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"
#if FW_ENABLE_TEXT_LOGGING == 1
#include "Fw/Log/LogTextPortAc.hpp"
#endif
#include "Fw/Port/InputSerializePort.hpp"
#include "Fw/Port/OutputSerializePort.hpp"
#include "Fw/Prm/PrmGetPortAc.hpp"
#include "Fw/Prm/PrmSetPortAc.hpp"
#include "Fw/Prm/PrmString.hpp"
#include "Fw/Time/Time.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/DirectiveIdEnumAc.hpp"
#include "Svc/FpySequencer/FpySequencer_BinaryRegOpDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_BlockStateEnumAc.hpp"
#include "Svc/FpySequencer/FpySequencer_CmdDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_DebugBreakpointArgsSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_DebugTelemetrySerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_DeserSerRegDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_DirectiveErrorCodeEnumAc.hpp"
#include "Svc/FpySequencer/FpySequencer_ExitDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GetPrmDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GetTlmDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GotoDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_IfDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_NoOpDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SequenceExecutionArgsSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SequencerStateMachineStateMachineAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SetRegDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_SetSerRegDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_UnaryRegOpDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_WaitAbsDirectiveSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencer_WaitRelDirectiveSerializableAc.hpp"
#include "Svc/Ping/PingPortAc.hpp"
#include "Svc/Sched/SchedPortAc.hpp"
#include "Svc/Seq/CmdSeqInPortAc.hpp"
#include "default/config/FwChanIdTypeAliasAc.hpp"
#include "default/config/FwOpcodeTypeAliasAc.hpp"
#include "default/config/FwPrmIdTypeAliasAc.hpp"
#include "default/config/FwSizeTypeAliasAc.hpp"

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_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 {
        OPCODE_RUN = 0x0, 
        OPCODE_VALIDATE = 0x1, 
        OPCODE_RUN_VALIDATED = 0x2, 
        OPCODE_CANCEL = 0x3, 
        OPCODE_DEBUG_SET_BREAKPOINT = 0x4, 
        OPCODE_DEBUG_BREAK = 0x5, 
        OPCODE_DEBUG_CONTINUE = 0x6, 
        OPCODE_DEBUG_CLEAR_BREAKPOINT = 0x7, 
        OPCODE_STATEMENT_TIMEOUT_SECS_SET = 0x8, 
        OPCODE_STATEMENT_TIMEOUT_SECS_SAVE = 0x9, 
      };

      enum {
        EVENTID_INVALIDCOMMAND = 0x0,
        EVENTID_INVALIDSEQRUNCALL = 0x1,
        EVENTID_FILEOPENERROR = 0x2,
        EVENTID_FILEREADERROR = 0x3,
        EVENTID_ENDOFFILEERROR = 0x4,
        EVENTID_FILEREADDESERIALIZEERROR = 0x5,
        EVENTID_WRONGSCHEMAVERSION = 0x6,
        EVENTID_WRONGCRC = 0x7,
        EVENTID_EXTRABYTESINSEQUENCE = 0x8,
        EVENTID_INSUFFICIENTBUFFERSPACE = 0x9,
        EVENTID_COMMANDFAILED = 0xa,
        EVENTID_SEQUENCEDONE = 0xb,
        EVENTID_SEQUENCECANCELLED = 0xc,
        EVENTID_UNKNOWNSEQUENCERDIRECTIVE = 0xd,
        EVENTID_CMDRESPONSEWHILENOTRUNNINGSEQUENCE = 0xe,
        EVENTID_CMDRESPONSEFROMOLDSEQUENCE = 0xf,
        EVENTID_CMDRESPONSEWHILENOTAWAITING = 0x10,
        EVENTID_CMDRESPONSEWHILEAWAITINGDIRECTIVE = 0x11,
        EVENTID_WRONGCMDRESPONSEOPCODE = 0x12,
        EVENTID_WRONGCMDRESPONSEINDEX = 0x13,
        EVENTID_DIRECTIVEDESERIALIZEERROR = 0x14,
        EVENTID_MISMATCHEDTIMEBASE = 0x15,
        EVENTID_MISMATCHEDTIMECONTEXT = 0x16,
        EVENTID_COMMANDTIMEDOUT = 0x17,
        EVENTID_DIRECTIVETIMEDOUT = 0x18,
        EVENTID_TOOMANYSEQUENCEARGS = 0x19,
        EVENTID_TOOMANYSEQUENCESTATEMENTS = 0x1a,
        EVENTID_DEBUGBROKEN = 0x1b,
        EVENTID_DEBUGBREAKPOINTSET = 0x1c,
        EVENTID_DEBUGBREAKPOINTCLEARED = 0x1d,
      };

      enum {
        CHANNELID_STATE = 0x0, 
        CHANNELID_SEQUENCESSUCCEEDED = 0x1, 
        CHANNELID_SEQUENCESFAILED = 0x2, 
        CHANNELID_SEQUENCESCANCELLED = 0x3, 
        CHANNELID_STATEMENTSDISPATCHED = 0x4, 
        CHANNELID_STATEMENTSFAILED = 0x5, 
        CHANNELID_LASTDIRECTIVEERROR = 0x6, 
        CHANNELID_SEQPATH = 0x7, 
        CHANNELID_DEBUGBREAKPOINTIDX = 0x8, 
        CHANNELID_DEBUG = 0x9, 
        CHANNELID_PRM_STATEMENT_TIMEOUT_SECS = 0xa, 
      };

      enum {
        PARAMID_STATEMENT_TIMEOUT_SECS = 0x0, 
      };

      enum class SmId : FwEnumStoreType {
        sequencer,
      };

    PROTECTED:

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

      class Svc_FpySequencer_SequencerStateMachine :
        public Svc::FpySequencer_SequencerStateMachineStateMachineBase
      {

        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_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_clearDebugBreakpoint(
              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_report_debugBroken(
              Signal signal 
          );

          void action_setDebugBreakpoint(
              Signal signal, 
              const Svc::FpySequencer_DebugBreakpointArgs& value 
          );

        PRIVATE:

          bool guard_goalStateIs_RUNNING(
              Signal signal 
          ) const;

          bool guard_shouldDebugBreak(
              Signal signal 
          ) const;

          bool guard_debugBreakOnce(
              Signal signal 
          ) const;

        PRIVATE:

          FpySequencerComponentBase& m_component;

      };

    public:

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

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

    public:

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

      Fw::InputCmdPort* get_cmdIn_InputPort(
          FwIndexType portNum 
      );

    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::InputCmdSeqInPort* get_seqRunIn_InputPort(
          FwIndexType portNum 
      );

      Svc::InputSchedPort* get_tlmWrite_InputPort(
          FwIndexType portNum 
      );

    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 
      );

    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 
      );

