FpySequencerComponentAc.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FpySequencerComponentAc.hpp
// \author Generated by fpp-to-cpp
// \brief  hpp file for FpySequencer component base class
// ======================================================================

#ifndef Svc_FpySequencerComponentAc_HPP
#define Svc_FpySequencerComponentAc_HPP

#include <atomic>

#include "Fw/Cmd/CmdPortAc.hpp"
#include "Fw/Cmd/CmdRegPortAc.hpp"
#include "Fw/Cmd/CmdResponseEnumAc.hpp"
#include "Fw/Cmd/CmdResponsePortAc.hpp"
#include "Fw/Cmd/CmdString.hpp"
#include "Fw/Com/ComPortAc.hpp"
#include "Fw/Comp/ActiveComponentBase.hpp"
#include "Fw/FPrimeBasicTypes.hpp"
#include "Fw/Log/LogPortAc.hpp"
#include "Fw/Log/LogString.hpp"
#include "Fw/Log/LogTextPortAc.hpp"
#if !FW_DIRECT_PORT_CALLS
#include "Fw/Port/InputSerializePort.hpp"
#endif
#if !FW_DIRECT_PORT_CALLS
#include "Fw/Port/OutputSerializePort.hpp"
#endif
#include "Fw/Prm/PrmGetPortAc.hpp"
#include "Fw/Prm/PrmSetPortAc.hpp"
#include "Fw/Prm/PrmString.hpp"
#include "Fw/Time/TimePortAc.hpp"
#include "Fw/Tlm/TlmGetPortAc.hpp"
#include "Fw/Tlm/TlmPortAc.hpp"
#include "Fw/Tlm/TlmString.hpp"
#include "Fw/Types/InternalInterfaceString.hpp"
#include "Os/Mutex.hpp"
#include "Svc/FpySequencer/DirectiveErrorCodeEnumAc.hpp"
#include "Svc/FpySequencer/DirectiveIdEnumAc.hpp"
#include "Svc/FpySequencer/FpySequencer_AllocateDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_BreakpointArgsSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_CallDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_ConstCmdDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_DiscardDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_ExitDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_FileReadStageEnumAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GetFieldDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GotoDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_IfDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_LoadAbsDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_LoadRelDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_MemCmpDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_NoOpDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PeekDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PopEventDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PopSerializableDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PushPrmDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PushRandDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PushTimeDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PushTlmValAndTimeDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PushTlmValDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_PushValDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_ReturnDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SequenceExecutionArgsSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SequencerStateMachineStateMachineAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SequencerStateMachine_StateEnumAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SetSeedDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_StackCmdDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_StackOpDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_StoreAbsConstOffsetDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_StoreAbsDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_StoreRelConstOffsetDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_StoreRelDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_WaitAbsDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_WaitRelDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/SignedStackSizeTypeAliasAc.hpp"
#include "Svc/FpySequencer/StackSizeTypeAliasAc.hpp"
#include "Svc/Ping/PingPortAc.hpp"
#include "Svc/Sched/SchedPortAc.hpp"
#include "Svc/Seq/BlockStateEnumAc.hpp"
#include "Svc/Seq/CmdSeqCancelPortAc.hpp"
#include "Svc/Seq/CmdSeqInPortAc.hpp"
#include "Svc/Seq/SeqArgsSerializableAc.hpp"
#include "default/config/FwChanIdTypeAliasAc.hpp"
#include "default/config/FwEnumStoreTypeAliasAc.hpp"
#include "default/config/FwIndexTypeAliasAc.hpp"
#include "default/config/FwOpcodeTypeAliasAc.hpp"
#include "default/config/FwPrmIdTypeAliasAc.hpp"
#include "default/config/FwSizeStoreTypeAliasAc.hpp"
#include "default/config/FwSizeTypeAliasAc.hpp"

static_assert(
  FW_PORT_SERIALIZATION == 1,
  "FpySequencer component requires serialization"
);

namespace Svc {

