BlockDriverComponentAc.hpp

Go to the documentation of this file.

// ======================================================================
// \title  BlockDriverComponentAc.hpp
// \author Auto-generated
// \brief  hpp file for BlockDriver component base class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================
 
#ifndef BLOCKDRIVER_COMP_HPP_
#define BLOCKDRIVER_COMP_HPP_
 
#include <FpConfig.hpp>
#include <Fw/Port/InputSerializePort.hpp>
#include <Fw/Port/OutputSerializePort.hpp>
#include <Fw/Comp/ActiveComponentBase.hpp>
#include <Fw/Tlm/TlmString.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Types/InternalInterfaceString.hpp>
#include <Drv/DataTypes/DataBuffer.hpp>
#include <Svc/Cycle/TimerVal.hpp>
#include <Fw/Tlm/TlmBuffer.hpp>
#include <Fw/Time/Time.hpp>
#include <Svc/Sched/SchedPortAc.hpp>
#include <Svc/Cycle/CyclePortAc.hpp>
#include <Drv/DataTypes/DataBufferPortAc.hpp>
#include <Svc/Ping/PingPortAc.hpp>
#include <Fw/Tlm/TlmPortAc.hpp>
#include <Fw/Time/TimePortAc.hpp>
 
namespace Drv {
 
  class BlockDriverComponentBase :
    public Fw::ActiveComponentBase
  {
 
    // ----------------------------------------------------------------------
    // Friend classes
    // ----------------------------------------------------------------------
 
    friend class BlockDriverComponentBaseFriend;
 
  public:
 
    // ----------------------------------------------------------------------
    // Getters for typed input ports
    // ----------------------------------------------------------------------
 
    Svc::InputSchedPort* get_Sched_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Drv::InputDataBufferPort* get_BufferIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Svc::InputPingPort* get_PingIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect typed input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_CycleOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputCyclePort *port 
    );
 
    void set_BufferOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Drv::InputDataBufferPort *port 
    );
 
    void set_PingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputPingPort *port 
    );
 
    void set_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTlmPort *port 
    );
 
    void set_Time_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTimePort *port 
    );
 
#if FW_PORT_SERIALIZATION
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect serialization input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_CycleOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_BufferOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_PingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_Time_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
#endif
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Component construction, initialization, and destruction
    // ----------------------------------------------------------------------
 
#if FW_OBJECT_NAMES == 1
    BlockDriverComponentBase(
        const char* compName 
    );
#else
    BlockDriverComponentBase(void);
#endif
 
    void init(
        NATIVE_INT_TYPE queueDepth, 
        NATIVE_INT_TYPE instance = 0 
    );
 
    virtual ~BlockDriverComponentBase(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------
 
    //
    virtual void Sched_handler(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    ) = 0;
 
    //
    virtual void BufferIn_handler(
        NATIVE_INT_TYPE portNum, 
        Drv::DataBuffer &buff 
    ) = 0;
 
    //
    virtual void PingIn_handler(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Port handler base-class functions for typed input ports.
    // ----------------------------------------------------------------------
    // Call these functions directly to bypass the corresponding ports.
    // ----------------------------------------------------------------------
 
    void Sched_handlerBase(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
    void BufferIn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        Drv::DataBuffer &buff 
    );
 
    void PingIn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Pre-message hooks for typed async input ports.
    // ----------------------------------------------------------------------
    // Each of these functions is invoked just before processing a message
    // on the corresponding port. By default they do nothing. You can
    // override them to provide specific pre-message behavior.
    // ----------------------------------------------------------------------
 
    virtual void Sched_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
    virtual void BufferIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        Drv::DataBuffer &buff 
    );
 
    virtual void PingIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Invocation functions for typed output ports
    // ----------------------------------------------------------------------
 
    void CycleOut_out(
        NATIVE_INT_TYPE portNum, 
        Svc::TimerVal &cycleStart 
    );
 
    void BufferOut_out(
        NATIVE_INT_TYPE portNum, 
        Drv::DataBuffer &buff 
    );
 
    void PingOut_out(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of input ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_Sched_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_BufferIn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_PingIn_InputPorts(void);
 
 
    // ----------------------------------------------------------------------
    // Enumerations for number of ports
    // ----------------------------------------------------------------------
 
    enum {
       NUM_SCHED_INPUT_PORTS = 1,
       NUM_BUFFERIN_INPUT_PORTS = 1,
       NUM_PINGIN_INPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of output ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_CycleOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_BufferOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_PingOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Tlm_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Time_OutputPorts(void);
 
 
    enum {
       NUM_CYCLEOUT_OUTPUT_PORTS = 1,
       NUM_BUFFEROUT_OUTPUT_PORTS = 1,
       NUM_PINGOUT_OUTPUT_PORTS = 1,
       NUM_TLM_OUTPUT_PORTS = 1,
       NUM_TIME_OUTPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Connection status queries for output ports
    // ----------------------------------------------------------------------
 
    bool isConnected_CycleOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_BufferOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_PingOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Time_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event logging functions
    // ----------------------------------------------------------------------
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Channel IDs
    // ----------------------------------------------------------------------
 
    enum {
      CHANNELID_BD_CYCLES = 0, 
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Telemetry write functions
    // ----------------------------------------------------------------------
 
    /* Driver cycle count */
    void tlmWrite_BD_Cycles(
        U32 arg 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Time
    // ----------------------------------------------------------------------
 
    Fw::Time getTime(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Internal interface handlers
    // ----------------------------------------------------------------------
 
    virtual void InterruptReport_internalInterfaceHandler(
        U32 interrupt 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Internal interface base-class functions
    // ----------------------------------------------------------------------
 
    void InterruptReport_internalInterfaceInvoke(
        U32 interrupt 
    );
 
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed input ports
    // ----------------------------------------------------------------------
 
    Svc::InputSchedPort m_Sched_InputPort[NUM_SCHED_INPUT_PORTS];
 
    Drv::InputDataBufferPort m_BufferIn_InputPort[NUM_BUFFERIN_INPUT_PORTS];
 
    Svc::InputPingPort m_PingIn_InputPort[NUM_PINGIN_INPUT_PORTS];
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed output ports
    // ----------------------------------------------------------------------
 
    Svc::OutputCyclePort m_CycleOut_OutputPort[NUM_CYCLEOUT_OUTPUT_PORTS];
 
    Drv::OutputDataBufferPort m_BufferOut_OutputPort[NUM_BUFFEROUT_OUTPUT_PORTS];
 
    Svc::OutputPingPort m_PingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS];
 
    Fw::OutputTlmPort m_Tlm_OutputPort[NUM_TLM_OUTPUT_PORTS];
 
    Fw::OutputTimePort m_Time_OutputPort[NUM_TIME_OUTPUT_PORTS];
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Calls for messages received on typed input ports
    // ----------------------------------------------------------------------
 
    static void m_p_Sched_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
    static void m_p_BufferIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        Drv::DataBuffer &buff 
    );
 
    static void m_p_PingIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Message dispatch functions
    // ----------------------------------------------------------------------
 
    virtual MsgDispatchStatus doDispatch(void);
 
 
 
  };
 
} // end namespace Drv
#endif