WasmSequencerComponentAc.hpp

Go to the documentation of this file.

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

#ifndef Svc_WasmSequencerComponentAc_HPP
#define Svc_WasmSequencerComponentAc_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 "Os/Mutex.hpp"
#include "Svc/Sched/SchedPortAc.hpp"
#include "Svc/Seq/BlockStateEnumAc.hpp"
#include "Svc/Seq/CmdSeqCancelPortAc.hpp"
#include "Svc/Seq/CmdSeqInPortAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_CommandRequestSerializableAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_ControllerStateMachineStateMachineAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_ControllerStateMachine_StateEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_ExitReasonEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_HostFunctionEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_InterpreterStateMachineStateMachineAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_InterpreterStateMachine_StateEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_InvokeRequestSerializableAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_LoadRequestSerializableAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_MemoryGrowFailReasonEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_ModuleIdxAliasAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_RequestContextSerializableAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_SequencePhaseEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_SignalSourceEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_StatusEnumAc.hpp"
#include "Svc/WasmSequencer/WasmSequencer_TrapReasonEnumAc.hpp"
#include "default/config/FwIndexTypeAliasAc.hpp"
#include "default/config/FwOpcodeTypeAliasAc.hpp"
#include "default/config/FwSizeStoreTypeAliasAc.hpp"
#include "default/config/FwSizeTypeAliasAc.hpp"

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

namespace Svc {

  class WasmSequencerComponentBase :
    public Fw::ActiveComponentBase
  {

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

      friend class WasmSequencerTesterBase;
      friend class WasmSequencerTester;

    protected:

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

      enum {
        NUM_CMDIN_INPUT_PORTS = 1,
      };

      enum {
        NUM_CHECKTIMERS_INPUT_PORTS = 1,
        NUM_CMDRESPONSEIN_INPUT_PORTS = 1,
        NUM_SEQCANCELIN_INPUT_PORTS = 1,
        NUM_SEQRUNIN_INPUT_PORTS = 1,
        NUM_WRITETELEMETRY_INPUT_PORTS = 1,
      };

      enum {
        NUM_SERIALIN_INPUT_PORTS = 5,
      };

      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_SEQDONEOUT_OUTPUT_PORTS = 1,
        NUM_SEQSTARTOUT_OUTPUT_PORTS = 1,
      };

      enum {
        NUM_SERIALOUT_OUTPUT_PORTS = 5,
      };

      enum {
        OPCODE_RUN = 0x0, 
        OPCODE_LOAD = 0x1, 
        OPCODE_INVOKE = 0x2, 
        OPCODE_WAIT = 0x3, 
        OPCODE_CANCEL = 0x4, 
        OPCODE_PAUSE = 0x5, 
        OPCODE_CONTINUE = 0x6, 
        OPCODE_GLOBAL_SET_I32 = 0x7, 
        OPCODE_GLOBAL_SET_I64 = 0x8, 
        OPCODE_GLOBAL_SET_F32 = 0x9, 
        OPCODE_GLOBAL_SET_F64 = 0xa, 
        OPCODE_GLOBAL_GET = 0xb, 
        OPCODE_HOST_FUNCTION_TIMEOUT_SECS_SET = 0xc, 
        OPCODE_HOST_FUNCTION_TIMEOUT_SECS_SAVE = 0xd, 
        OPCODE_INSTRUCTION_FUEL_SET = 0xe, 
        OPCODE_INSTRUCTION_FUEL_SAVE = 0xf, 
        OPCODE_SEQ_BASE_DIR_SET = 0x10, 
        OPCODE_SEQ_BASE_DIR_SAVE = 0x11, 
      };