  class FpySequencerComponentBase :
    public Fw::ActiveComponentBase
  {

      // ----------------------------------------------------------------------
      // Friend classes
      // ----------------------------------------------------------------------

      friend class FpySequencerTesterBase;
      friend class FpySequencerTester;

    protected:

      // ----------------------------------------------------------------------
      // Constants
      // ----------------------------------------------------------------------

      enum {
        NUM_CMDIN_INPUT_PORTS = 1,
      };

      enum {
        NUM_CHECKTIMERS_INPUT_PORTS = 1,
        NUM_CMDRESPONSEIN_INPUT_PORTS = 1,
        NUM_PINGIN_INPUT_PORTS = 1,
        NUM_SEQCANCELIN_INPUT_PORTS = 1,
        NUM_SEQRUNIN_INPUT_PORTS = 1,
        NUM_TLMWRITE_INPUT_PORTS = 1,
      };

      enum {
        NUM_CMDREGOUT_OUTPUT_PORTS = 1,
        NUM_CMDRESPONSEOUT_OUTPUT_PORTS = 1,
        NUM_LOGOUT_OUTPUT_PORTS = 1,
        NUM_LOGTEXTOUT_OUTPUT_PORTS = 1,
        NUM_PRMGET_OUTPUT_PORTS = 1,
        NUM_PRMSET_OUTPUT_PORTS = 1,
        NUM_TIMECALLER_OUTPUT_PORTS = 1,
        NUM_TLMOUT_OUTPUT_PORTS = 1,
      };

      enum {
        NUM_CMDOUT_OUTPUT_PORTS = 1,
        NUM_GETPARAM_OUTPUT_PORTS = 1,
        NUM_GETTLMCHAN_OUTPUT_PORTS = 1,
        NUM_PINGOUT_OUTPUT_PORTS = 1,
        NUM_SEQDONEOUT_OUTPUT_PORTS = 1,
        NUM_SEQSTARTOUT_OUTPUT_PORTS = 1,
      };

      enum {
        NUM_SERIALOUT_OUTPUT_PORTS = 5,
      };

      enum {
        OPCODE_RUN = 0x0, 
        OPCODE_RUN_ARGS = 0x1,
        OPCODE_VALIDATE = 0x2, 
        OPCODE_VALIDATE_ARGS = 0x3, 
        OPCODE_RUN_VALIDATED = 0x4, 
        OPCODE_CANCEL = 0x5, 
        OPCODE_SET_BREAKPOINT = 0x6, 
        OPCODE_BREAK = 0x7, 
        OPCODE_CONTINUE = 0x8, 
        OPCODE_CLEAR_BREAKPOINT = 0x9, 
        OPCODE_STEP = 0xa, 
        OPCODE_DUMP_STACK_TO_FILE = 0xb, 
        OPCODE_STATEMENT_TIMEOUT_SECS_SET = 0xc, 
        OPCODE_STATEMENT_TIMEOUT_SECS_SAVE = 0xd, 
        OPCODE_SEQ_BASE_DIR_SET = 0xe, 
        OPCODE_SEQ_BASE_DIR_SAVE = 0xf, 
      };

      enum {
        EVENTID_INVALIDCOMMAND = 0x0,
        EVENTID_INVALIDSEQRUNCALL = 0x1,
        EVENTID_INVALIDSEQCANCELCALL = 0x2,
        EVENTID_FILEOPENERROR = 0x3,
        EVENTID_FILEWRITEERROR = 0x4,
        EVENTID_FILEREADERROR = 0x5,
        EVENTID_ENDOFFILEERROR = 0x6,
        EVENTID_FILEREADDESERIALIZEERROR = 0x7,
        EVENTID_WRONGSCHEMAVERSION = 0x8,
        EVENTID_WRONGCRC = 0x9,
        EVENTID_EXTRABYTESINSEQUENCE = 0xa,
        EVENTID_INSUFFICIENTBUFFERSPACE = 0xb,
        EVENTID_FILEAPIERROR = 0xc,
        EVENTID_SEQUENCEFILEPATHTOOLONG = 0xd,
        EVENTID_COMMANDFAILED = 0xe,
        EVENTID_SEQUENCEDONE = 0xf,
        EVENTID_SEQUENCECANCELLED = 0x10,
        EVENTID_SEQUENCEEXITEDWITHERROR = 0x11,
        EVENTID_UNKNOWNSEQUENCERDIRECTIVE = 0x12,
        EVENTID_CMDRESPONSEWHILENOTRUNNINGSEQUENCE = 0x13,
        EVENTID_CMDRESPONSEFROMOLDSEQUENCE = 0x14,
        EVENTID_CMDRESPONSEWHILENOTAWAITING = 0x15,
        EVENTID_CMDRESPONSEWHILEAWAITINGDIRECTIVE = 0x16,
        EVENTID_WRONGCMDRESPONSEOPCODE = 0x17,
        EVENTID_WRONGCMDRESPONSEINDEX = 0x18,
        EVENTID_DIRECTIVEDESERIALIZEERROR = 0x19,
        EVENTID_MISMATCHEDTIMEBASE = 0x1a,
        EVENTID_MISMATCHEDTIMECONTEXT = 0x1b,
        EVENTID_COMMANDTIMEDOUT = 0x1c,
        EVENTID_DIRECTIVETIMEDOUT = 0x1d,
        EVENTID_TOOMANYSEQUENCEARGS = 0x1e,
        EVENTID_TOOMANYSEQUENCEDIRECTIVES = 0x1f,
        EVENTID_ARGSIZEMISMATCH = 0x20,
        EVENTID_ARGSIZEEXCEEDSCAPACITY = 0x21,
        EVENTID_ARGTOTALSIZEEXCEEDSSTACKLIMIT = 0x22,
        EVENTID_SEQUENCEPAUSED = 0x23,
        EVENTID_BREAKPOINTSET = 0x24,
        EVENTID_BREAKPOINTCLEARED = 0x25,
        EVENTID_LOGFATAL = 0x26,
        EVENTID_LOGWARNINGHI = 0x27,
        EVENTID_LOGWARNINGLO = 0x28,
        EVENTID_LOGCOMMAND = 0x29,
        EVENTID_LOGACTIVITYHI = 0x2a,
        EVENTID_LOGACTIVITYLO = 0x2b,
        EVENTID_LOGDIAGNOSTIC = 0x2c,
        EVENTID_DIRECTIVEWHILENOTAWAITING = 0x2d,
        EVENTID_DIRECTIVEFROMOLDSEQUENCE = 0x2e,
      };

      enum {
        CHANNELID_STATE = 0x0, 
        CHANNELID_SEQUENCESSUCCEEDED = 0x1, 
        CHANNELID_SEQUENCESFAILED = 0x2, 
        CHANNELID_SEQUENCESCANCELLED = 0x3, 
        CHANNELID_STATEMENTSDISPATCHED = 0x4, 
        CHANNELID_STATEMENTSFAILED = 0x5, 
        CHANNELID_LASTDIRECTIVEERROR = 0x6, 
        CHANNELID_DIRECTIVEERRORINDEX = 0x7, 
        CHANNELID_DIRECTIVEERRORID = 0x8, 
        CHANNELID_SEQPATH = 0x9, 
        CHANNELID_DEBUG_REACHEDENDOFFILE = 0xa, 
        CHANNELID_DEBUG_NEXTSTATEMENTREADSUCCESS = 0xb, 
        CHANNELID_DEBUG_NEXTSTATEMENTOPCODE = 0xc, 
        CHANNELID_DEBUG_NEXTSTATEMENTINDEX = 0xd, 
        CHANNELID_DEBUG_NEXTCMDOPCODE = 0xe, 
        CHANNELID_DEBUG_STACKSIZE = 0xf, 
        CHANNELID_BREAKPOINTINUSE = 0x10, 
        CHANNELID_BREAKPOINTINDEX = 0x11, 
        CHANNELID_BREAKONLYONCEONBREAKPOINT = 0x12, 
        CHANNELID_BREAKBEFORENEXTLINE = 0x13, 
        CHANNELID_PRM_STATEMENT_TIMEOUT_SECS = 0x14, 
        CHANNELID_PRM_SEQ_BASE_DIR = 0x15, 
      };

      enum {
        PARAMID_STATEMENT_TIMEOUT_SECS = 0x0, 
        PARAMID_SEQ_BASE_DIR = 0x1, 
      };

      enum class SmId : FwEnumStoreType {
        sequencer,
      };

    protected:

      // ----------------------------------------------------------------------
      // Types for internal state machines
      // ----------------------------------------------------------------------

      class Svc_FpySequencer_SequencerStateMachine :
        public Svc::FpySequencer_SequencerStateMachineStateMachineBase
      {

          // ----------------------------------------------------------------------
          // Friend classes
          // ----------------------------------------------------------------------

          friend class FpySequencerTesterBase;
          friend class FpySequencerTester;

        public:

          Svc_FpySequencer_SequencerStateMachine(
              FpySequencerComponentBase& component 
          );

        public:

          void init(
              FpySequencerComponentBase::SmId smId 
          );

        public:

          FpySequencerComponentBase::SmId getId() const;

        private:

          void action_signalEntered(
              Signal signal 
          );

          void action_setSequenceFilePath(
              Signal signal, 
              const Svc::FpySequencer_SequenceExecutionArgs& value 
          );

          void action_setSequenceBlockState(
              Signal signal, 
              const Svc::FpySequencer_SequenceExecutionArgs& value 
          );

          void action_setSequenceArguments(
              Signal signal, 
              const Svc::FpySequencer_SequenceExecutionArgs& value 
          );

          void action_validate(
              Signal signal 
          );

          void action_report_seqSucceeded(
              Signal signal 
          );

          void action_report_seqCancelled(
              Signal signal 
          );

          void action_report_seqFailed(
              Signal signal 
          );

          void action_report_seqStarted(
              Signal signal 
          );

          void action_setGoalState_RUNNING(
              Signal signal 
          );

          void action_setGoalState_VALID(
              Signal signal 
          );

          void action_setGoalState_IDLE(
              Signal signal 
          );

          void action_sendCmdResponse_OK(
              Signal signal 
          );

          void action_sendCmdResponse_EXECUTION_ERROR(
              Signal signal 
          );

          void action_clearSequenceFile(
              Signal signal 
          );

          void action_clearBreakpoint(
              Signal signal 
          );

          void action_clearSequenceArguments(
              Signal signal 
          );

          void action_checkShouldWake(
              Signal signal 
          );

          void action_dispatchStatement(
              Signal signal 
          );

          void action_resetRuntime(
              Signal signal 
          );

          void action_checkStatementTimeout(
              Signal signal 
          );

          void action_incrementSequenceCounter(
              Signal signal 
          );

          void action_pushArgsToStack(
              Signal signal 
          );

          void action_report_seqBroken(
              Signal signal 
          );

          void action_setBreakpoint(
              Signal signal, 
              const Svc::FpySequencer_BreakpointArgs& value 
          );

          void action_setBreakBeforeNextLine(
              Signal signal 
          );

          void action_clearBreakBeforeNextLine(
              Signal signal 
          );

        private:

          bool guard_goalStateIs_RUNNING(
              Signal signal 
          ) const;

          bool guard_shouldBreak(
              Signal signal 
          ) const;

          bool guard_breakOnce(
              Signal signal 
          ) const;

        private:

          FpySequencerComponentBase& m_component;

      };

    public:

      // ----------------------------------------------------------------------
      // Component initialization
      // ----------------------------------------------------------------------

      void init(
          FwSizeType queueDepth, 
          FwEnumStoreType instance = 0 
      );

#if !FW_DIRECT_PORT_CALLS

    public:

      // ----------------------------------------------------------------------
      // Getters for special input ports
      // ----------------------------------------------------------------------

      Fw::InputCmdPort* get_cmdIn_InputPort(
          FwIndexType portNum 
      );

#endif

#if !FW_DIRECT_PORT_CALLS

    public:

      // ----------------------------------------------------------------------
      // Getters for typed input ports
      // ----------------------------------------------------------------------

      Svc::InputSchedPort* get_checkTimers_InputPort(
          FwIndexType portNum 
      );

      Fw::InputCmdResponsePort* get_cmdResponseIn_InputPort(
          FwIndexType portNum 
      );

      Svc::InputPingPort* get_pingIn_InputPort(
          FwIndexType portNum 
      );

      Svc::InputCmdSeqCancelPort* get_seqCancelIn_InputPort(
          FwIndexType portNum 
      );

      Svc::InputCmdSeqInPort* get_seqRunIn_InputPort(
          FwIndexType portNum 
      );

      Svc::InputSchedPort* get_tlmWrite_InputPort(
          FwIndexType portNum 
      );

#endif

#if !FW_DIRECT_PORT_CALLS

    public:

      // ----------------------------------------------------------------------
      // Connect input ports to special output ports
      // ----------------------------------------------------------------------

      void set_cmdRegOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputCmdRegPort* port 
      );

