CommandDispatcherComponentAc.hpp

Go to the documentation of this file.

// ======================================================================
// \title  CommandDispatcherComponentAc.hpp
// \author Auto-generated
// \brief  hpp file for CommandDispatcher component base class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================
 
#ifndef COMMANDDISPATCHER_COMP_HPP_
#define COMMANDDISPATCHER_COMP_HPP_
 
#include <FpConfig.hpp>
#include <Fw/Port/InputSerializePort.hpp>
#include <Fw/Port/OutputSerializePort.hpp>
#include <Fw/Comp/ActiveComponentBase.hpp>
#include <Os/Mutex.hpp>
#include <Fw/Cmd/CmdString.hpp>
#include <Fw/Tlm/TlmString.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Log/LogString.hpp>
#include <Fw/Cmd/CmdArgBuffer.hpp>
#include <Fw/Com/ComBuffer.hpp>
#include <Fw/Tlm/TlmBuffer.hpp>
#include <Fw/Time/Time.hpp>
#include <Fw/Log/LogBuffer.hpp>
#include <Fw/Log/TextLogString.hpp>
#include <Fw/Cmd/CmdPortAc.hpp>
#include <Fw/Cmd/CmdResponsePortAc.hpp>
#include <Fw/Cmd/CmdRegPortAc.hpp>
#include <Fw/Com/ComPortAc.hpp>
#include <Svc/Ping/PingPortAc.hpp>
#include <Fw/Tlm/TlmPortAc.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Log/LogPortAc.hpp>
#if FW_ENABLE_TEXT_LOGGING == 1
#include <Fw/Log/LogTextPortAc.hpp>
#endif
 
namespace Svc {
 
  class CommandDispatcherComponentBase :
    public Fw::ActiveComponentBase
  {
 
    // ----------------------------------------------------------------------
    // Friend classes
    // ----------------------------------------------------------------------
 
    friend class CommandDispatcherComponentBaseFriend;
 
  public:
 
    // ----------------------------------------------------------------------
    // Getters for typed input ports
    // ----------------------------------------------------------------------
 
    Fw::InputCmdRegPort* get_compCmdReg_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Fw::InputCmdResponsePort* get_compCmdStat_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Fw::InputComPort* get_seqCmdBuff_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Svc::InputPingPort* get_pingIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Fw::InputCmdPort* get_CmdDisp_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect typed input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_compCmdSend_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdPort *port 
    );
 
    void set_seqCmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdResponsePort *port 
    );
 
    void set_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputPingPort *port 
    );
 
    void set_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdResponsePort *port 
    );
 
    void set_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdRegPort *port 
    );
 
    void set_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTlmPort *port 
    );
 
    void set_Time_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTimePort *port 
    );
 
    void set_Log_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogPort *port 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    void set_LogText_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogTextPort *port 
    );
#endif
 
#if FW_PORT_SERIALIZATION
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect serialization input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_compCmdSend_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_seqCmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_CmdReg_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 
    );
 
    void set_Log_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    void set_LogText_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
#endif
 
