CmdSequencerComponentAc.hpp

Go to the documentation of this file.

// ======================================================================
// \title  CmdSequencerComponentAc.hpp
// \author Auto-generated
// \brief  hpp file for CmdSequencer component base class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================
 
#ifndef CMDSEQUENCER_COMP_HPP_
#define CMDSEQUENCER_COMP_HPP_
 
#include <FpConfig.hpp>
#include <Fw/Port/InputSerializePort.hpp>
#include <Fw/Port/OutputSerializePort.hpp>
#include <Fw/Comp/ActiveComponentBase.hpp>
#include <Fw/Cmd/CmdString.hpp>
#include <Fw/Tlm/TlmString.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Log/LogString.hpp>
#include <Fw/Time/Time.hpp>
#include <Fw/Log/TextLogString.hpp>
#include <Fw/Tlm/TlmBuffer.hpp>
#include <Fw/Com/ComBuffer.hpp>
#include <Fw/Cmd/CmdArgBuffer.hpp>
#include <Fw/Types/EightyCharString.hpp>
#include <Fw/Log/LogBuffer.hpp>
#include <Fw/Cmd/CmdRegPortAc.hpp>
#if FW_ENABLE_TEXT_LOGGING == 1
#include <Fw/Log/LogTextPortAc.hpp>
#endif
#include <Svc/Ping/PingPortAc.hpp>
#include <Fw/Tlm/TlmPortAc.hpp>
#include <Fw/Cmd/CmdResponsePortAc.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Com/ComPortAc.hpp>
#include <Fw/Cmd/CmdPortAc.hpp>
#include <Svc/Sched/SchedPortAc.hpp>
#include <Svc/Seq/CmdSeqInPortAc.hpp>
#include <Fw/Log/LogPortAc.hpp>
 
namespace Svc {
 
  class CmdSequencerComponentBase :
    public Fw::ActiveComponentBase
  {
 
    // ----------------------------------------------------------------------
    // Friend classes
    // ----------------------------------------------------------------------
 
    friend class CmdSequencerComponentBaseFriend;
 
  public:
 
    // ----------------------------------------------------------------------
    // Getters for typed input ports
    // ----------------------------------------------------------------------
 
    Svc::InputPingPort* get_pingIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Fw::InputCmdResponsePort* get_cmdResponseIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Fw::InputCmdPort* get_cmdIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Svc::InputSchedPort* get_schedIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Svc::InputCmdSeqInPort* get_seqRunIn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect typed input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_cmdRegOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdRegPort *port 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    void set_LogText_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogTextPort *port 
    );
#endif
 
    void set_tlmOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTlmPort *port 
    );
 
    void set_cmdResponseOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdResponsePort *port 
    );
 
    void set_timeCaller_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTimePort *port 
    );
 
    void set_comCmdOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputComPort *port 
    );
 
    void set_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputPingPort *port 
    );
 
    void set_logOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogPort *port 
    );
 
    void set_seqDone_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdResponsePort *port 
    );
 
#if FW_PORT_SERIALIZATION
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect serialization input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_cmdRegOut_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
 
    void set_tlmOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_cmdResponseOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_timeCaller_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_comCmdOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_logOut_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_seqDone_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