      void set_cmdResponseOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputCmdResponsePort* port 
      );

      void set_logOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputLogPort* port 
      );

#if FW_ENABLE_TEXT_LOGGING == 1

      void set_logTextOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputLogTextPort* port 
      );

#endif

      void set_prmGet_OutputPort(
          FwIndexType portNum, 
          Fw::InputPrmGetPort* port 
      );

      void set_prmSet_OutputPort(
          FwIndexType portNum, 
          Fw::InputPrmSetPort* port 
      );

      void set_timeCaller_OutputPort(
          FwIndexType portNum, 
          Fw::InputTimePort* port 
      );

      void set_tlmOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputTlmPort* port 
      );

#endif

#if !FW_DIRECT_PORT_CALLS

    public:

      // ----------------------------------------------------------------------
      // Connect typed input ports to typed output ports
      // ----------------------------------------------------------------------

      void set_cmdOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputComPort* port 
      );

      void set_getParam_OutputPort(
          FwIndexType portNum, 
          Fw::InputPrmGetPort* port 
      );

      void set_getTlmChan_OutputPort(
          FwIndexType portNum, 
          Fw::InputTlmGetPort* port 
      );

      void set_pingOut_OutputPort(
          FwIndexType portNum, 
          Svc::InputPingPort* port 
      );

      void set_seqDoneOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputCmdResponsePort* port 
      );

      void set_seqStartOut_OutputPort(
          FwIndexType portNum, 
          Svc::InputCmdSeqInPort* port 
      );

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

    public:

      // ----------------------------------------------------------------------
      // Connect serial input ports to special output ports
      // ----------------------------------------------------------------------

      void set_cmdRegOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

      void set_cmdResponseOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

      void set_logOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

#if FW_ENABLE_TEXT_LOGGING == 1

      void set_logTextOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

#endif

      void set_prmSet_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

      void set_timeCaller_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

      void set_tlmOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

    public:

      // ----------------------------------------------------------------------
      // Connect serial input ports to typed output ports
      // ----------------------------------------------------------------------

      void set_cmdOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

      void set_pingOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

      void set_seqDoneOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

      void set_seqStartOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputSerializePort* port 
      );

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

    public:

      // ----------------------------------------------------------------------
      // Connect typed and serial input ports to serial output ports
      // ----------------------------------------------------------------------

      void set_serialOut_OutputPort(
          FwIndexType portNum, 
          Fw::InputPortBase* port 
      );