#if 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_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

    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
      // ----------------------------------------------------------------------

      FwIndexType getNum_cmdIn_InputPorts() const;

    PROTECTED:

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

      FwIndexType getNum_checkTimers_InputPorts() const;

      FwIndexType getNum_cmdResponseIn_InputPorts() const;

      FwIndexType getNum_pingIn_InputPorts() const;

      FwIndexType getNum_seqRunIn_InputPorts() const;

      FwIndexType getNum_tlmWrite_InputPorts() const;

    PROTECTED:

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

      FwIndexType getNum_cmdRegOut_OutputPorts() const;

      FwIndexType getNum_cmdResponseOut_OutputPorts() const;

      FwIndexType getNum_logOut_OutputPorts() const;

#if FW_ENABLE_TEXT_LOGGING == 1

      FwIndexType getNum_logTextOut_OutputPorts() const;

#endif

      FwIndexType getNum_prmGet_OutputPorts() const;

      FwIndexType getNum_prmSet_OutputPorts() const;

      FwIndexType getNum_timeCaller_OutputPorts() const;

      FwIndexType getNum_tlmOut_OutputPorts() const;

    PROTECTED:

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

      FwIndexType getNum_cmdOut_OutputPorts() const;

      FwIndexType getNum_getParam_OutputPorts() const;

      FwIndexType getNum_getTlmChan_OutputPorts() const;

      FwIndexType getNum_pingOut_OutputPorts() const;

      FwIndexType getNum_seqDoneOut_OutputPorts() const;

      FwIndexType getNum_seqStartOut_OutputPorts() const;

    PROTECTED:

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

      bool isConnected_cmdRegOut_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_cmdResponseOut_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_logOut_OutputPort(
          FwIndexType portNum 
      );

#if FW_ENABLE_TEXT_LOGGING == 1

      bool isConnected_logTextOut_OutputPort(
          FwIndexType portNum 
      );