      enum {
        EVENTID_STOREALLOCATIONSUCCEEDED = 0x0, 
        EVENTID_CONTROLLERCANNOTINVOKE = 0x1, 
        EVENTID_CONTROLLERBUSY = 0x2, 
        EVENTID_MODULENOTFOUND = 0x3, 
        EVENTID_MEMORYGROWREJECTED = 0x4, 
        EVENTID_GLOBALSETFAILED = 0x5,
        EVENTID_GLOBALGETFAILED = 0x6,
        EVENTID_GLOBALVALUEI32 = 0x7,
        EVENTID_GLOBALVALUEI64 = 0x8,
        EVENTID_GLOBALVALUEF32 = 0x9,
        EVENTID_GLOBALVALUEF64 = 0xa,
        EVENTID_FILEOPENERROR = 0xb, 
        EVENTID_SEQUENCEFILEPATHTOOLONG = 0xc, 
        EVENTID_SEQUENCEFILEPATHNOTCONTAINED = 0xd, 
        EVENTID_MODULELOADFAILED = 0xe, 
        EVENTID_MODULEMAININVOKEFAILED = 0xf, 
        EVENTID_MODULESTARTINVOKEFAILED = 0x10, 
        EVENTID_TOOMANYBLOCKINGCOMMANDS = 0x11, 
        EVENTID_BUFFERTOOLARGE = 0x12, 
        EVENTID_BUFFERTOOSMALL = 0x13, 
        EVENTID_HOSTFUNCTIONINVALIDPOINTER = 0x14,
        EVENTID_INVALIDBLOCKINGTYPEVALUE = 0x15,
        EVENTID_HOSTFUNCTIONINVALIDPORT = 0x16, 
        EVENTID_SERIALPORTSENDFAILED = 0x17, 
        EVENTID_SERIALINFRAMETOOLARGE = 0x18, 
        EVENTID_HOSTFUNCTIONINVALIDSEVERITY = 0x19, 
        EVENTID_SEQUENCESTARTING = 0x1a, 
        EVENTID_SEQUENCESUCCEEDED = 0x1b, 
        EVENTID_SEQUENCECANCELLED = 0x1c, 
        EVENTID_SEQUENCEEXITED = 0x1d, 
        EVENTID_SEQUENCEPANIC = 0x1e, 
        EVENTID_SEQUENCETRAPPED = 0x1f, 
        EVENTID_SEQUENCEHOSTFAILURE = 0x20, 
        EVENTID_SEQUENCEPAUSED = 0x21, 
        EVENTID_SEQUENCENOTRUNNING = 0x22, 
        EVENTID_SLEEPDURATIONTOOLARGE = 0x23, 
        EVENTID_HOSTFUNCTIONINVALIDID = 0x24, 
        EVENTID_CMDRESPONSEFROMOLDSEQUENCE = 0x25, 
        EVENTID_WRONGCMDRESPONSEINDEX = 0x26, 
        EVENTID_INVALIDMODULEENTRYPOINT = 0x27,
        EVENTID_LOGWARNINGHI = 0x28, 
        EVENTID_LOGWARNINGLO = 0x29, 
        EVENTID_LOGACTIVITYHI = 0x2a, 
        EVENTID_LOGACTIVITYLO = 0x2b, 
        EVENTID_LOGDIAGNOSTIC = 0x2c, 
      };

      enum {
        CHANNELID_CONTROLLERSTATE = 0x0, 
        CHANNELID_INTERPRETERSTATE = 0x1, 
        CHANNELID_SEQUENCESSUCCEEDED = 0x2, 
        CHANNELID_SEQUENCESFAILED = 0x3, 
        CHANNELID_SEQUENCESCANCELLED = 0x4, 
        CHANNELID_COMMANDSDISPATCHED = 0x5, 
        CHANNELID_COMMANDSFAILED = 0x6, 
        CHANNELID_LASTTRAPREASON = 0x7, 
        CHANNELID_SEQNAME = 0x8, 
      };

      enum {
        PARAMID_HOST_FUNCTION_TIMEOUT_SECS = 0x0, 
        PARAMID_INSTRUCTION_FUEL = 0x1, 
        PARAMID_SEQ_BASE_DIR = 0x2, 
      };

      enum class SmId : FwEnumStoreType {
        controller,
        interpreter,
      };

    protected:

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