#endif
 
  public:
 
    // ----------------------------------------------------------------------
    // Command registration
    // ----------------------------------------------------------------------
 
    void regCommands(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Component construction, initialization, and destruction
    // ----------------------------------------------------------------------
 
#if FW_OBJECT_NAMES == 1
    CmdSequencerComponentBase(
        const char* compName 
    );
#else
    CmdSequencerComponentBase(void);
#endif
 
    void init(
        NATIVE_INT_TYPE queueDepth, 
        NATIVE_INT_TYPE instance = 0 
    );
 
    virtual ~CmdSequencerComponentBase(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------
 
    //
    virtual void pingIn_handler(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    ) = 0;
 
    //
    virtual void cmdResponseIn_handler(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    ) = 0;
 
    //
    virtual void schedIn_handler(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    ) = 0;
 
    //
    virtual void seqRunIn_handler(
        NATIVE_INT_TYPE portNum, 
        Fw::EightyCharString &filename 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Port handler base-class functions for typed input ports.
    // ----------------------------------------------------------------------
    // Call these functions directly to bypass the corresponding ports.
    // ----------------------------------------------------------------------
 
    void pingIn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    void cmdResponseIn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
    void schedIn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
    void seqRunIn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        Fw::EightyCharString &filename 
    );
 
  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 pingIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    virtual void cmdResponseIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
    virtual void schedIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
    virtual void seqRunIn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        Fw::EightyCharString &filename 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Invocation functions for typed output ports
    // ----------------------------------------------------------------------
 
    void comCmdOut_out(
        NATIVE_INT_TYPE portNum, 
        Fw::ComBuffer &data, 
        U32 context 
    );
 
    void pingOut_out(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    void seqDone_out(
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of input ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_pingIn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_cmdResponseIn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_cmdIn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_schedIn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_seqRunIn_InputPorts(void);
 
 
    // ----------------------------------------------------------------------
    // Enumerations for number of ports
    // ----------------------------------------------------------------------
 
    enum {
       NUM_PINGIN_INPUT_PORTS = 1,
       NUM_CMDRESPONSEIN_INPUT_PORTS = 1,
       NUM_CMDIN_INPUT_PORTS = 1,
       NUM_SCHEDIN_INPUT_PORTS = 1,
       NUM_SEQRUNIN_INPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of output ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_cmdRegOut_OutputPorts(void);
 
#if FW_ENABLE_TEXT_LOGGING == 1
    NATIVE_INT_TYPE getNum_LogText_OutputPorts(void);
#endif
 
    NATIVE_INT_TYPE getNum_tlmOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_cmdResponseOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_timeCaller_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_comCmdOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_pingOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_logOut_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_seqDone_OutputPorts(void);
 
 
    enum {
       NUM_CMDREGOUT_OUTPUT_PORTS = 1,
       NUM_LOGTEXT_OUTPUT_PORTS = 1,
       NUM_TLMOUT_OUTPUT_PORTS = 1,
       NUM_CMDRESPONSEOUT_OUTPUT_PORTS = 1,
       NUM_TIMECALLER_OUTPUT_PORTS = 1,
       NUM_COMCMDOUT_OUTPUT_PORTS = 1,
       NUM_PINGOUT_OUTPUT_PORTS = 1,
       NUM_LOGOUT_OUTPUT_PORTS = 1,
       NUM_SEQDONE_OUTPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Connection status queries for output ports
    // ----------------------------------------------------------------------
 
    bool isConnected_cmdRegOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    bool isConnected_LogText_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
#endif
 
    bool isConnected_tlmOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_cmdResponseOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_timeCaller_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_comCmdOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_pingOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_logOut_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_seqDone_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command opcodes
    // ----------------------------------------------------------------------
 
    enum {
      OPCODE_CS_RUN = 0, /* Run a command sequence file */
      OPCODE_CS_VALIDATE = 1, /* Validate a command sequence file */
      OPCODE_CS_CANCEL = 2, /* Cancel a command sequence */
      OPCODE_CS_START = 3, /* Start running a command sequence */
      OPCODE_CS_STEP = 4, /* Perform one step in a command sequence. Valid only if CmdSequencer is in MANUAL run mode. */
      OPCODE_CS_AUTO = 5, /* Set the run mode to AUTO. */
      OPCODE_CS_MANUAL = 6, /* Set the run mode to MANUAL. */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handlers to implement
    // ----------------------------------------------------------------------
 
    /* Run a command sequence file */
    virtual void CS_RUN_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& fileName 
    ) = 0;
 
    /* Validate a command sequence file */
    virtual void CS_VALIDATE_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& fileName 
    ) = 0;
 
    /* Cancel a command sequence */
    virtual void CS_CANCEL_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    ) = 0;
 
    /* Start running a command sequence */
    virtual void CS_START_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    ) = 0;
 
    /* Perform one step in a command sequence. Valid only if CmdSequencer is in MANUAL run mode. */
    virtual void CS_STEP_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    ) = 0;
 
    /* Set the run mode to AUTO. */
    virtual void CS_AUTO_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    ) = 0;
 
    /* Set the run mode to MANUAL. */
    virtual void CS_MANUAL_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 CS_RUN_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CS_VALIDATE_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CS_CANCEL_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CS_START_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CS_STEP_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CS_AUTO_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void CS_MANUAL_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handler base-class functions.
    // Call these functions directly to bypass the command input port.
    // ----------------------------------------------------------------------
 
    void CS_RUN_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CS_VALIDATE_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CS_CANCEL_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CS_START_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CS_STEP_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CS_AUTO_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void CS_MANUAL_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_CS_SEQUENCELOADED = 0, /* Sequence file was successfully loaded. */
      EVENTID_CS_SEQUENCECANCELED = 1, /* A command sequence was successfully canceled. */
      EVENTID_CS_FILEREADERROR = 2, /* The Sequence File Loader could not read the sequence file. */
      EVENTID_CS_FILEINVALID = 3, /* The sequence file format was invalid. */
      EVENTID_CS_RECORDINVALID = 4, /* The format of a command record was invalid. */
      EVENTID_CS_FILESIZEERROR = 5, /* The sequence file was too large. */
      EVENTID_CS_FILENOTFOUND = 6, /* The sequence file was not found */
      EVENTID_CS_FILECRCFAILURE = 7, /* The sequence file validation failed */
      EVENTID_CS_COMMANDCOMPLETE = 8, /* The Command Sequencer issued a command and received a success status in return. */
      EVENTID_CS_SEQUENCECOMPLETE = 9, /* A command sequence successfully completed. */
      EVENTID_CS_COMMANDERROR = 10, /* The Command Sequencer issued a command and received an error status in return. */
      EVENTID_CS_INVALIDMODE = 11, /* The Command Sequencer received a command that was invalid for its current mode. */
      EVENTID_CS_RECORDMISMATCH = 12, /* Number of records in header doesn't match number in file */
      EVENTID_CS_TIMEBASEMISMATCH = 13, /* The running time base doesn't match the time base in the sequence files */
      EVENTID_CS_TIMECONTEXTMISMATCH = 14, /* The running time base doesn't match the time base in the sequence files */
      EVENTID_CS_PORTSEQUENCESTARTED = 15, /* A local port request to run a sequence was started */
      EVENTID_CS_UNEXPECTEDCOMPLETION = 16, /* A command status came back when no sequence was running */
      EVENTID_CS_MODESWITCHED = 17, /* Switched step mode */
      EVENTID_CS_NOSEQUENCEACTIVE = 18, /* A sequence related command came with no active sequence */
      EVENTID_CS_SEQUENCEVALID = 19, /* A sequence passed validation */
      EVENTID_CS_SEQUENCETIMEOUT = 20, /* A sequence passed validation */
      EVENTID_CS_CMDSTEPPED = 21, /* A commmand in a sequence was stepped through */
      EVENTID_CS_CMDSTARTED = 22, /* A manual sequence was started */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event enums
    // ----------------------------------------------------------------------
 
    typedef enum {
      SEQ_READ_HEADER, /*  */
      SEQ_READ_HEADER_SIZE, /*  */
      SEQ_DESER_SIZE, /*  */
      SEQ_DESER_NUM_RECORDS, /*  */
      SEQ_DESER_TIME_BASE, /*  */
      SEQ_DESER_TIME_CONTEXT, /*  */
      SEQ_READ_SEQ_CRC, /*  */
      SEQ_READ_SEQ_DATA, /*  */
      SEQ_READ_SEQ_DATA_SIZE, /*  */
      FileReadStage_MAX
    } FileReadStage;
 
    typedef enum {
      SEQ_STEP_MODE, /*  */
      SEQ_AUTO_MODE, /*  */
      SeqMode_MAX
    } SeqMode;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event logging functions
    // ----------------------------------------------------------------------
 
    /* Sequence file was successfully loaded. */
    void log_ACTIVITY_LO_CS_SequenceLoaded(
        Fw::LogStringArg& fileName 
    );
 
 
    /* A command sequence was successfully canceled. */
    void log_ACTIVITY_HI_CS_SequenceCanceled(
        Fw::LogStringArg& fileName 
    );
 
 
    /* The Sequence File Loader could not read the sequence file. */
    void log_WARNING_HI_CS_FileReadError(
        Fw::LogStringArg& fileName 
    );
 
 
    /* The sequence file format was invalid. */
    void log_WARNING_HI_CS_FileInvalid(
        Fw::LogStringArg& fileName, 
        FileReadStage stage, 
        I32 error 
    );
 
 
    /* The format of a command record was invalid. */
    void log_WARNING_HI_CS_RecordInvalid(
        Fw::LogStringArg& fileName, 
        U32 recordNumber, 
        I32 error 
    );
 
 
    /* The sequence file was too large. */
    void log_WARNING_HI_CS_FileSizeError(
        Fw::LogStringArg& fileName, 
        U32 size 
    );
 
 
    /* The sequence file was not found */
    void log_WARNING_HI_CS_FileNotFound(
        Fw::LogStringArg& fileName 
    );
 
 
    /* The sequence file validation failed */
    void log_WARNING_HI_CS_FileCrcFailure(
        Fw::LogStringArg& fileName, 
        U32 storedCRC, 
        U32 computedCRC 
    );
 
 
    /* The Command Sequencer issued a command and received a success status in return. */
    void log_ACTIVITY_LO_CS_CommandComplete(
        Fw::LogStringArg& fileName, 
        U32 recordNumber, 
        U32 opCode 
    );
 
 
    /* A command sequence successfully completed. */
    void log_ACTIVITY_HI_CS_SequenceComplete(
        Fw::LogStringArg& fileName 
    );
 
 
    /* The Command Sequencer issued a command and received an error status in return. */
    void log_WARNING_HI_CS_CommandError(
        Fw::LogStringArg& fileName, 
        U32 recordNumber, 
        U32 opCode, 
        U32 errorStatus 
    );
 
 
    /* The Command Sequencer received a command that was invalid for its current mode. */
    void log_WARNING_HI_CS_InvalidMode(
        void
    );
 
 
    /* Number of records in header doesn't match number in file */
    void log_WARNING_HI_CS_RecordMismatch(
        Fw::LogStringArg& fileName, 
        U32 header_records, 
        U32 extra_bytes 
    );
 
 
    /* The running time base doesn't match the time base in the sequence files */
    void log_WARNING_HI_CS_TimeBaseMismatch(
        Fw::LogStringArg& fileName, 
        U16 time_base, 
        U16 seq_time_base 
    );
 
 
    /* The running time base doesn't match the time base in the sequence files */
    void log_WARNING_HI_CS_TimeContextMismatch(
        Fw::LogStringArg& fileName, 
        U8 currTimeBase, 
        U8 seqTimeBase 
    );
 
 
    /* A local port request to run a sequence was started */
    void log_ACTIVITY_HI_CS_PortSequenceStarted(
        Fw::LogStringArg& filename 
    );
 
 
    /* A command status came back when no sequence was running */
    void log_WARNING_HI_CS_UnexpectedCompletion(
        U32 opcode 
    );
 
 
    /* Switched step mode */
    void log_ACTIVITY_HI_CS_ModeSwitched(
        SeqMode mode 
    );
 
 
    /* A sequence related command came with no active sequence */
    void log_WARNING_LO_CS_NoSequenceActive(
        void
    );
 
 
    /* A sequence passed validation */
    void log_ACTIVITY_HI_CS_SequenceValid(
        Fw::LogStringArg& filename 
    );
 
 
    /* A sequence passed validation */
    void log_WARNING_HI_CS_SequenceTimeout(
        Fw::LogStringArg& filename, 
        U32 command 
    );
 
 
    /* A commmand in a sequence was stepped through */
    void log_ACTIVITY_HI_CS_CmdStepped(
        Fw::LogStringArg& filename, 
        U32 command 
    );
 
 
    /* A manual sequence was started */
    void log_ACTIVITY_HI_CS_CmdStarted(
        Fw::LogStringArg& filename 
    );
 
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Channel IDs
    // ----------------------------------------------------------------------
 
    enum {
      CHANNELID_CS_LOADCOMMANDS = 0, 
      CHANNELID_CS_CANCELCOMMANDS = 1, 
      CHANNELID_CS_ERRORS = 2, 
      CHANNELID_CS_COMMANDSEXECUTED = 3, 
      CHANNELID_CS_SEQUENCESCOMPLETED = 4, 
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Telemetry write functions
    // ----------------------------------------------------------------------
 
    /* The number of Load commands executed */
    void tlmWrite_CS_LoadCommands(
        U32 arg 
    );
 
    /* The number of Cancel commands executed */
    void tlmWrite_CS_CancelCommands(
        U32 arg 
    );
 
    /* The number of errors that have occurred */
    void tlmWrite_CS_Errors(
        U32 arg 
    );
 
    /* The number of commands executed across all sequences. */
    void tlmWrite_CS_CommandsExecuted(
        U32 arg 
    );
 
    /* The number of sequences completed. */
    void tlmWrite_CS_SequencesCompleted(
        U32 arg 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Time
    // ----------------------------------------------------------------------
 
    Fw::Time getTime(void);
 
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed input ports
    // ----------------------------------------------------------------------
 
    Svc::InputPingPort m_pingIn_InputPort[NUM_PINGIN_INPUT_PORTS];
 
    Fw::InputCmdResponsePort m_cmdResponseIn_InputPort[NUM_CMDRESPONSEIN_INPUT_PORTS];
 
    Fw::InputCmdPort m_cmdIn_InputPort[NUM_CMDIN_INPUT_PORTS];
 
    Svc::InputSchedPort m_schedIn_InputPort[NUM_SCHEDIN_INPUT_PORTS];
 
    Svc::InputCmdSeqInPort m_seqRunIn_InputPort[NUM_SEQRUNIN_INPUT_PORTS];
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed output ports
    // ----------------------------------------------------------------------
 
    Fw::OutputCmdRegPort m_cmdRegOut_OutputPort[NUM_CMDREGOUT_OUTPUT_PORTS];
 
#if FW_ENABLE_TEXT_LOGGING == 1
    Fw::OutputLogTextPort m_LogText_OutputPort[NUM_LOGTEXT_OUTPUT_PORTS];
#endif
 
    Fw::OutputTlmPort m_tlmOut_OutputPort[NUM_TLMOUT_OUTPUT_PORTS];
 
    Fw::OutputCmdResponsePort m_cmdResponseOut_OutputPort[NUM_CMDRESPONSEOUT_OUTPUT_PORTS];
 
    Fw::OutputTimePort m_timeCaller_OutputPort[NUM_TIMECALLER_OUTPUT_PORTS];
 
    Fw::OutputComPort m_comCmdOut_OutputPort[NUM_COMCMDOUT_OUTPUT_PORTS];
 
    Svc::OutputPingPort m_pingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS];
 
    Fw::OutputLogPort m_logOut_OutputPort[NUM_LOGOUT_OUTPUT_PORTS];
 
    Fw::OutputCmdResponsePort m_seqDone_OutputPort[NUM_SEQDONE_OUTPUT_PORTS];
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Calls for messages received on typed input ports
    // ----------------------------------------------------------------------
 
    static void m_p_pingIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    static void m_p_cmdResponseIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
    static void m_p_cmdIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    static void m_p_schedIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
    static void m_p_seqRunIn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        Fw::EightyCharString &filename 
    );
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Message dispatch functions
    // ----------------------------------------------------------------------
 
    virtual MsgDispatchStatus doDispatch(void);
 
 
  PRIVATE:
    // ----------------------------------------------------------------------
    // Counter values for event throttling
    // ----------------------------------------------------------------------
 
  };
 
} // end namespace Svc
#endif