#endif

      bool isConnected_prmGet_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_prmSet_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_timeCaller_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_tlmOut_OutputPort(
          FwIndexType portNum 
      );

    PROTECTED:

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

      bool isConnected_cmdOut_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_getParam_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_getTlmChan_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_pingOut_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_seqDoneOut_OutputPort(
          FwIndexType portNum 
      );

      bool isConnected_seqStartOut_OutputPort(
          FwIndexType portNum 
      );

    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 seqRunIn_handler(
          FwIndexType portNum, 
          const Fw::StringBase& filename 
      ) = 0;

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

    PROTECTED:

      // ----------------------------------------------------------------------
      // 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 seqRunIn_handlerBase(
          FwIndexType portNum, 
          const Fw::StringBase& filename 
      );

      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 checkTimers_preMsgHook(
          FwIndexType portNum, 
          U32 context 
      );

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

      virtual void pingIn_preMsgHook(
          FwIndexType portNum, 
          U32 key 
      );

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

      virtual void tlmWrite_preMsgHook(
          FwIndexType portNum, 
          U32 context 
      );

    PROTECTED:

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

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

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

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

      void pingOut_out(
          FwIndexType portNum, 
          U32 key 
      );

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

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

    PROTECTED:

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

      virtual void directive_binaryRegOp_internalInterfaceHandler(const Svc::FpySequencer_BinaryRegOpDirective& directive) = 0;

      virtual void directive_cmd_internalInterfaceHandler(const Svc::FpySequencer_CmdDirective& directive) = 0;

      virtual void directive_deserSerReg_internalInterfaceHandler(const Svc::FpySequencer_DeserSerRegDirective& directive) = 0;

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

      virtual void directive_getPrm_internalInterfaceHandler(const Svc::FpySequencer_GetPrmDirective& directive) = 0;

      virtual void directive_getTlm_internalInterfaceHandler(const Svc::FpySequencer_GetTlmDirective& directive) = 0;

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

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

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

      virtual void directive_setReg_internalInterfaceHandler(const Svc::FpySequencer_SetRegDirective& directive) = 0;

      virtual void directive_setSerReg_internalInterfaceHandler(const Svc::FpySequencer_SetSerRegDirective& directive) = 0;

      virtual void directive_unaryRegOp_internalInterfaceHandler(const Svc::FpySequencer_UnaryRegOpDirective& directive) = 0;

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

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

    PROTECTED:

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

      void directive_binaryRegOp_internalInterfaceInvoke(const Svc::FpySequencer_BinaryRegOpDirective& directive);

      void directive_cmd_internalInterfaceInvoke(const Svc::FpySequencer_CmdDirective& directive);

      void directive_deserSerReg_internalInterfaceInvoke(const Svc::FpySequencer_DeserSerRegDirective& directive);

      void directive_exit_internalInterfaceInvoke(const Svc::FpySequencer_ExitDirective& directive);

      void directive_getPrm_internalInterfaceInvoke(const Svc::FpySequencer_GetPrmDirective& directive);

      void directive_getTlm_internalInterfaceInvoke(const Svc::FpySequencer_GetTlmDirective& directive);

      void directive_goto_internalInterfaceInvoke(const Svc::FpySequencer_GotoDirective& directive);

      void directive_if_internalInterfaceInvoke(const Svc::FpySequencer_IfDirective& directive);

      void directive_noOp_internalInterfaceInvoke(const Svc::FpySequencer_NoOpDirective& directive);

      void directive_setReg_internalInterfaceInvoke(const Svc::FpySequencer_SetRegDirective& directive);

      void directive_setSerReg_internalInterfaceInvoke(const Svc::FpySequencer_SetSerRegDirective& directive);

      void directive_unaryRegOp_internalInterfaceInvoke(const Svc::FpySequencer_UnaryRegOpDirective& directive);

      void directive_waitAbs_internalInterfaceInvoke(const Svc::FpySequencer_WaitAbsDirective& directive);

      void directive_waitRel_internalInterfaceInvoke(const Svc::FpySequencer_WaitRelDirective& directive);

    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_DEBUG_SET_BREAKPOINT(
          const Svc::FpySequencer_DebugBreakpointArgs& value 
      );

      void sequencer_sendSignal_cmd_DEBUG_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_DEBUG_CONTINUE();

      void sequencer_sendSignal_cmd_DEBUG_BREAK(
          const Svc::FpySequencer_DebugBreakpointArgs& value 
      );

    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_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_clearDebugBreakpoint(
          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_report_debugBroken(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_FpySequencer_SequencerStateMachine_action_setDebugBreakpoint(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal, 
          const Svc::FpySequencer_DebugBreakpointArgs& value 
      ) = 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_shouldDebugBreak(
          SmId smId, 
          Svc_FpySequencer_SequencerStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_FpySequencer_SequencerStateMachine_guard_debugBreakOnce(
          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, 
          Svc::FpySequencer_BlockState block 
      ) = 0;

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

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

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

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

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

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

      virtual void DEBUG_CLEAR_BREAKPOINT_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      ) = 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 VALIDATE_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 DEBUG_SET_BREAKPOINT_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

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

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

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

      virtual void RUN_VALIDATED_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void CANCEL_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void DEBUG_SET_BREAKPOINT_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void DEBUG_BREAK_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void DEBUG_CONTINUE_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void DEBUG_CLEAR_BREAKPOINT_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_FileOpenError(
          const Fw::StringBase& filePath,
          I32 errorCode
      ) const;

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

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

      void log_WARNING_HI_FileReadDeserializeError(
          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(U32 remaining) const;

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

      void log_WARNING_HI_CommandFailed(
          FwOpcodeType opCode,
          U32 stmtIdx,
          const Fw::StringBase& filePath,
          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_UnknownSequencerDirective(
          U8 opcode,
          U32 stmtIdx,
          const Fw::StringBase& filePath
      ) const;

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

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

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

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

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

      void log_WARNING_HI_WrongCmdResponseIndex(
          FwOpcodeType opcode,
          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_TooManySequenceStatements(
          U16 count,
          U16 max
      ) const;

      void log_ACTIVITY_HI_DebugBroken(
          U32 stmtIdx,
          bool breakOnce
      ) const;

      void log_ACTIVITY_HI_DebugBreakpointSet(
          U32 breakpointIdx,
          bool breakOnce
      ) const;

      void log_ACTIVITY_HI_DebugBreakpointCleared() const;

    PROTECTED:

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

      void tlmWrite_State(
          I32 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::FpySequencer_DirectiveErrorCode& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

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

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

      void tlmWrite_Debug(
          const Svc::FpySequencer_DebugTelemetry& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

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

    PROTECTED:

      // ----------------------------------------------------------------------
      // Parameter update hook
      // ----------------------------------------------------------------------

      virtual void parameterUpdated(
          FwPrmIdType id 
      );

      // ----------------------------------------------------------------------
      // Parameter load hook
      // ----------------------------------------------------------------------

      virtual void parametersLoaded();

    PROTECTED:

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

      F32 paramGet_STATEMENT_TIMEOUT_SECS(
          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_seqRunIn_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          const Fw::StringBase& filename 
      );

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

    PRIVATE:

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

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

      void sequencer_sendSignalFinish(
          Fw::SerializeBufferBase& buffer 
      );

    PRIVATE:

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

      void smDispatch(
          Fw::SerializeBufferBase& buffer 
      );

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

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

    PRIVATE:

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

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

    PRIVATE:

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

      Fw::CmdResponse paramSave_STATEMENT_TIMEOUT_SECS();

    PRIVATE:

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

      Fw::InputCmdPort m_cmdIn_InputPort[NUM_CMDIN_INPUT_PORTS];

    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::InputCmdSeqInPort m_seqRunIn_InputPort[NUM_SEQRUNIN_INPUT_PORTS];

      Svc::InputSchedPort m_tlmWrite_InputPort[NUM_TLMWRITE_INPUT_PORTS];

    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];

    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];

    PRIVATE:

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

      bool m_first_update_State;

      bool m_first_update_SequencesSucceeded;

      bool m_first_update_SequencesFailed;

      bool m_first_update_SequencesCancelled;

      bool m_first_update_StatementsDispatched;

      bool m_first_update_StatementsFailed;

      bool m_first_update_LastDirectiveError;

      bool m_first_update_SeqPath;

      bool m_first_update_DebugBreakpointIdx;

      bool m_first_update_Debug;

      bool m_first_update_PRM_STATEMENT_TIMEOUT_SECS;

    PRIVATE:

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

      I32 m_last_State;

      U64 m_last_SequencesSucceeded;

      U64 m_last_SequencesFailed;

      U64 m_last_SequencesCancelled;

      U64 m_last_StatementsDispatched;

      U64 m_last_StatementsFailed;

      Svc::FpySequencer_DirectiveErrorCode m_last_LastDirectiveError;

      Fw::TlmString m_last_SeqPath;

      U32 m_last_DebugBreakpointIdx;

      Svc::FpySequencer_DebugTelemetry m_last_Debug;

      F32 m_last_PRM_STATEMENT_TIMEOUT_SECS;

    PRIVATE:

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

      Fw::ParamValid m_param_STATEMENT_TIMEOUT_SECS_valid;

    PRIVATE:

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

      F32 m_STATEMENT_TIMEOUT_SECS;

    PRIVATE:

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

      Svc_FpySequencer_SequencerStateMachine m_stateMachine_sequencer;

    PRIVATE:

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

      Os::Mutex m_paramLock;

  };

}

#endif