      class Svc_WasmSequencer_ControllerStateMachine :
        public Svc::WasmSequencer_ControllerStateMachineStateMachineBase
      {

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

          friend class WasmSequencerTesterBase;
          friend class WasmSequencerTester;

        public:

          Svc_WasmSequencer_ControllerStateMachine(
              WasmSequencerComponentBase& component 
          );

        public:

          void init(
              WasmSequencerComponentBase::SmId smId 
          );

        public:

          WasmSequencerComponentBase::SmId getId() const;

        private:

          void action_processInvoke(
              Signal signal, 
              const Svc::WasmSequencer_InvokeRequest& value 
          );

          void action_setCancelRequested(
              Signal signal 
          );

          void action_clearCancelRequested(
              Signal signal 
          );

          void action_cancelPendingRequest(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_respond_noblock_OK(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_respond_ERROR(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_incrementSequenceFailure(
              Signal signal 
          );

          void action_respondInvoke_BUSY(
              Signal signal, 
              const Svc::WasmSequencer_InvokeRequest& value 
          );

          void action_respondInvoke_ERROR(
              Signal signal, 
              const Svc::WasmSequencer_InvokeRequest& value 
          );

          void action_respondLoad_BUSY(
              Signal signal, 
              const Svc::WasmSequencer_LoadRequest& value 
          );

          void action_respond_block_OK(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_respond_block_ERROR(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_load(
              Signal signal, 
              const Svc::WasmSequencer_LoadRequest& value 
          );

          void action_invokeStart(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_invokeMain(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_reportModuleInvalidMain(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_reportModuleMainInvokeFailed(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_reportModuleStartInvokeFailed(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_reportModuleStarted(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_reportModuleSucceeded(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_reportModuleStartFailed(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_reportModuleMainFailed(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_resetStore(
              Signal signal 
          );

          void action_runEngine(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

        private:

          bool guard_cancelRequested(
              Signal signal 
          ) const;

          bool guard_moduleHasStart(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          ) const;

          bool guard_moduleHasValidMain(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          ) const;

          bool guard_invokeSucceeded(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          ) const;

          bool guard_interpreterSucceeded(
              Signal signal 
          ) const;

        private:

          WasmSequencerComponentBase& m_component;

      };

      class Svc_WasmSequencer_InterpreterStateMachine :
        public Svc::WasmSequencer_InterpreterStateMachineStateMachineBase
      {

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

          friend class WasmSequencerTesterBase;
          friend class WasmSequencerTester;

        public:

          Svc_WasmSequencer_InterpreterStateMachine(
              WasmSequencerComponentBase& component 
          );

        public:

          void init(
              WasmSequencerComponentBase::SmId smId 
          );

        public:

          WasmSequencerComponentBase::SmId getId() const;

        private:

          void action_cmdReplyOK(
              Signal signal, 
              const Svc::WasmSequencer_CommandRequest& value 
          );

          void action_signalEntered(
              Signal signal 
          );

          void action_spin(
              Signal signal 
          );

          void action_reset(
              Signal signal 
          );

          void action_clearExitStatus(
              Signal signal 
          );

          void action_setExitReason_INTERPRETER_FINISHED(
              Signal signal 
          );

          void action_setExitReason_INTERPRETER_TRAP(
              Signal signal 
          );

          void action_setExitReason_REPLY_TIMEOUT(
              Signal signal 
          );

          void action_setExitReason_HOST_FAILURE(
              Signal signal 
          );

          void action_setExitReason_TIMER_INCOMPARABLE(
              Signal signal 
          );

          void action_setExitReason_UNEXPECTED_REPLY(
              Signal signal 
          );

          void action_setExitReason_CANCEL(
              Signal signal 
          );

          void action_setExitCode(
              Signal signal, 
              I32 value 
          );

          void action_setTrapReason(
              Signal signal, 
              const Svc::WasmSequencer_TrapReason& value 
          );

          void action_setLastHostFunction(
              Signal signal 
          );

          void action_finish(
              Signal signal 
          );

          void action_reportPaused(
              Signal signal 
          );

          void action_clearPause(
              Signal signal 
          );

          void action_dispatchPendingHostFunction(
              Signal signal 
          );

          void action_clearPendingHostFunction(
              Signal signal 
          );

          void action_setContext(
              Signal signal, 
              const Svc::WasmSequencer_RequestContext& value 
          );

          void action_clearContext(
              Signal signal 
          );

          void action_resume(
              Signal signal 
          );

          void action_resumeI32(
              Signal signal, 
              I32 value 
          );

          void action_checkSleepTimers(
              Signal signal 
          );

          void action_checkTimeout(
              Signal signal 
          );

          void action_dequeueSerialAndResume(
              Signal signal, 
              const FwIndexType& value 
          );

        private:

          bool guard_pendingPause(
              Signal signal 
          ) const;

          bool guard_pendingHostFunction(
              Signal signal 
          ) const;

          bool guard_pendingHostFunctionIsSleep(
              Signal signal 
          ) const;

          bool guard_blockingSerialIn(
              Signal signal, 
              const FwIndexType& value 
          ) const;

          bool guard_dequeueSucceeded(
              Signal signal 
          ) const;

        private:

          WasmSequencerComponentBase& 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::InputCmdSeqCancelPort* get_seqCancelIn_InputPort(
          FwIndexType portNum 
      );

      Svc::InputCmdSeqInPort* get_seqRunIn_InputPort(
          FwIndexType portNum 
      );

      Svc::InputSchedPort* get_writeTelemetry_InputPort(
          FwIndexType portNum 
      );

#endif

#if !FW_DIRECT_PORT_CALLS

    public:

      // ----------------------------------------------------------------------
      // Getters for serial input ports
      // ----------------------------------------------------------------------

      Fw::InputSerializePort* get_serialIn_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_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_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
      // ----------------------------------------------------------------------

      WasmSequencerComponentBase(
          const char* compName = "" 
      );

      virtual ~WasmSequencerComponentBase();

    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_seqCancelIn_InputPorts() {
        return NUM_SEQCANCELIN_INPUT_PORTS;
      }

      static constexpr FwIndexType getNum_seqRunIn_InputPorts() {
        return NUM_SEQRUNIN_INPUT_PORTS;
      }

      static constexpr FwIndexType getNum_writeTelemetry_InputPorts() {
        return NUM_WRITETELEMETRY_INPUT_PORTS;
      }

    protected:

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

      static constexpr FwIndexType getNum_serialIn_InputPorts() {
        return NUM_SERIALIN_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_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_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 seqCancelIn_handler(
          FwIndexType portNum 
      ) = 0;

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

      virtual void writeTelemetry_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 seqCancelIn_handlerBase(
          FwIndexType portNum 
      );

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

      void writeTelemetry_handlerBase(
          FwIndexType portNum, 
          U32 context 
      );

    protected:

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

      virtual void serialIn_handler(
          FwIndexType portNum, 
          Fw::LinearBufferBase& buffer 
      ) = 0;

#if FW_DIRECT_PORT_CALLS
    public:
#else
    protected:
#endif

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

      void serialIn_handlerBase(
          FwIndexType portNum, 
          Fw::LinearBufferBase& buffer 
      );

    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 seqRunIn_preMsgHook(
          FwIndexType portNum, 
          const Fw::StringBase& filename, 
          const Svc::SeqArgs& args 
      );

      virtual void writeTelemetry_preMsgHook(
          FwIndexType portNum, 
          U32 context 
      );

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

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

      Svc_WasmSequencer_ControllerStateMachine::State controller_getState() const;

      Svc_WasmSequencer_InterpreterStateMachine::State interpreter_getState() const;

    protected:

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

      void controller_sendSignal_run(
          const Svc::WasmSequencer_LoadRequest& value 
      );

      void controller_sendSignal_load(
          const Svc::WasmSequencer_LoadRequest& value 
      );

      void controller_sendSignal_invoke(
          const Svc::WasmSequencer_InvokeRequest& value 
      );

      void controller_sendSignal_invoked(
          const Svc::WasmSequencer_RequestContext& value 
      );

      void controller_sendSignal_invokeFailed(
          const Svc::WasmSequencer_RequestContext& value 
      );

      void controller_sendSignal_cancel();

      void controller_sendSignal_loadSucceeded(
          const Svc::WasmSequencer_RequestContext& value 
      );

      void controller_sendSignal_loadFailed(
          const Svc::WasmSequencer_RequestContext& value 
      );

      void controller_sendSignal_engineFinished(
          const Svc::WasmSequencer_RequestContext& value 
      );

      void interpreter_sendSignal_cmd_CONTINUE();

      void interpreter_sendSignal_cmdCancel(
          const Svc::WasmSequencer_CommandRequest& value 
      );

      void interpreter_sendSignal_cancel();

      void interpreter_sendSignal_entered();

      void interpreter_sendSignal_run(
          const Svc::WasmSequencer_RequestContext& value 
      );

      void interpreter_sendSignal_checkTimers();

      void interpreter_sendSignal_hostResume();

      void interpreter_sendSignal_hostResumeI32(
          I32 value 
      );

      void interpreter_sendSignal_hostResponseFailure();

      void interpreter_sendSignal_hostResponseUnexpected(
          const Svc::WasmSequencer_HostFunction& value 
      );

      void interpreter_sendSignal_hostResponseTimeIncomparable();

      void interpreter_sendSignal_hostResponseTimeout();

      void interpreter_sendSignal_serialInMessage(
          const FwIndexType& value 
      );

      void interpreter_sendSignal_interpreterFinished(
          I32 value 
      );

      void interpreter_sendSignal_interpreterTrap(
          const Svc::WasmSequencer_TrapReason& value 
      );

      void interpreter_sendSignal_interpreterOutOfFuel();

      void interpreter_sendSignal_interpreterHostFunctionNeedsPause();

    protected:

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

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_processInvoke(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_InvokeRequest& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_setCancelRequested(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_clearCancelRequested(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_cancelPendingRequest(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_respond_noblock_OK(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_respond_ERROR(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_incrementSequenceFailure(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_respondInvoke_BUSY(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_InvokeRequest& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_respondInvoke_ERROR(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_InvokeRequest& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_respondLoad_BUSY(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_LoadRequest& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_respond_block_OK(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_respond_block_ERROR(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_load(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_LoadRequest& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_invokeStart(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_invokeMain(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleInvalidMain(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleMainInvokeFailed(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleStartInvokeFailed(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleStarted(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleSucceeded(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleStartFailed(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_reportModuleMainFailed(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_resetStore(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_ControllerStateMachine_action_runEngine(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_cmdReplyOK(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal, 
          const Svc::WasmSequencer_CommandRequest& value 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_signalEntered(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_spin(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_reset(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_clearExitStatus(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_INTERPRETER_FINISHED(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_INTERPRETER_TRAP(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_REPLY_TIMEOUT(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_HOST_FAILURE(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_TIMER_INCOMPARABLE(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_UNEXPECTED_REPLY(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitReason_CANCEL(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setExitCode(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal, 
          I32 value 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setTrapReason(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal, 
          const Svc::WasmSequencer_TrapReason& value 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setLastHostFunction(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_finish(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_reportPaused(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_clearPause(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_dispatchPendingHostFunction(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_clearPendingHostFunction(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_setContext(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_clearContext(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_resume(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_resumeI32(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal, 
          I32 value 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_checkSleepTimers(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_checkTimeout(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) = 0;

      virtual void Svc_WasmSequencer_InterpreterStateMachine_action_dequeueSerialAndResume(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal, 
          const FwIndexType& value 
      ) = 0;

    protected:

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

      virtual bool Svc_WasmSequencer_ControllerStateMachine_guard_cancelRequested(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_WasmSequencer_ControllerStateMachine_guard_moduleHasStart(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) const = 0;

      virtual bool Svc_WasmSequencer_ControllerStateMachine_guard_moduleHasValidMain(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) const = 0;

      virtual bool Svc_WasmSequencer_ControllerStateMachine_guard_invokeSucceeded(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal, 
          const Svc::WasmSequencer_RequestContext& value 
      ) const = 0;

      virtual bool Svc_WasmSequencer_ControllerStateMachine_guard_interpreterSucceeded(
          SmId smId, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_WasmSequencer_InterpreterStateMachine_guard_pendingPause(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_WasmSequencer_InterpreterStateMachine_guard_pendingHostFunction(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_WasmSequencer_InterpreterStateMachine_guard_pendingHostFunctionIsSleep(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      ) const = 0;

      virtual bool Svc_WasmSequencer_InterpreterStateMachine_guard_blockingSerialIn(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal, 
          const FwIndexType& value 
      ) const = 0;

      virtual bool Svc_WasmSequencer_InterpreterStateMachine_guard_dequeueSucceeded(
          SmId smId, 
          Svc_WasmSequencer_InterpreterStateMachine::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 LOAD_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName, 
          const Fw::CmdStringArg& name 
      ) = 0;

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

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

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

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

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

      virtual void GLOBAL_SET_I32_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& moduleName, 
          const Fw::CmdStringArg& name, 
          I32 value 
      ) = 0;

      virtual void GLOBAL_SET_I64_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& moduleName, 
          const Fw::CmdStringArg& name, 
          I64 value 
      ) = 0;

      virtual void GLOBAL_SET_F32_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& moduleName, 
          const Fw::CmdStringArg& name, 
          F32 value 
      ) = 0;

      virtual void GLOBAL_SET_F64_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& moduleName, 
          const Fw::CmdStringArg& name, 
          F64 value 
      ) = 0;

      virtual void GLOBAL_GET_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& moduleName, 
          const Fw::CmdStringArg& name 
      ) = 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 LOAD_cmdHandlerBase(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          Fw::CmdArgBuffer& args 
      );

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

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

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

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

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

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

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

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

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

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

      virtual void INVOKE_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void WAIT_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void PAUSE_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void CONTINUE_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void GLOBAL_SET_I32_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void GLOBAL_SET_I64_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void GLOBAL_SET_F32_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void GLOBAL_SET_F64_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

      virtual void GLOBAL_GET_preMsgHook(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );

    protected:

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

      void log_DIAGNOSTIC_StoreAllocationSucceeded(U16 moduleCount) const;

      void log_WARNING_LO_ControllerCannotInvoke() const;

      void log_WARNING_LO_ControllerBusy(
          const Svc::WasmSequencer_SignalSource& signalSource,
          const Svc::WasmSequencer_ControllerStateMachine_State& state
      ) const;

      void log_WARNING_LO_ModuleNotFound(const Fw::StringBase& module_name) const;

      void log_WARNING_LO_MemoryGrowRejected(
          const Svc::WasmSequencer_MemoryGrowFailReason& reason, 
          U64 requestedSize 
      ) const;

      void log_WARNING_LO_GlobalSetFailed(
          const Fw::StringBase& module_name,
          const Fw::StringBase& globalName,
          const Svc::WasmSequencer_Status& reason
      ) const;

      void log_WARNING_LO_GlobalGetFailed(
          const Fw::StringBase& module_name,
          const Fw::StringBase& globalName,
          const Svc::WasmSequencer_Status& reason
      ) const;

      void log_ACTIVITY_LO_GlobalValueI32(
          const Fw::StringBase& module_name,
          const Fw::StringBase& globalName,
          I32 value
      ) const;

      void log_ACTIVITY_LO_GlobalValueI64(
          const Fw::StringBase& module_name,
          const Fw::StringBase& globalName,
          I64 value
      ) const;

      void log_ACTIVITY_LO_GlobalValueF32(
          const Fw::StringBase& module_name,
          const Fw::StringBase& globalName,
          F32 value
      ) const;

      void log_ACTIVITY_LO_GlobalValueF64(
          const Fw::StringBase& module_name,
          const Fw::StringBase& globalName,
          F64 value
      ) const;

      void log_WARNING_HI_FileOpenError(
          const Fw::StringBase& fileName,
          I32 status
      ) const;

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

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

      void log_WARNING_HI_ModuleLoadFailed(const Svc::WasmSequencer_Status& status) const;

      void log_WARNING_HI_ModuleMainInvokeFailed(const Svc::WasmSequencer_Status& status) const;

      void log_WARNING_HI_ModuleStartInvokeFailed(const Svc::WasmSequencer_Status& status) const;

      void log_WARNING_HI_TooManyBlockingCommands() const;

      void log_WARNING_HI_BufferTooLarge(
          const Svc::WasmSequencer_HostFunction& host_function,
          U32 size,
          U32 maxSize
      ) const;

      void log_WARNING_HI_BufferTooSmall(
          const Svc::WasmSequencer_HostFunction& host_function,
          U32 size,
          U32 valueSize
      ) const;

      void log_WARNING_HI_HostFunctionInvalidPointer(
          const Svc::WasmSequencer_HostFunction& host_function,
          const Svc::WasmSequencer_Status& code
      ) const;

      void log_WARNING_HI_InvalidBlockingTypeValue(I32 invalidValue) const;

      void log_WARNING_HI_HostFunctionInvalidPort(
          const Svc::WasmSequencer_HostFunction& host_function,
          I32 index,
          U32 numPorts
      ) const;

      void log_WARNING_HI_SerialPortSendFailed(
          const Svc::WasmSequencer_HostFunction& host_function,
          I32 status
      ) const;

      void log_WARNING_HI_SerialInFrameTooLarge(
          U32 portIndex,
          U32 size,
          U32 maxSize
      ) const;

      void log_WARNING_HI_HostFunctionInvalidSeverity(
          I32 raw,
          const Fw::StringBase& msg
      ) const;

      void log_ACTIVITY_HI_SequenceStarting(Svc::WasmSequencer_ModuleIdx index) const;

      void log_ACTIVITY_HI_SequenceSucceeded(Svc::WasmSequencer_ModuleIdx index) const;

      void log_ACTIVITY_HI_SequenceCancelled(
          Svc::WasmSequencer_ModuleIdx index,
          const Svc::WasmSequencer_SequencePhase& phase
      ) const;

      void log_WARNING_HI_SequenceExited(
          Svc::WasmSequencer_ModuleIdx index,
          const Svc::WasmSequencer_SequencePhase& phase,
          I32 code
      ) const;

      void log_WARNING_HI_SequencePanic(
          Svc::WasmSequencer_ModuleIdx index,
          const Svc::WasmSequencer_SequencePhase& phase,
          I32 code
      ) const;

      void log_WARNING_HI_SequenceTrapped(
          Svc::WasmSequencer_ModuleIdx index,
          const Svc::WasmSequencer_SequencePhase& phase,
          const Svc::WasmSequencer_TrapReason& reason
      ) const;

      void log_WARNING_HI_SequenceHostFailure(
          Svc::WasmSequencer_ModuleIdx index,
          const Svc::WasmSequencer_SequencePhase& phase,
          const Svc::WasmSequencer_ExitReason& reason,
          const Svc::WasmSequencer_HostFunction& hostFunction
      ) const;

      void log_ACTIVITY_HI_SequencePaused() const;

      void log_WARNING_LO_SequenceNotRunning() const;

      void log_WARNING_HI_SleepDurationTooLarge(
          const Svc::WasmSequencer_HostFunction& host_function,
          U64 micros
      ) const;

      void log_WARNING_HI_HostFunctionInvalidId(
          const Svc::WasmSequencer_HostFunction& host_function,
          I64 id
      ) const;

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

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

      void log_WARNING_HI_InvalidModuleEntrypoint(
          Svc::WasmSequencer_ModuleIdx moduleIdx,
          const Svc::WasmSequencer_Status& status
      ) const;

      void log_WARNING_HI_LogWarningHi(const Fw::StringBase& msg) const;

      void log_WARNING_LO_LogWarningLo(const Fw::StringBase& msg) const;

      void log_ACTIVITY_HI_LogActivityHi(const Fw::StringBase& msg) const;

      void log_ACTIVITY_LO_LogActivityLo(const Fw::StringBase& msg) const;

      void log_DIAGNOSTIC_LogDiagnostic(const Fw::StringBase& msg) const;

    protected:

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

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

    protected:

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

      void tlmWrite_ControllerState(
          const Svc::WasmSequencer_ControllerStateMachine_State& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_InterpreterState(
          const Svc::WasmSequencer_InterpreterStateMachine_State& 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_CommandsDispatched(
          U64 arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

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

      void tlmWrite_LastTrapReason(
          const Svc::WasmSequencer_TrapReason& arg, 
          Fw::Time _tlmTime = Fw::Time() 
      );

      void tlmWrite_SeqName(
          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_HOST_FUNCTION_TIMEOUT_SECS(
          Fw::ParamValid& valid 
      );

      FwSizeType paramGet_INSTRUCTION_FUEL(
          Fw::ParamValid& valid 
      );

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

    protected:

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

      Fw::Time getTime() const;

    protected:

      // ----------------------------------------------------------------------
      // Mutex operations for guarded ports
      //
      // You can override these operations to provide more sophisticated
      // synchronization
      // ----------------------------------------------------------------------

      virtual void lock();

      virtual void unLock();

    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_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_writeTelemetry_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          U32 context 
      );

    private:

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

#if FW_PORT_SERIALIZATION

      static void m_p_serialIn_in(
          Fw::PassiveComponentBase* callComp, 
          FwIndexType portNum, 
          Fw::LinearBufferBase& buffer 
      );

#endif

    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 controller_sendSignalFinish(
          Fw::LinearBufferBase& buffer 
      );

      void interpreter_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_WasmSequencer_ControllerStateMachine_smDispatch(
          Fw::SerialBufferBase& buffer, 
          Svc_WasmSequencer_ControllerStateMachine& sm, 
          Svc_WasmSequencer_ControllerStateMachine::Signal signal 
      );

      void Svc_WasmSequencer_InterpreterStateMachine_smDispatch(
          Fw::SerialBufferBase& buffer, 
          Svc_WasmSequencer_InterpreterStateMachine& sm, 
          Svc_WasmSequencer_InterpreterStateMachine::Signal signal 
      );

    private:

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

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

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

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

    private:

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

      Fw::CmdResponse paramSave_HOST_FUNCTION_TIMEOUT_SECS();

      Fw::CmdResponse paramSave_INSTRUCTION_FUEL();

      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::InputCmdSeqCancelPort m_seqCancelIn_InputPort[NUM_SEQCANCELIN_INPUT_PORTS];

      Svc::InputCmdSeqInPort m_seqRunIn_InputPort[NUM_SEQRUNIN_INPUT_PORTS];

      Svc::InputSchedPort m_writeTelemetry_InputPort[NUM_WRITETELEMETRY_INPUT_PORTS];

#endif

#if !FW_DIRECT_PORT_CALLS

    private:

      // ----------------------------------------------------------------------
      // Serial input ports
      // ----------------------------------------------------------------------

      Fw::InputSerializePort m_serialIn_InputPort[NUM_SERIALIN_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];

      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_ControllerState = true;

      bool m_first_update_InterpreterState = true;

      bool m_first_update_SequencesSucceeded = true;

      bool m_first_update_SequencesFailed = true;

      bool m_first_update_SequencesCancelled = true;

      bool m_first_update_CommandsDispatched = true;

      bool m_first_update_CommandsFailed = true;

      bool m_first_update_LastTrapReason = true;

      bool m_first_update_SeqName = true;

    private:

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

      Svc::WasmSequencer_ControllerStateMachine_State m_last_ControllerState = {};

      Svc::WasmSequencer_InterpreterStateMachine_State m_last_InterpreterState = {};

      U64 m_last_SequencesSucceeded = {};

      U64 m_last_SequencesFailed = {};

      U64 m_last_SequencesCancelled = {};

      U64 m_last_CommandsDispatched = {};

      U64 m_last_CommandsFailed = {};

      Svc::WasmSequencer_TrapReason m_last_LastTrapReason = {};

      Fw::TlmString m_last_SeqName = {};

    private:

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

      Fw::ParamValid m_param_HOST_FUNCTION_TIMEOUT_SECS_valid = Fw::ParamValid::UNINIT;

      Fw::ParamValid m_param_INSTRUCTION_FUEL_valid = Fw::ParamValid::UNINIT;

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

    private:

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

      F32 m_HOST_FUNCTION_TIMEOUT_SECS;

      FwSizeType m_INSTRUCTION_FUEL;

      Fw::ParamString m_SEQ_BASE_DIR;

    private:

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

      Svc_WasmSequencer_ControllerStateMachine m_stateMachine_controller;

      Svc_WasmSequencer_InterpreterStateMachine m_stateMachine_interpreter;

    private:

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

      Os::Mutex m_guardedPortMutex;

      Os::Mutex m_paramLock;

  };

}

#endif