#endif

    public:

      // ----------------------------------------------------------------------
      // Command registration
      // ----------------------------------------------------------------------

      void regCommands();

    public:

      // ----------------------------------------------------------------------
      // Parameter loading
      // ----------------------------------------------------------------------

      void loadParameters();

    protected:

      // ----------------------------------------------------------------------
      // Component construction and destruction
      // ----------------------------------------------------------------------

      FpySequencerComponentBase(
          const char* compName = "" 
      );

      virtual ~FpySequencerComponentBase();

    protected:

      // ----------------------------------------------------------------------
      // Getters for numbers of special input ports
      // ----------------------------------------------------------------------

      static constexpr FwIndexType getNum_cmdIn_InputPorts() {
        return NUM_CMDIN_INPUT_PORTS;
      }

    protected:

      // ----------------------------------------------------------------------
      // Getters for numbers of typed input ports
      // ----------------------------------------------------------------------

      static constexpr FwIndexType getNum_checkTimers_InputPorts() {
        return NUM_CHECKTIMERS_INPUT_PORTS;
      }

      static constexpr FwIndexType getNum_cmdResponseIn_InputPorts() {
        return NUM_CMDRESPONSEIN_INPUT_PORTS;
      }

      static constexpr FwIndexType getNum_pingIn_InputPorts() {
        return NUM_PINGIN_INPUT_PORTS;
      }

      static constexpr FwIndexType getNum_seqCancelIn_InputPorts() {
        return NUM_SEQCANCELIN_INPUT_PORTS;
      }

      static constexpr FwIndexType getNum_seqRunIn_InputPorts() {
        return NUM_SEQRUNIN_INPUT_PORTS;
      }

      static constexpr FwIndexType getNum_tlmWrite_InputPorts() {
        return NUM_TLMWRITE_INPUT_PORTS;
      }

    protected:

      // ----------------------------------------------------------------------
      // Getters for numbers of special output ports
      // ----------------------------------------------------------------------

      static constexpr FwIndexType getNum_cmdRegOut_OutputPorts() {
        return NUM_CMDREGOUT_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_cmdResponseOut_OutputPorts() {
        return NUM_CMDRESPONSEOUT_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_logOut_OutputPorts() {
        return NUM_LOGOUT_OUTPUT_PORTS;
      }

#if FW_ENABLE_TEXT_LOGGING == 1

      static constexpr FwIndexType getNum_logTextOut_OutputPorts() {
        return NUM_LOGTEXTOUT_OUTPUT_PORTS;
      }

#endif

      static constexpr FwIndexType getNum_prmGet_OutputPorts() {
        return NUM_PRMGET_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_prmSet_OutputPorts() {
        return NUM_PRMSET_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_timeCaller_OutputPorts() {
        return NUM_TIMECALLER_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_tlmOut_OutputPorts() {
        return NUM_TLMOUT_OUTPUT_PORTS;
      }

    protected:

      // ----------------------------------------------------------------------
      // Getters for numbers of typed output ports
      // ----------------------------------------------------------------------

      static constexpr FwIndexType getNum_cmdOut_OutputPorts() {
        return NUM_CMDOUT_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_getParam_OutputPorts() {
        return NUM_GETPARAM_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_getTlmChan_OutputPorts() {
        return NUM_GETTLMCHAN_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_pingOut_OutputPorts() {
        return NUM_PINGOUT_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_seqDoneOut_OutputPorts() {
        return NUM_SEQDONEOUT_OUTPUT_PORTS;
      }

      static constexpr FwIndexType getNum_seqStartOut_OutputPorts() {
        return NUM_SEQSTARTOUT_OUTPUT_PORTS;
      }

    protected:

      // ----------------------------------------------------------------------
      // Getters for numbers of serial output ports
      // ----------------------------------------------------------------------

      static constexpr FwIndexType getNum_serialOut_OutputPorts() {
        return NUM_SERIALOUT_OUTPUT_PORTS;
      }

    protected:

      // ----------------------------------------------------------------------
      // Connection status queries for special output ports
      // ----------------------------------------------------------------------

      bool isConnected_cmdRegOut_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_cmdResponseOut_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_logOut_OutputPort(
          FwIndexType portNum 
      ) const;

#if FW_ENABLE_TEXT_LOGGING == 1

      bool isConnected_logTextOut_OutputPort(
          FwIndexType portNum 
      ) const;

#endif

      bool isConnected_prmGet_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_prmSet_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_timeCaller_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_tlmOut_OutputPort(
          FwIndexType portNum 
      ) const;

    protected:

      // ----------------------------------------------------------------------
      // Connection status queries for typed output ports
      // ----------------------------------------------------------------------

      bool isConnected_cmdOut_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_getParam_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_getTlmChan_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_pingOut_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_seqDoneOut_OutputPort(
          FwIndexType portNum 
      ) const;

      bool isConnected_seqStartOut_OutputPort(
          FwIndexType portNum 
      ) const;

    protected:

      // ----------------------------------------------------------------------
      // Connection status queries for serial output ports
      // ----------------------------------------------------------------------

      bool isConnected_serialOut_OutputPort(
          FwIndexType portNum 
      ) const;

#if FW_DIRECT_PORT_CALLS
    public:
#else
    protected:
#endif

      // ----------------------------------------------------------------------
      // Port handler base-class functions for special input ports
      //
      // Call these functions directly to bypass the corresponding ports
      // ----------------------------------------------------------------------

      void cmdIn_handlerBase(
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

    protected:

      // ----------------------------------------------------------------------
      // Handlers to implement for typed input ports
      // ----------------------------------------------------------------------

      virtual void checkTimers_handler(
          FwIndexType portNum, 
          U32 context 
      ) = 0;

      virtual void cmdResponseIn_handler(
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      ) = 0;

      virtual void pingIn_handler(
          FwIndexType portNum, 
          U32 key 
      ) = 0;

      virtual void seqCancelIn_handler(
          FwIndexType portNum 
      ) = 0;

      virtual void seqRunIn_handler(
          FwIndexType portNum, 
          const Fw::StringBase& filename, 
          const Svc::SeqArgs& args 
      ) = 0;

      virtual void tlmWrite_handler(
          FwIndexType portNum, 
          U32 context 
      ) = 0;

#if FW_DIRECT_PORT_CALLS
    public:
#else
    protected:
#endif

      // ----------------------------------------------------------------------
      // Port handler base-class functions for typed input ports
      //
      // Call these functions directly to bypass the corresponding ports
      // ----------------------------------------------------------------------

      void checkTimers_handlerBase(
          FwIndexType portNum, 
          U32 context 
      );

      void cmdResponseIn_handlerBase(
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      );

      void pingIn_handlerBase(
          FwIndexType portNum, 
          U32 key 
      );

      void seqCancelIn_handlerBase(
          FwIndexType portNum 
      );

      void seqRunIn_handlerBase(
          FwIndexType portNum, 
          const Fw::StringBase& filename, 
          const Svc::SeqArgs& args 
      );

      void tlmWrite_handlerBase(
          FwIndexType portNum, 
          U32 context 
      );

    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 cmdResponseIn_preMsgHook(
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      );

      virtual void pingIn_preMsgHook(
          FwIndexType portNum, 
          U32 key 
      );

      virtual void seqCancelIn_preMsgHook(
          FwIndexType portNum 
      );

      virtual void seqRunIn_preMsgHook(
          FwIndexType portNum, 
          const Fw::StringBase& filename, 
          const Svc::SeqArgs& args 
      );

    protected:

      // ----------------------------------------------------------------------
      // Invocation functions for typed output ports
      // ----------------------------------------------------------------------

      void cmdOut_out(
          FwIndexType portNum, 
          Fw::ComBuffer& data, 
          U32 context 
      ) const;

      Fw::ParamValid getParam_out(
          FwIndexType portNum, 
          FwPrmIdType id, 
          Fw::ParamBuffer& val 
      ) const;

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

      void pingOut_out(
          FwIndexType portNum, 
          U32 key 
      ) const;

      void seqDoneOut_out(
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      ) const;

      void seqStartOut_out(
          FwIndexType portNum, 
          const Fw::StringBase& filename, 
          const Svc::SeqArgs& args 
      ) const;

    protected:

      // ----------------------------------------------------------------------
      // Invocation functions for serial output ports
      // ----------------------------------------------------------------------

      Fw::SerializeStatus serialOut_out(
          FwIndexType portNum, 
          Fw::LinearBufferBase& buffer 
      );

    protected:

      // ----------------------------------------------------------------------
      // Hooks for internal ports
      //
      // Each of these functions is invoked just before dropping a message
      // on the corresponding internal port. You should override them to provide
      // specific drop behavior.
      // ----------------------------------------------------------------------

      virtual void tlmWriteInternal_overflowHook() = 0;

    protected:

      // ----------------------------------------------------------------------
      // Internal interface handlers
      // ----------------------------------------------------------------------

      virtual void checkTimersInternal_internalInterfaceHandler() = 0;

      virtual void directive_allocate_internalInterfaceHandler(
          const Svc::FpySequencer_AllocateDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_call_internalInterfaceHandler(
          const Svc::FpySequencer_CallDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_constCmd_internalInterfaceHandler(
          const Svc::FpySequencer_ConstCmdDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_discard_internalInterfaceHandler(
          const Svc::FpySequencer_DiscardDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_exit_internalInterfaceHandler(
          const Svc::FpySequencer_ExitDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_getField_internalInterfaceHandler(
          const Svc::FpySequencer_GetFieldDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_goto_internalInterfaceHandler(
          const Svc::FpySequencer_GotoDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_if_internalInterfaceHandler(
          const Svc::FpySequencer_IfDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_loadAbs_internalInterfaceHandler(
          const Svc::FpySequencer_LoadAbsDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_loadRel_internalInterfaceHandler(
          const Svc::FpySequencer_LoadRelDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_memCmp_internalInterfaceHandler(
          const Svc::FpySequencer_MemCmpDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_noOp_internalInterfaceHandler(
          const Svc::FpySequencer_NoOpDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_peek_internalInterfaceHandler(
          const Svc::FpySequencer_PeekDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_popEvent_internalInterfaceHandler(
          const Svc::FpySequencer_PopEventDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_popSerializable_internalInterfaceHandler(
          const Svc::FpySequencer_PopSerializableDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_pushPrm_internalInterfaceHandler(
          const Svc::FpySequencer_PushPrmDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_pushRand_internalInterfaceHandler(
          const Svc::FpySequencer_PushRandDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_pushTime_internalInterfaceHandler(
          const Svc::FpySequencer_PushTimeDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_pushTlmVal_internalInterfaceHandler(
          const Svc::FpySequencer_PushTlmValDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_pushTlmValAndTime_internalInterfaceHandler(
          const Svc::FpySequencer_PushTlmValAndTimeDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_pushVal_internalInterfaceHandler(
          const Svc::FpySequencer_PushValDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_return_internalInterfaceHandler(
          const Svc::FpySequencer_ReturnDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_setSeed_internalInterfaceHandler(
          const Svc::FpySequencer_SetSeedDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_stackCmd_internalInterfaceHandler(
          const Svc::FpySequencer_StackCmdDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_stackOp_internalInterfaceHandler(
          const Svc::FpySequencer_StackOpDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_storeAbs_internalInterfaceHandler(
          const Svc::FpySequencer_StoreAbsDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_storeAbsConstOffset_internalInterfaceHandler(
          const Svc::FpySequencer_StoreAbsConstOffsetDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_storeRel_internalInterfaceHandler(
          const Svc::FpySequencer_StoreRelDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_storeRelConstOffset_internalInterfaceHandler(
          const Svc::FpySequencer_StoreRelConstOffsetDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_waitAbs_internalInterfaceHandler(
          const Svc::FpySequencer_WaitAbsDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void directive_waitRel_internalInterfaceHandler(
          const Svc::FpySequencer_WaitRelDirective& directive,
          U64 sequenceIndex
      ) = 0;

      virtual void tlmWriteInternal_internalInterfaceHandler() = 0;

    protected:

      // ----------------------------------------------------------------------
      // Internal interface base-class functions
      // ----------------------------------------------------------------------

      void checkTimersInternal_internalInterfaceInvoke();

      void directive_allocate_internalInterfaceInvoke(
          const Svc::FpySequencer_AllocateDirective& directive,
          U64 sequenceIndex
      );

      void directive_call_internalInterfaceInvoke(
          const Svc::FpySequencer_CallDirective& directive,
          U64 sequenceIndex
      );

      void directive_constCmd_internalInterfaceInvoke(
          const Svc::FpySequencer_ConstCmdDirective& directive,
          U64 sequenceIndex
      );

      void directive_discard_internalInterfaceInvoke(
          const Svc::FpySequencer_DiscardDirective& directive,
          U64 sequenceIndex
      );

      void directive_exit_internalInterfaceInvoke(
          const Svc::FpySequencer_ExitDirective& directive,
          U64 sequenceIndex
      );

      void directive_getField_internalInterfaceInvoke(
          const Svc::FpySequencer_GetFieldDirective& directive,
          U64 sequenceIndex
      );

      void directive_goto_internalInterfaceInvoke(
          const Svc::FpySequencer_GotoDirective& directive,
          U64 sequenceIndex
      );

      void directive_if_internalInterfaceInvoke(
          const Svc::FpySequencer_IfDirective& directive,
          U64 sequenceIndex
      );

      void directive_loadAbs_internalInterfaceInvoke(
          const Svc::FpySequencer_LoadAbsDirective& directive,
          U64 sequenceIndex
      );

      void directive_loadRel_internalInterfaceInvoke(
          const Svc::FpySequencer_LoadRelDirective& directive,
          U64 sequenceIndex
      );

      void directive_memCmp_internalInterfaceInvoke(
          const Svc::FpySequencer_MemCmpDirective& directive,
          U64 sequenceIndex
      );

      void directive_noOp_internalInterfaceInvoke(
          const Svc::FpySequencer_NoOpDirective& directive,
          U64 sequenceIndex
      );

      void directive_peek_internalInterfaceInvoke(
          const Svc::FpySequencer_PeekDirective& directive,
          U64 sequenceIndex
      );

      void directive_popEvent_internalInterfaceInvoke(
          const Svc::FpySequencer_PopEventDirective& directive,
          U64 sequenceIndex
      );

      void directive_popSerializable_internalInterfaceInvoke(
          const Svc::FpySequencer_PopSerializableDirective& directive,
          U64 sequenceIndex
      );

      void directive_pushPrm_internalInterfaceInvoke(
          const Svc::FpySequencer_PushPrmDirective& directive,
          U64 sequenceIndex
      );

      void directive_pushRand_internalInterfaceInvoke(
          const Svc::FpySequencer_PushRandDirective& directive,
          U64 sequenceIndex
      );

      void directive_pushTime_internalInterfaceInvoke(
          const Svc::FpySequencer_PushTimeDirective& directive,
          U64 sequenceIndex
      );

      void directive_pushTlmVal_internalInterfaceInvoke(
          const Svc::FpySequencer_PushTlmValDirective& directive,
          U64 sequenceIndex
      );

      void directive_pushTlmValAndTime_internalInterfaceInvoke(
          const Svc::FpySequencer_PushTlmValAndTimeDirective& directive,
          U64 sequenceIndex
      );

      void directive_pushVal_internalInterfaceInvoke(
          const Svc::FpySequencer_PushValDirective& directive,
          U64 sequenceIndex
      );

      void directive_return_internalInterfaceInvoke(
          const Svc::FpySequencer_ReturnDirective& directive,
          U64 sequenceIndex
      );

      void directive_setSeed_internalInterfaceInvoke(
          const Svc::FpySequencer_SetSeedDirective& directive,
          U64 sequenceIndex
      );

      void directive_stackCmd_internalInterfaceInvoke(
          const Svc::FpySequencer_StackCmdDirective& directive,
          U64 sequenceIndex
      );

      void directive_stackOp_internalInterfaceInvoke(
          const Svc::FpySequencer_StackOpDirective& directive,
          U64 sequenceIndex
      );

      void directive_storeAbs_internalInterfaceInvoke(
          const Svc::FpySequencer_StoreAbsDirective& directive,
          U64 sequenceIndex
      );

      void directive_storeAbsConstOffset_internalInterfaceInvoke(
          const Svc::FpySequencer_StoreAbsConstOffsetDirective& directive,
          U64 sequenceIndex
      );

      void directive_storeRel_internalInterfaceInvoke(
          const Svc::FpySequencer_StoreRelDirective& directive,
          U64 sequenceIndex
      );

      void directive_storeRelConstOffset_internalInterfaceInvoke(
          const Svc::FpySequencer_StoreRelConstOffsetDirective& directive,
          U64 sequenceIndex
      );

      void directive_waitAbs_internalInterfaceInvoke(
          const Svc::FpySequencer_WaitAbsDirective& directive,
          U64 sequenceIndex
      );

      void directive_waitRel_internalInterfaceInvoke(
          const Svc::FpySequencer_WaitRelDirective& directive,
          U64 sequenceIndex
      );

      void tlmWriteInternal_internalInterfaceInvoke();

    protected:

      // ----------------------------------------------------------------------
      // State getter functions
      // ----------------------------------------------------------------------

      Svc_FpySequencer_SequencerStateMachine::State sequencer_getState() const;

    protected:

      // ----------------------------------------------------------------------
      // Signal send functions
      // ----------------------------------------------------------------------

      void sequencer_sendSignal_cmd_VALIDATE(
          const Svc::FpySequencer_SequenceExecutionArgs& value 
      );

      void sequencer_sendSignal_cmd_RUN(
          const Svc::FpySequencer_SequenceExecutionArgs& value 
      );

      void sequencer_sendSignal_cmd_RUN_VALIDATED(
          const Svc::FpySequencer_SequenceExecutionArgs& value 
      );

      void sequencer_sendSignal_cmd_CANCEL();

      void sequencer_sendSignal_cmd_SET_BREAKPOINT(
          const Svc::FpySequencer_BreakpointArgs& value 
      );

      void sequencer_sendSignal_cmd_CLEAR_BREAKPOINT();

      void sequencer_sendSignal_result_failure();

      void sequencer_sendSignal_result_success();

      void sequencer_sendSignal_entered();

      void sequencer_sendSignal_result_dispatchStatement_success();

      void sequencer_sendSignal_result_dispatchStatement_failure();

      void sequencer_sendSignal_result_dispatchStatement_noMoreStatements();

      void sequencer_sendSignal_checkTimersIn();

      void sequencer_sendSignal_result_checkShouldWake_wakeup();

      void sequencer_sendSignal_result_checkShouldWake_keepSleeping();

      void sequencer_sendSignal_result_timeOpFailed();

      void sequencer_sendSignal_stmtResponse_beginSleep();

      void sequencer_sendSignal_stmtResponse_success();

      void sequencer_sendSignal_stmtResponse_failure();

      void sequencer_sendSignal_stmtResponse_unexpected();

      void sequencer_sendSignal_stmtResponse_keepWaiting();

      void sequencer_sendSignal_result_checkStatementTimeout_statementTimeout();

      void sequencer_sendSignal_result_checkStatementTimeout_noTimeout();

      void sequencer_sendSignal_cmd_CONTINUE();

      void sequencer_sendSignal_cmd_BREAK();

      void sequencer_sendSignal_cmd_STEP();

    protected:

      // ----------------------------------------------------------------------
      // Functions to implement for internal state machine actions
      // ----------------------------------------------------------------------

      virtual void Svc_FpySequencer_SequencerStateMachine_action_signalEntered(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setSequenceFilePath(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal, 
          const Svc::FpySequencer_SequenceExecutionArgs& value 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setSequenceBlockState(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal, 
          const Svc::FpySequencer_SequenceExecutionArgs& value 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setSequenceArguments(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal, 
          const Svc::FpySequencer_SequenceExecutionArgs& value 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_validate(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_report_seqSucceeded(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_report_seqCancelled(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_report_seqFailed(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_report_seqStarted(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_RUNNING(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_VALID(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_IDLE(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_OK(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_EXECUTION_ERROR(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_clearSequenceFile(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_clearBreakpoint(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_clearSequenceArguments(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_checkShouldWake(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_dispatchStatement(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_resetRuntime(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_checkStatementTimeout(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_incrementSequenceCounter(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_pushArgsToStack(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_report_seqBroken(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setBreakpoint(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal, 
          const Svc::FpySequencer_BreakpointArgs& value 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setBreakBeforeNextLine(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_clearBreakBeforeNextLine(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

    protected:

      // ----------------------------------------------------------------------
      // Functions to implement for internal state machine guards
      // ----------------------------------------------------------------------

      virtual bool Svc_FpySequencer_SequencerStateMachine_guard_goalStateIs_RUNNING(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_FpySequencer_SequencerStateMachine_guard_shouldBreak(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_FpySequencer_SequencerStateMachine_guard_breakOnce(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) const = 0;

    protected:

      // ----------------------------------------------------------------------
      // Command response
      // ----------------------------------------------------------------------

      void cmdResponse_out(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdResponse response 
      );

    protected:

      // ----------------------------------------------------------------------
      // Command handlers to implement
      // ----------------------------------------------------------------------

      virtual void RUN_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName, 
          const Svc::BlockState& block 
      ) = 0;

      virtual void RUN_ARGS_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName, 
          const Svc::BlockState& block, 
          const Svc::SeqArgs& buffer 
      ) = 0;

      virtual void VALIDATE_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName 
      ) = 0;

      virtual void VALIDATE_ARGS_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName, 
          const Svc::SeqArgs& buffer 
      ) = 0;

      virtual void RUN_VALIDATED_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Svc::BlockState& block 
      ) = 0;

      virtual void CANCEL_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      ) = 0;

      virtual void SET_BREAKPOINT_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          U32 stmtIdx, 
          bool breakOnce 
      ) = 0;

      virtual void BREAK_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      ) = 0;

      virtual void CONTINUE_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      ) = 0;

      virtual void CLEAR_BREAKPOINT_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      ) = 0;

      virtual void STEP_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      ) = 0;

      virtual void DUMP_STACK_TO_FILE_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName 
      ) = 0;

    protected:

      // ----------------------------------------------------------------------
      // Command handler base-class functions
      //
      // Call these functions directly to bypass the command input port
      // ----------------------------------------------------------------------

      void RUN_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void RUN_ARGS_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void VALIDATE_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void VALIDATE_ARGS_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void RUN_VALIDATED_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void CANCEL_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void SET_BREAKPOINT_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void BREAK_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void CONTINUE_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void CLEAR_BREAKPOINT_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void STEP_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

      void DUMP_STACK_TO_FILE_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

    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 RUN_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void RUN_ARGS_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void VALIDATE_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void VALIDATE_ARGS_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void RUN_VALIDATED_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void CANCEL_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void SET_BREAKPOINT_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void BREAK_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void CONTINUE_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void CLEAR_BREAKPOINT_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void STEP_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void DUMP_STACK_TO_FILE_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

    protected:

      // ----------------------------------------------------------------------
      // Event logging functions
      // ----------------------------------------------------------------------

      void log_WARNING_HI_InvalidCommand(I32 state) const;

      void log_WARNING_HI_InvalidSeqRunCall(I32 state) const;

      void log_WARNING_HI_InvalidSeqCancelCall(I32 state) const;

      void log_WARNING_HI_FileOpenError(
          const Fw::StringBase& filePath,
          I32 errorCode
      ) const;

      void log_WARNING_HI_FileWriteError(
          FwSizeType writeSize,
          const Fw::StringBase& filePath,
          I32 errorCode
      ) const;

      void log_WARNING_HI_FileReadError(
          const Svc::FpySequencer_FileReadStage& readStage,
          const Fw::StringBase& filePath,
          I32 errorCode
      ) const;

      void log_WARNING_HI_EndOfFileError(
          const Svc::FpySequencer_FileReadStage& readStage,
          const Fw::StringBase& filePath
      ) const;

      void log_WARNING_HI_FileReadDeserializeError(
          const Svc::FpySequencer_FileReadStage& readStage,
          const Fw::StringBase& filePath,
          I32 errorCode,
          U64 buffLeft,
          U64 buffLength
      ) const;

      void log_WARNING_HI_WrongSchemaVersion(
          U8 expected,
          U8 actual
      ) const;

      void log_WARNING_HI_WrongCRC(
          U32 expected,
          U32 actual
      ) const;

      void log_WARNING_HI_ExtraBytesInSequence(FwSizeType remaining) const;

      void log_WARNING_HI_InsufficientBufferSpace(
          U64 bufferSize,
          const Fw::StringBase& filePath
      ) const;

      void log_WARNING_HI_FileApiError(
          const Fw::StringBase& filePath,
          I32 errorCode
      ) const;

      void log_WARNING_HI_SequenceFilePathTooLong(
          const Fw::StringBase& baseDir,
          const Fw::StringBase& fileName
      ) const;

      void log_WARNING_HI_CommandFailed(
          FwOpcodeType opCode,
          U32 stmtIdx,
          const Fw::StringBase& filePath,
          const Fw::CmdResponse& response
      ) const;

      void log_ACTIVITY_HI_SequenceDone(const Fw::StringBase& filePath) const;

      void log_ACTIVITY_HI_SequenceCancelled(const Fw::StringBase& filePath) const;

      void log_WARNING_HI_SequenceExitedWithError(
          const Fw::StringBase& filePath,
          I32 errorCode
      ) const;

      void log_WARNING_HI_UnknownSequencerDirective(
          U8 opcode,
          U32 stmtIdx,
          const Fw::StringBase& filePath
      ) const;

      void log_WARNING_LO_CmdResponseWhileNotRunningSequence(
          I32 state,
          FwOpcodeType opcode,
          const Fw::CmdResponse& response
      ) const;

      void log_WARNING_LO_CmdResponseFromOldSequence(
          FwOpcodeType opcode,
          const Fw::CmdResponse& response,
          U16 oldSequenceIdx,
          U16 currentSequenceIdx
      ) const;

      void log_WARNING_HI_CmdResponseWhileNotAwaiting(
          FwOpcodeType opcode,
          const Fw::CmdResponse& response
      ) const;

      void log_WARNING_HI_CmdResponseWhileAwaitingDirective(
          FwOpcodeType opcode,
          const Fw::CmdResponse& response,
          U8 expectedDirectiveOpcode
      ) const;

      void log_WARNING_HI_WrongCmdResponseOpcode(
          FwOpcodeType opcode,
          const Fw::CmdResponse& response,
          FwOpcodeType expectedOpcode
      ) const;

      void log_WARNING_HI_WrongCmdResponseIndex(
          FwOpcodeType opcode,
          const Fw::CmdResponse& response,
          U16 actualCmdIdx,
          U16 expectedCmdIdx
      ) const;

      void log_WARNING_HI_DirectiveDeserializeError(
          U8 opcode,
          U32 stmtIdx,
          I32 errorCode,
          U64 buffLeft,
          U64 buffLength
      ) const;

      void log_WARNING_HI_MismatchedTimeBase(
          I32 internalTimeBase,
          I32 otherTimeBase
      ) const;

      void log_WARNING_HI_MismatchedTimeContext(
          I32 internalTimeContext,
          I32 otherTimeContext
      ) const;

      void log_WARNING_HI_CommandTimedOut(
          FwOpcodeType opCode,
          U32 stmtIdx,
          const Fw::StringBase& filePath
      ) const;

      void log_WARNING_HI_DirectiveTimedOut(
          U8 opCode,
          U32 stmtIdx,
          const Fw::StringBase& filePath
      ) const;

      void log_WARNING_HI_TooManySequenceArgs(
          U8 count,
          U8 max
      ) const;

      void log_WARNING_HI_TooManySequenceDirectives(
          U16 count,
          U16 max
      ) const;

      void log_WARNING_HI_ArgSizeMismatch(
          Svc::Fpy::StackSizeType expected,
          FwSizeType actual,
          const Fw::StringBase& filePath
      ) const;

      void log_WARNING_HI_ArgSizeExceedsCapacity(
          FwSizeType actual,
          FwSizeType capacity
      ) const;

      void log_WARNING_HI_ArgTotalSizeExceedsStackLimit(Svc::Fpy::StackSizeType argSize) const;

      void log_ACTIVITY_HI_SequencePaused(U32 stmtIdx) const;

      void log_ACTIVITY_HI_BreakpointSet(
          U32 breakpointIdx,
          bool breakOnce
      ) const;

      void log_ACTIVITY_HI_BreakpointCleared() const;

      void log_FATAL_LogFatal(
          const Fw::StringBase& filePath,
          const Fw::StringBase& message
      ) const;

      void log_WARNING_HI_LogWarningHi(
          const Fw::StringBase& filePath,
          const Fw::StringBase& message
      ) const;

      void log_WARNING_LO_LogWarningLo(
          const Fw::StringBase& filePath,
          const Fw::StringBase& message
      ) const;

      void log_COMMAND_LogCommand(
          const Fw::StringBase& filePath,
          const Fw::StringBase& message
      ) const;

      void log_ACTIVITY_HI_LogActivityHi(
          const Fw::StringBase& filePath,
          const Fw::StringBase& message
      ) const;

      void log_ACTIVITY_LO_LogActivityLo(
          const Fw::StringBase& filePath,
          const Fw::StringBase& message
      ) const;

      void log_DIAGNOSTIC_LogDiagnostic(
          const Fw::StringBase& filePath,
          const Fw::StringBase& message
      ) const;

      void log_WARNING_LO_DirectiveWhileNotAwaiting(
          const Svc::Fpy::DirectiveId& directive,
          I32 state
      ) const;

      void log_WARNING_LO_DirectiveFromOldSequence(
          const Svc::Fpy::DirectiveId& directive,
          U64 oldSequenceIdx,
          U64 currentSequenceIdx
      ) const;

    protected:

      // ----------------------------------------------------------------------
      // Telemetry serialized write
      // ----------------------------------------------------------------------

      void tlmWrite(
          FwChanIdType id, 
          Fw::TlmBuffer& _tlmBuff, 
          Fw::Time _tlmTime = Fw::Time() 
      ) const;

    protected:

      // ----------------------------------------------------------------------
      // Telemetry write functions
      // ----------------------------------------------------------------------

      void tlmWrite_State(
          FwEnumStoreType arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_SequencesSucceeded(
          U64 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_SequencesFailed(
          U64 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_SequencesCancelled(
          U64 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_StatementsDispatched(
          U64 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_StatementsFailed(
          U64 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_LastDirectiveError(
          const Svc::Fpy::DirectiveErrorCode& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_DirectiveErrorIndex(
          U64 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_DirectiveErrorId(
          const Svc::Fpy::DirectiveId& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_SeqPath(
          const Fw::StringBase& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_Debug_ReachedEndOfFile(
          bool arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_Debug_NextStatementReadSuccess(
          bool arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_Debug_NextStatementOpcode(
          U8 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_Debug_NextStatementIndex(
          U32 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_Debug_NextCmdOpcode(
          FwOpcodeType arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_Debug_StackSize(
          Svc::Fpy::StackSizeType arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_BreakpointInUse(
          bool arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_BreakpointIndex(
          U32 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_BreakOnlyOnceOnBreakpoint(
          bool arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_BreakBeforeNextLine(
          bool arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_PRM_STATEMENT_TIMEOUT_SECS(
          F32 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_PRM_SEQ_BASE_DIR(
          const Fw::StringBase& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

    protected:

      // ----------------------------------------------------------------------
      // Parameter hook functions
      // ----------------------------------------------------------------------

      virtual void parameterUpdated(
          FwPrmIdType id 
      );

      virtual void parametersLoaded();

      virtual void parameterLoaded(
          FwPrmIdType id, 
          Fw::ParamValid valid 
      );

    protected:

      // ----------------------------------------------------------------------
      // Parameter get functions
      // ----------------------------------------------------------------------

      F32 paramGet_STATEMENT_TIMEOUT_SECS(
          Fw::ParamValid& valid 
      );

      Fw::ParamString paramGet_SEQ_BASE_DIR(
          Fw::ParamValid& valid 
      );

    protected:

      // ----------------------------------------------------------------------
      // Time
      // ----------------------------------------------------------------------

      Fw::Time getTime() const;

    private:

      // ----------------------------------------------------------------------
      // Message dispatch functions
      // ----------------------------------------------------------------------

      virtual MsgDispatchStatus doDispatch();

    private:

      // ----------------------------------------------------------------------
      // Calls for messages received on special input ports
      // ----------------------------------------------------------------------

      static void m_p_cmdIn_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

    private:

      // ----------------------------------------------------------------------
      // Calls for messages received on typed input ports
      // ----------------------------------------------------------------------

      static void m_p_checkTimers_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          U32 context 
      );

      static void m_p_cmdResponseIn_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      );

      static void m_p_pingIn_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          U32 key 
      );

      static void m_p_seqCancelIn_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum 
      );

      static void m_p_seqRunIn_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          const Fw::StringBase& filename, 
          const Svc::SeqArgs& args 
      );

      static void m_p_tlmWrite_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          U32 context 
      );

    private:

      // ----------------------------------------------------------------------
      // Invocation functions for special output ports
      // ----------------------------------------------------------------------

      void cmdRegOut_out(
          FwIndexType portNum, 
          FwOpcodeType opCode 
      ) const;

      void cmdResponseOut_out(
          FwIndexType portNum, 
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      ) const;

      void logOut_out(
          FwIndexType portNum, 
          FwEventIdType id, 
          Fw::Time& timeTag, 
          const Fw::LogSeverity& severity, 
          Fw::LogBuffer& args 
      ) const;

#if FW_ENABLE_TEXT_LOGGING

      void logTextOut_out(
          FwIndexType portNum, 
          FwEventIdType id, 
          Fw::Time& timeTag, 
          const Fw::LogSeverity& severity, 
          Fw::TextLogString& text 
      ) const;

#endif

      Fw::ParamValid prmGet_out(
          FwIndexType portNum, 
          FwPrmIdType id, 
          Fw::ParamBuffer& val 
      ) const;

      void prmSet_out(
          FwIndexType portNum, 
          FwPrmIdType id, 
          Fw::ParamBuffer& val 
      ) const;

      void timeCaller_out(
          FwIndexType portNum, 
          Fw::Time& time 
      ) const;

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

    private:

      // ----------------------------------------------------------------------
      // Send signal helper functions
      // ----------------------------------------------------------------------

      void sendSignalStart(
          SmId smId, 
          FwEnumStoreType signal, 
          Fw::SerialBufferBase& buffer 
      );

      void sequencer_sendSignalFinish(
          Fw::LinearBufferBase& buffer 
      );

    private:

      // ----------------------------------------------------------------------
      // Helper functions for state machine dispatch
      // ----------------------------------------------------------------------

      void smDispatch(
          Fw::SerialBufferBase& buffer 
      );

      static void deserializeSmIdAndSignal(
          Fw::SerialBufferBase& buffer, 
          FwEnumStoreType& smId, 
          FwEnumStoreType& signal 
      );

      void Svc_FpySequencer_SequencerStateMachine_smDispatch(
          Fw::SerialBufferBase& buffer, 
          Svc_FpySequencer_SequencerStateMachine& sm, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      );

    private:

      // ----------------------------------------------------------------------
      // Parameter set functions
      // ----------------------------------------------------------------------

      Fw::CmdResponse paramSet_STATEMENT_TIMEOUT_SECS(
          Fw::SerialBufferBase& val 
      );

      Fw::CmdResponse paramSet_SEQ_BASE_DIR(
          Fw::SerialBufferBase& val 
      );

    private:

      // ----------------------------------------------------------------------
      // Parameter save functions
      // ----------------------------------------------------------------------

      Fw::CmdResponse paramSave_STATEMENT_TIMEOUT_SECS();

      Fw::CmdResponse paramSave_SEQ_BASE_DIR();

#if !FW_DIRECT_PORT_CALLS

    private:

      // ----------------------------------------------------------------------
      // Special input ports
      // ----------------------------------------------------------------------

      Fw::InputCmdPort m_cmdIn_InputPort[NUM_CMDIN_INPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

    private:

      // ----------------------------------------------------------------------
      // Typed input ports
      // ----------------------------------------------------------------------

      Svc::InputSchedPort m_checkTimers_InputPort[NUM_CHECKTIMERS_INPUT_PORTS];

      Fw::InputCmdResponsePort m_cmdResponseIn_InputPort[NUM_CMDRESPONSEIN_INPUT_PORTS];

      Svc::InputPingPort m_pingIn_InputPort[NUM_PINGIN_INPUT_PORTS];

      Svc::InputCmdSeqCancelPort m_seqCancelIn_InputPort[NUM_SEQCANCELIN_INPUT_PORTS];

      Svc::InputCmdSeqInPort m_seqRunIn_InputPort[NUM_SEQRUNIN_INPUT_PORTS];

      Svc::InputSchedPort m_tlmWrite_InputPort[NUM_TLMWRITE_INPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

    private:

      // ----------------------------------------------------------------------
      // Special output ports
      // ----------------------------------------------------------------------

      Fw::OutputCmdRegPort m_cmdRegOut_OutputPort[NUM_CMDREGOUT_OUTPUT_PORTS];

      Fw::OutputCmdResponsePort m_cmdResponseOut_OutputPort[NUM_CMDRESPONSEOUT_OUTPUT_PORTS];

      Fw::OutputLogPort m_logOut_OutputPort[NUM_LOGOUT_OUTPUT_PORTS];

#if FW_ENABLE_TEXT_LOGGING == 1

      Fw::OutputLogTextPort m_logTextOut_OutputPort[NUM_LOGTEXTOUT_OUTPUT_PORTS];

#endif

      Fw::OutputPrmGetPort m_prmGet_OutputPort[NUM_PRMGET_OUTPUT_PORTS];

      Fw::OutputPrmSetPort m_prmSet_OutputPort[NUM_PRMSET_OUTPUT_PORTS];

      Fw::OutputTimePort m_timeCaller_OutputPort[NUM_TIMECALLER_OUTPUT_PORTS];

      Fw::OutputTlmPort m_tlmOut_OutputPort[NUM_TLMOUT_OUTPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

    private:

      // ----------------------------------------------------------------------
      // Typed output ports
      // ----------------------------------------------------------------------

      Fw::OutputComPort m_cmdOut_OutputPort[NUM_CMDOUT_OUTPUT_PORTS];

      Fw::OutputPrmGetPort m_getParam_OutputPort[NUM_GETPARAM_OUTPUT_PORTS];

      Fw::OutputTlmGetPort m_getTlmChan_OutputPort[NUM_GETTLMCHAN_OUTPUT_PORTS];

      Svc::OutputPingPort m_pingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS];

      Fw::OutputCmdResponsePort m_seqDoneOut_OutputPort[NUM_SEQDONEOUT_OUTPUT_PORTS];

      Svc::OutputCmdSeqInPort m_seqStartOut_OutputPort[NUM_SEQSTARTOUT_OUTPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

    private:

      // ----------------------------------------------------------------------
      // Serial output ports
      // ----------------------------------------------------------------------

      Fw::OutputSerializePort m_serialOut_OutputPort[NUM_SERIALOUT_OUTPUT_PORTS];

#endif

    private:

      // ----------------------------------------------------------------------
      // First update flags for telemetry channels
      // ----------------------------------------------------------------------

      bool m_first_update_State = true;

      bool m_first_update_SequencesSucceeded = true;

      bool m_first_update_SequencesFailed = true;

      bool m_first_update_SequencesCancelled = true;

      bool m_first_update_StatementsDispatched = true;

      bool m_first_update_StatementsFailed = true;

      bool m_first_update_LastDirectiveError = true;

      bool m_first_update_DirectiveErrorIndex = true;

      bool m_first_update_DirectiveErrorId = true;

      bool m_first_update_SeqPath = true;

      bool m_first_update_Debug_ReachedEndOfFile = true;

      bool m_first_update_Debug_NextStatementReadSuccess = true;

      bool m_first_update_Debug_NextStatementOpcode = true;

      bool m_first_update_Debug_NextStatementIndex = true;

      bool m_first_update_Debug_NextCmdOpcode = true;

      bool m_first_update_Debug_StackSize = true;

      bool m_first_update_BreakpointInUse = true;

      bool m_first_update_BreakpointIndex = true;

      bool m_first_update_BreakOnlyOnceOnBreakpoint = true;

      bool m_first_update_BreakBeforeNextLine = true;

      bool m_first_update_PRM_STATEMENT_TIMEOUT_SECS = true;

      bool m_first_update_PRM_SEQ_BASE_DIR = true;

    private:

      // ----------------------------------------------------------------------
      // Last value storage for telemetry channels
      // ----------------------------------------------------------------------

      FwEnumStoreType m_last_State = {};

      U64 m_last_SequencesSucceeded = {};

      U64 m_last_SequencesFailed = {};

      U64 m_last_SequencesCancelled = {};

      U64 m_last_StatementsDispatched = {};

      U64 m_last_StatementsFailed = {};

      Svc::Fpy::DirectiveErrorCode m_last_LastDirectiveError = {};

      U64 m_last_DirectiveErrorIndex = {};

      Svc::Fpy::DirectiveId m_last_DirectiveErrorId = {};

      Fw::TlmString m_last_SeqPath = {};

      bool m_last_Debug_ReachedEndOfFile = {};

      bool m_last_Debug_NextStatementReadSuccess = {};

      U8 m_last_Debug_NextStatementOpcode = {};

      U32 m_last_Debug_NextStatementIndex = {};

      FwOpcodeType m_last_Debug_NextCmdOpcode = {};

      Svc::Fpy::StackSizeType m_last_Debug_StackSize = {};

      bool m_last_BreakpointInUse = {};

      U32 m_last_BreakpointIndex = {};

      bool m_last_BreakOnlyOnceOnBreakpoint = {};

      bool m_last_BreakBeforeNextLine = {};

      F32 m_last_PRM_STATEMENT_TIMEOUT_SECS = {};

      Fw::TlmString m_last_PRM_SEQ_BASE_DIR = {};

    private:

      // ----------------------------------------------------------------------
      // Parameter validity flags
      // ----------------------------------------------------------------------

      Fw::ParamValid m_param_STATEMENT_TIMEOUT_SECS_valid = Fw::ParamValid::UNINIT;

      Fw::ParamValid m_param_SEQ_BASE_DIR_valid = Fw::ParamValid::UNINIT;

    private:

      // ----------------------------------------------------------------------
      // Parameter variables
      // ----------------------------------------------------------------------

      F32 m_STATEMENT_TIMEOUT_SECS;

      Fw::ParamString m_SEQ_BASE_DIR;

    private:

      // ----------------------------------------------------------------------
      // State machine instances
      // ----------------------------------------------------------------------

      Svc_FpySequencer_SequencerStateMachine m_stateMachine_sequencer;

    private:

      // ----------------------------------------------------------------------
      // Mutexes
      // ----------------------------------------------------------------------

      Os::Mutex m_paramLock;

  };

}

#endif