#endif
 
  public:
 
    // ----------------------------------------------------------------------
    // Command registration
    // ----------------------------------------------------------------------
 
    void regCommands(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Component construction, initialization, and destruction
    // ----------------------------------------------------------------------
 
#if FW_OBJECT_NAMES == 1
    CommandDispatcherComponentBase(
        const char* compName 
    );
#else
    CommandDispatcherComponentBase(void);
#endif
 
    void init(
        NATIVE_INT_TYPE queueDepth, 
        NATIVE_INT_TYPE instance = 0 
    );
 
    virtual ~CommandDispatcherComponentBase(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // ----------------------------------------------------------------------
    // ----------------------------------------------------------------------
 
    virtual void lock(void);
 
    virtual void unLock(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------
 
    //
    virtual void compCmdReg_handler(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode 
    ) = 0;
 
    //
    virtual void compCmdStat_handler(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    ) = 0;
 
    //
    virtual void seqCmdBuff_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::ComBuffer &data, 
        U32 context 
    ) = 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 compCmdReg_handlerBase(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode 
    );
 
    void compCmdStat_handlerBase(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
    void seqCmdBuff_handlerBase(
        NATIVE_INT_TYPE portNum, 
        Fw::ComBuffer &data, 
        U32 context 
    );
 
    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 compCmdStat_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
    virtual void seqCmdBuff_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        Fw::ComBuffer &data, 
        U32 context 
    );
 
    virtual void pingIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Invocation functions for typed output ports
    // ----------------------------------------------------------------------
 
    void compCmdSend_out(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void seqCmdStatus_out(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
    void pingOut_out(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of input ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_compCmdReg_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_compCmdStat_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_seqCmdBuff_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_pingIn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdDisp_InputPorts(void);
 
 
    // ----------------------------------------------------------------------
    // Enumerations for number of ports
    // ----------------------------------------------------------------------
 
    enum {
       NUM_COMPCMDREG_INPUT_PORTS = 30          ,
       NUM_COMPCMDSTAT_INPUT_PORTS = 1,
       NUM_SEQCMDBUFF_INPUT_PORTS = 5           ,
       NUM_PINGIN_INPUT_PORTS = 1,
       NUM_CMDDISP_INPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of output ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_compCmdSend_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_seqCmdStatus_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_pingOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdStatus_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdReg_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Tlm_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Time_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Log_OutputPorts(void);
 
#if FW_ENABLE_TEXT_LOGGING == 1
    NATIVE_INT_TYPE getNum_LogText_OutputPorts(void);
#endif
 
 
    enum {
       NUM_COMPCMDSEND_OUTPUT_PORTS = 30          ,
       NUM_SEQCMDSTATUS_OUTPUT_PORTS = 5           ,
       NUM_PINGOUT_OUTPUT_PORTS = 1,
       NUM_CMDSTATUS_OUTPUT_PORTS = 1,
       NUM_CMDREG_OUTPUT_PORTS = 1,
       NUM_TLM_OUTPUT_PORTS = 1,
       NUM_TIME_OUTPUT_PORTS = 1,
       NUM_LOG_OUTPUT_PORTS = 1,
       NUM_LOGTEXT_OUTPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Connection status queries for output ports
    // ----------------------------------------------------------------------
 
    bool isConnected_compCmdSend_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_seqCmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Time_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Log_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    bool isConnected_LogText_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
#endif
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command opcodes
    // ----------------------------------------------------------------------
 
    enum {
      OPCODE_CMD_NO_OP = 0, /* No-op command */
      OPCODE_CMD_NO_OP_STRING = 1, /* No-op string command */
      OPCODE_CMD_TEST_CMD_1 = 2, /* No-op command */
      OPCODE_CMD_CLEAR_TRACKING = 3, /* Clear command tracking info to recover from components not returning status */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handlers to implement
    // ----------------------------------------------------------------------
 
    /* No-op command */
    virtual void CMD_NO_OP_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    ) = 0;
 
    /* No-op string command */
    virtual void CMD_NO_OP_STRING_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& arg1 
    ) = 0;
 
    /* No-op command */
    virtual void CMD_TEST_CMD_1_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        I32 arg1, 
        F32 arg2, 
        U8 arg3 
    ) = 0;
 
    /* Clear command tracking info to recover from components not returning status */
    virtual void CMD_CLEAR_TRACKING_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Pre-message hooks for async commands.
    // ----------------------------------------------------------------------
    // Each of these functions is invoked just before processing the
    // corresponding command. By default they do nothing. You can
    // override them to provide specific pre-command behavior.
    // ----------------------------------------------------------------------
 
    virtual void CMD_NO_OP_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CMD_NO_OP_STRING_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CMD_TEST_CMD_1_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CMD_CLEAR_TRACKING_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handler base-class functions.
    // Call these functions directly to bypass the command input port.
    // ----------------------------------------------------------------------
 
    void CMD_NO_OP_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CMD_NO_OP_STRING_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CMD_TEST_CMD_1_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CMD_CLEAR_TRACKING_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command response
    // ----------------------------------------------------------------------
 
    void cmdResponse_out(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event IDs
    // ----------------------------------------------------------------------
 
    enum {
      EVENTID_OPCODEREGISTERED = 0, /* Op code registered event */
      EVENTID_OPCODEDISPATCHED = 1, /* Op code dispatched event */
      EVENTID_OPCODECOMPLETED = 2, /* Op code completed event */
      EVENTID_OPCODEERROR = 3, /* Op code completed with error event */
      EVENTID_MALFORMEDCOMMAND = 4, /* Received a malformed command packet */
      EVENTID_INVALIDCOMMAND = 5, /* Received an invalid opcode */
      EVENTID_TOOMANYCOMMANDS = 6, /* Exceeded the number of commands that can be simultaneously executed */
      EVENTID_NOOPRECEIVED = 7, /* The command dispatcher has successfully recieved a NO-OP command */
      EVENTID_NOOPSTRINGRECEIVED = 8, /* The command dispatcher has successfully recieved a NO-OP command from GUI with a string */
      EVENTID_TESTCMD1ARGS = 9, /* This log event message returns the TEST_CMD_1 arguments. */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event enums
    // ----------------------------------------------------------------------
 
    typedef enum {
      ERR_INVALID_OPCODE, /*  //<! Invalid opcode dispatched */
      ERR_VALIDATION_ERROR, /*  //<! Command failed validation */
      ERR_FORMAT_ERROR, /*  //<! Command failed to deserialize */
      ERR_EXECUTION_ERROR, /*  //<! Command had execution error */
      ERR_BUSY, /*  //<! Component busy */
      ERR_UNEXP, /*  //<! Unexpected response */
      ErrorResponse_MAX
    } ErrorResponse;
 
    typedef enum {
      ERR_BUFFER_TOO_SMALL, /*  //<! Buffer too small */
      ERR_BUFFER_FORMAT, /*  //<! Buffer wrong format */
      ERR_SIZE_MISMATCH, /*  //<! Buffer size mismatch */
      ERR_TYPE_MISMATCH, /*  //<! Buffer type mismatch */
      ERR_UNEXP_STAT, /*  //<! Unexpected status */
      CmdSerError_MAX
    } CmdSerError;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event logging functions
    // ----------------------------------------------------------------------
 
    /* Op code registered event */
    void log_DIAGNOSTIC_OpCodeRegistered(
        U32 Opcode, 
        I32 port, 
        I32 slot 
    );
 
 
    /* Op code dispatched event */
    void log_COMMAND_OpCodeDispatched(
        U32 Opcode, 
        I32 port 
    );
 
 
    /* Op code completed event */
    void log_COMMAND_OpCodeCompleted(
        U32 Opcode 
    );
 
 
    /* Op code completed with error event */
    void log_WARNING_HI_OpCodeError(
        U32 Opcode, 
        ErrorResponse error 
    );
 
 
    /* Received a malformed command packet */
    void log_WARNING_HI_MalformedCommand(
        CmdSerError Status 
    );
 
 
    /* Received an invalid opcode */
    void log_WARNING_HI_InvalidCommand(
        U32 Opcode 
    );
 
 
    /* Exceeded the number of commands that can be simultaneously executed */
    void log_WARNING_HI_TooManyCommands(
        U32 Opcode 
    );
 
 
    /* The command dispatcher has successfully recieved a NO-OP command */
    void log_ACTIVITY_HI_NoOpReceived(
        void
    );
 
 
    /* The command dispatcher has successfully recieved a NO-OP command from GUI with a string */
    void log_ACTIVITY_HI_NoOpStringReceived(
        Fw::LogStringArg& message 
    );
 
 
    /* This log event message returns the TEST_CMD_1 arguments. */
    void log_ACTIVITY_HI_TestCmd1Args(
        I32 arg1, 
        F32 arg2, 
        U8 arg3 
    );
 
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Channel IDs
    // ----------------------------------------------------------------------
 
    enum {
      CHANNELID_COMMANDSDISPATCHED = 0, 
      CHANNELID_COMMANDERRORS = 1, 
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Telemetry write functions
    // ----------------------------------------------------------------------
 
    /* Number of commands dispatched */
    void tlmWrite_CommandsDispatched(
        U32 arg 
    );
 
    /* Number of command errors */
    void tlmWrite_CommandErrors(
        U32 arg 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Time
    // ----------------------------------------------------------------------
 
    Fw::Time getTime(void);
 
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed input ports
    // ----------------------------------------------------------------------
 
    Fw::InputCmdRegPort m_compCmdReg_InputPort[NUM_COMPCMDREG_INPUT_PORTS];
 
    Fw::InputCmdResponsePort m_compCmdStat_InputPort[NUM_COMPCMDSTAT_INPUT_PORTS];
 
    Fw::InputComPort m_seqCmdBuff_InputPort[NUM_SEQCMDBUFF_INPUT_PORTS];
 
    Svc::InputPingPort m_pingIn_InputPort[NUM_PINGIN_INPUT_PORTS];
 
    Fw::InputCmdPort m_CmdDisp_InputPort[NUM_CMDDISP_INPUT_PORTS];
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed output ports
    // ----------------------------------------------------------------------
 
    Fw::OutputCmdPort m_compCmdSend_OutputPort[NUM_COMPCMDSEND_OUTPUT_PORTS];
 
    Fw::OutputCmdResponsePort m_seqCmdStatus_OutputPort[NUM_SEQCMDSTATUS_OUTPUT_PORTS];
 
    Svc::OutputPingPort m_pingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS];
 
    Fw::OutputCmdResponsePort m_CmdStatus_OutputPort[NUM_CMDSTATUS_OUTPUT_PORTS];
 
    Fw::OutputCmdRegPort m_CmdReg_OutputPort[NUM_CMDREG_OUTPUT_PORTS];
 
    Fw::OutputTlmPort m_Tlm_OutputPort[NUM_TLM_OUTPUT_PORTS];
 
    Fw::OutputTimePort m_Time_OutputPort[NUM_TIME_OUTPUT_PORTS];
 
    Fw::OutputLogPort m_Log_OutputPort[NUM_LOG_OUTPUT_PORTS];
 
#if FW_ENABLE_TEXT_LOGGING == 1
    Fw::OutputLogTextPort m_LogText_OutputPort[NUM_LOGTEXT_OUTPUT_PORTS];
#endif
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Calls for messages received on typed input ports
    // ----------------------------------------------------------------------
 
    static void m_p_compCmdReg_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode 
    );
 
    static void m_p_compCmdStat_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
    static void m_p_seqCmdBuff_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        Fw::ComBuffer &data, 
        U32 context 
    );
 
    static void m_p_pingIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    static void m_p_CmdDisp_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Message dispatch functions
    // ----------------------------------------------------------------------
 
    virtual MsgDispatchStatus doDispatch(void);
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Mutexes
    // ----------------------------------------------------------------------
 
    Os::Mutex m_guardedPortMutex;
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // First update flags for telemetry channels
    // ----------------------------------------------------------------------
 
    bool m_first_update_CommandsDispatched;
 
    bool m_first_update_CommandErrors;
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Last value storage for telemetry channels
    // ----------------------------------------------------------------------
 
    U32 m_last_CommandsDispatched;
 
    U32 m_last_CommandErrors;
 
 
  PRIVATE:
    // ----------------------------------------------------------------------
    // Counter values for event throttling
    // ----------------------------------------------------------------------
 
  };
 
} // end namespace Svc
#endif