AosDeframerComponentAc.cpp

Go to the documentation of this file.

// ======================================================================
// \title  AosDeframerComponentAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for AosDeframer component base class
// ======================================================================

#include "Fw/Types/Assert.hpp"
#include "Fw/Types/ExternalString.hpp"
#if FW_ENABLE_TEXT_LOGGING
#include "Fw/Types/String.hpp"
#endif
#include "Svc/Ccsds/AosDeframer/AosDeframerComponentAc.hpp"

namespace Svc {

  namespace Ccsds {

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

    void AosDeframerComponentBase ::
      init(FwEnumStoreType instance)
    {
      // Initialize base class
      Fw::PassiveComponentBase::init(instance);

#if !FW_DIRECT_PORT_CALLS
      // Connect input port dataIn
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataIn_InputPorts());
        port++
      ) {
        this->m_dataIn_InputPort[port].init();
        this->m_dataIn_InputPort[port].addCallComp(
          this,
          m_p_dataIn_in
        );
        this->m_dataIn_InputPort[port].setPortNum(port);

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataIn_InputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataIn_InputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect input port dataReturnIn
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataReturnIn_InputPorts());
        port++
      ) {
        this->m_dataReturnIn_InputPort[port].init();
        this->m_dataReturnIn_InputPort[port].addCallComp(
          this,
          m_p_dataReturnIn_in
        );
        this->m_dataReturnIn_InputPort[port].setPortNum(port);

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataReturnIn_InputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataReturnIn_InputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port logOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_logOut_OutputPorts());
        port++
      ) {
        this->m_logOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_logOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_logOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS && FW_ENABLE_TEXT_LOGGING
      // Connect output port logTextOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_logTextOut_OutputPorts());
        port++
      ) {
        this->m_logTextOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_logTextOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_logTextOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port prmGetOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_prmGetOut_OutputPorts());
        port++
      ) {
        this->m_prmGetOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_prmGetOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_prmGetOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port prmSetOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_prmSetOut_OutputPorts());
        port++
      ) {
        this->m_prmSetOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_prmSetOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_prmSetOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port timeCaller
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_timeCaller_OutputPorts());
        port++
      ) {
        this->m_timeCaller_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_timeCaller_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_timeCaller_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port tlmOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_tlmOut_OutputPorts());
        port++
      ) {
        this->m_tlmOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_tlmOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_tlmOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port allocate
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_allocate_OutputPorts());
        port++
      ) {
        this->m_allocate_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_allocate_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_allocate_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port dataOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataOut_OutputPorts());
        port++
      ) {
        this->m_dataOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port dataReturnOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataReturnOut_OutputPorts());
        port++
      ) {
        this->m_dataReturnOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataReturnOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataReturnOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port deallocate
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_deallocate_OutputPorts());
        port++
      ) {
        this->m_deallocate_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_deallocate_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_deallocate_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port errorNotify
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_errorNotify_OutputPorts());
        port++
      ) {
        this->m_errorNotify_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_errorNotify_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_errorNotify_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif
    }

#if !FW_DIRECT_PORT_CALLS

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

    Svc::InputComDataWithContextPort* AosDeframerComponentBase ::
      get_dataIn_InputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return &this->m_dataIn_InputPort[portNum];
    }

    Svc::InputComDataWithContextPort* AosDeframerComponentBase ::
      get_dataReturnIn_InputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return &this->m_dataReturnIn_InputPort[portNum];
    }

#endif

#if !FW_DIRECT_PORT_CALLS

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

    void AosDeframerComponentBase ::
      set_logOut_OutputPort(
          FwIndexType portNum,
          Fw::InputLogPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logOut_OutputPort[portNum].addCallPort(port);
    }

#if FW_ENABLE_TEXT_LOGGING == 1

    void AosDeframerComponentBase ::
      set_logTextOut_OutputPort(
          FwIndexType portNum,
          Fw::InputLogTextPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logTextOut_OutputPort[portNum].addCallPort(port);
    }

#endif

    void AosDeframerComponentBase ::
      set_prmGetOut_OutputPort(
          FwIndexType portNum,
          Fw::InputPrmGetPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmGetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_prmGetOut_OutputPort[portNum].addCallPort(port);
    }

    void AosDeframerComponentBase ::
      set_prmSetOut_OutputPort(
          FwIndexType portNum,
          Fw::InputPrmSetPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmSetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_prmSetOut_OutputPort[portNum].addCallPort(port);
    }

    void AosDeframerComponentBase ::
      set_timeCaller_OutputPort(
          FwIndexType portNum,
          Fw::InputTimePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_timeCaller_OutputPort[portNum].addCallPort(port);
    }

    void AosDeframerComponentBase ::
      set_tlmOut_OutputPort(
          FwIndexType portNum,
          Fw::InputTlmPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_tlmOut_OutputPort[portNum].addCallPort(port);
    }

#endif

#if !FW_DIRECT_PORT_CALLS

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

    void AosDeframerComponentBase ::
      set_allocate_OutputPort(
          FwIndexType portNum,
          Fw::InputBufferGetPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_allocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_allocate_OutputPort[portNum].addCallPort(port);
    }

    void AosDeframerComponentBase ::
      set_dataOut_OutputPort(
          FwIndexType portNum,
          Svc::InputComDataWithContextPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataOut_OutputPort[portNum].addCallPort(port);
    }

    void AosDeframerComponentBase ::
      set_dataReturnOut_OutputPort(
          FwIndexType portNum,
          Svc::InputComDataWithContextPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataReturnOut_OutputPort[portNum].addCallPort(port);
    }

    void AosDeframerComponentBase ::
      set_deallocate_OutputPort(
          FwIndexType portNum,
          Fw::InputBufferSendPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_deallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_deallocate_OutputPort[portNum].addCallPort(port);
    }

    void AosDeframerComponentBase ::
      set_errorNotify_OutputPort(
          FwIndexType portNum,
          Svc::Ccsds::InputErrorNotifyPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_errorNotify_OutputPort[portNum].addCallPort(port);
    }

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

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

    void AosDeframerComponentBase ::
      set_logOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logOut_OutputPort[portNum].registerSerialPort(port);
    }

#if FW_ENABLE_TEXT_LOGGING == 1

    void AosDeframerComponentBase ::
      set_logTextOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logTextOut_OutputPort[portNum].registerSerialPort(port);
    }

#endif

    void AosDeframerComponentBase ::
      set_prmSetOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmSetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_prmSetOut_OutputPort[portNum].registerSerialPort(port);
    }

    void AosDeframerComponentBase ::
      set_timeCaller_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
    }

    void AosDeframerComponentBase ::
      set_tlmOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
    }

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

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

    void AosDeframerComponentBase ::
      set_dataOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataOut_OutputPort[portNum].registerSerialPort(port);
    }

    void AosDeframerComponentBase ::
      set_dataReturnOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataReturnOut_OutputPort[portNum].registerSerialPort(port);
    }

    void AosDeframerComponentBase ::
      set_deallocate_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_deallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_deallocate_OutputPort[portNum].registerSerialPort(port);
    }

    void AosDeframerComponentBase ::
      set_errorNotify_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_errorNotify_OutputPort[portNum].registerSerialPort(port);
    }

#endif

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

    AosDeframerComponentBase ::
      AosDeframerComponentBase(const char* compName) :
        Fw::PassiveComponentBase(compName)
    {

    }

    AosDeframerComponentBase ::
      ~AosDeframerComponentBase()
    {

    }

#if !FW_DIRECT_PORT_CALLS

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

    bool AosDeframerComponentBase ::
      isConnected_logOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_logOut_OutputPort[portNum].isConnected();
    }

#if FW_ENABLE_TEXT_LOGGING == 1

    bool AosDeframerComponentBase ::
      isConnected_logTextOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_logTextOut_OutputPort[portNum].isConnected();
    }

#endif

    bool AosDeframerComponentBase ::
      isConnected_prmGetOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmGetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_prmGetOut_OutputPort[portNum].isConnected();
    }

    bool AosDeframerComponentBase ::
      isConnected_prmSetOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmSetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_prmSetOut_OutputPort[portNum].isConnected();
    }

    bool AosDeframerComponentBase ::
      isConnected_timeCaller_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_timeCaller_OutputPort[portNum].isConnected();
    }

    bool AosDeframerComponentBase ::
      isConnected_tlmOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_tlmOut_OutputPort[portNum].isConnected();
    }

#endif

#if !FW_DIRECT_PORT_CALLS

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

    bool AosDeframerComponentBase ::
      isConnected_allocate_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_allocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_allocate_OutputPort[portNum].isConnected();
    }

    bool AosDeframerComponentBase ::
      isConnected_dataOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_dataOut_OutputPort[portNum].isConnected();
    }

    bool AosDeframerComponentBase ::
      isConnected_dataReturnOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_dataReturnOut_OutputPort[portNum].isConnected();
    }

    bool AosDeframerComponentBase ::
      isConnected_deallocate_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_deallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_deallocate_OutputPort[portNum].isConnected();
    }

    bool AosDeframerComponentBase ::
      isConnected_errorNotify_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_errorNotify_OutputPort[portNum].isConnected();
    }

#endif

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

    void AosDeframerComponentBase ::
      dataIn_handlerBase(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      // Make sure port number is valid
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      // Lock guard mutex before calling
      this->lock();

      // Call handler function
      this->dataIn_handler(
        portNum,
        data,
        context
      );

      // Unlock guard mutex
      this->unLock();
    }

    void AosDeframerComponentBase ::
      dataReturnIn_handlerBase(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      // Make sure port number is valid
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      // Call handler function
      this->dataReturnIn_handler(
        portNum,
        data,
        context
      );
    }

#if !FW_DIRECT_PORT_CALLS

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

    Fw::Buffer AosDeframerComponentBase ::
      allocate_out(
          FwIndexType portNum,
          FwSizeType size
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_allocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_allocate_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      return this->m_allocate_OutputPort[portNum].invoke(
        size
      );
    }

    void AosDeframerComponentBase ::
      dataOut_out(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_dataOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_dataOut_OutputPort[portNum].invoke(
        data,
        context
      );
    }

    void AosDeframerComponentBase ::
      dataReturnOut_out(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_dataReturnOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_dataReturnOut_OutputPort[portNum].invoke(
        data,
        context
      );
    }

    void AosDeframerComponentBase ::
      deallocate_out(
          FwIndexType portNum,
          Fw::Buffer& fwBuffer
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_deallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_deallocate_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_deallocate_OutputPort[portNum].invoke(
        fwBuffer
      );
    }

    void AosDeframerComponentBase ::
      errorNotify_out(
          FwIndexType portNum,
          const Svc::Ccsds::FrameError& errorCode
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_errorNotify_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_errorNotify_OutputPort[portNum].invoke(
        errorCode
      );
    }

#endif

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

    void AosDeframerComponentBase ::
      log_WARNING_LO_InvalidSpacecraftId(
          U16 transmitted,
          U16 configured
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_INVALIDSPACECRAFTID;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(2));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U16))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(transmitted);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U16))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(configured);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_LO,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Invalid Spacecraft ID Received. Received: %" PRIu16 " | Deframer configured with: %" PRIu16 "";
#else
        const char* _formatString =
          "%s: Invalid Spacecraft ID Received. Received: %" PRIu16 " | Deframer configured with: %" PRIu16 "";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "InvalidSpacecraftId ",
          transmitted,
          configured
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_LO,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_InvalidFrameLength(
          FwSizeType actual,
          U32 expected
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_INVALIDFRAMELENGTH;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(2));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(FwSizeType))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(actual);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U32))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(expected);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Frame length mismatch. Received: %" PRIu64 " | Expected: %" PRIu32 " ";
#else
        const char* _formatString =
          "%s: Frame length mismatch. Received: %" PRIu64 " | Expected: %" PRIu32 " ";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "InvalidFrameLength ",
          actual,
          expected
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_ACTIVITY_LO_InvalidVcId(
          U8 transmitted,
          U8 configured
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_INVALIDVCID;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(2));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(transmitted);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(configured);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::ACTIVITY_LO,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Invalid Virtual Channel ID. Frame contained: %" PRIu8 " | Accepted VCIDs: %" PRIu8 "";
#else
        const char* _formatString =
          "%s: Invalid Virtual Channel ID. Frame contained: %" PRIu8 " | Accepted VCIDs: %" PRIu8 "";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "InvalidVcId ",
          transmitted,
          configured
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::ACTIVITY_LO,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_InvalidFecf(
          U16 transmitted,
          U16 computed
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_INVALIDFECF;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(2));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U16))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(transmitted);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U16))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(computed);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Invalid FECF (CRC) received. Trailer specified: %" PRIu16 " | Computed on board: %" PRIu16 "";
#else
        const char* _formatString =
          "%s: Invalid FECF (CRC) received. Trailer specified: %" PRIu16 " | Computed on board: %" PRIu16 "";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "InvalidFecf ",
          transmitted,
          computed
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_InvalidTfvn(
          U8 transmitted,
          U8 expected
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_INVALIDTFVN;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(2));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(transmitted);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(expected);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Invalid CCSDS Transfer Frame Version Number. Received: %" PRIu8 " | Expected: %" PRIu8 "";
#else
        const char* _formatString =
          "%s: Invalid CCSDS Transfer Frame Version Number. Received: %" PRIu8 " | Expected: %" PRIu8 "";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "InvalidTfvn ",
          transmitted,
          expected
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_DisabledPvn(
          U8 vcId,
          U8 pvn
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_DISABLEDPVN;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(2));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(vcId);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(pvn);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Packet version number %" PRIu8 " encountered on VC %" PRIu8 " but it is invalid or disabled by configuration";
#else
        const char* _formatString =
          "%s: Packet version number %" PRIu8 " encountered on VC %" PRIu8 " but it is invalid or disabled by configuration";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "DisabledPvn ",
          vcId,
          pvn
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_ACTIVITY_LO_IdleFrame(U8 vcId) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_IDLEFRAME;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(1));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(vcId);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::ACTIVITY_LO,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Received frame containing only idle data on VC %" PRIu8 "";
#else
        const char* _formatString =
          "%s: Received frame containing only idle data on VC %" PRIu8 "";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "IdleFrame ",
          vcId
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::ACTIVITY_LO,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_SpanningPacketAllocFailed(
          U8 vcId,
          ComCfg::Pvn pvn,
          FwSizeType packetSize
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_SPANNINGPACKETALLOCFAILED;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(3));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(vcId);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(ComCfg::Pvn::SERIALIZED_SIZE)
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(pvn);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(FwSizeType))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(packetSize);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Spanning packet allocation failed on VC %" PRIu8 " for %s packet of %" PRIu64 " bytes; packet dropped";
#else
        const char* _formatString =
          "%s: Spanning packet allocation failed on VC %" PRIu8 " for %s packet of %" PRIu64 " bytes; packet dropped";
#endif

        Fw::String pvnStr;
        pvn.toString(pvnStr);

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "SpanningPacketAllocFailed ",
          vcId,
          pvnStr.toChar(),
          packetSize
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_VcFrameCountGap(
          U8 vcId,
          U32 received,
          U32 expected
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_VCFRAMECOUNTGAP;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(3));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(vcId);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U32))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(received);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U32))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(expected);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: VC frame count gap on VC %" PRIu8 ". Received %" PRIu32 " | Expected next count %" PRIu32 "";
#else
        const char* _formatString =
          "%s: VC frame count gap on VC %" PRIu8 ". Received %" PRIu32 " | Expected next count %" PRIu32 "";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "VcFrameCountGap ",
          vcId,
          received,
          expected
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_SpanningPacketAbandoned(
          U8 vcId,
          ComCfg::Pvn pvn,
          FwSizeType bytesReceived,
          FwSizeType bytesExpected
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_SPANNINGPACKETABANDONED;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(4));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(vcId);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(ComCfg::Pvn::SERIALIZED_SIZE)
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(pvn);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(FwSizeType))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(bytesReceived);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(FwSizeType))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(bytesExpected);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Spanning packet on VC %" PRIu8 " (%s) abandoned after receiving %" PRIu64 " of %" PRIu64 " expected bytes";
#else
        const char* _formatString =
          "%s: Spanning packet on VC %" PRIu8 " (%s) abandoned after receiving %" PRIu64 " of %" PRIu64 " expected bytes";
#endif

        Fw::String pvnStr;
        pvn.toString(pvnStr);

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "SpanningPacketAbandoned ",
          vcId,
          pvnStr.toChar(),
          bytesReceived,
          bytesExpected
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

    void AosDeframerComponentBase ::
      log_WARNING_HI_InvalidFhp(
          U8 vcId,
          FwSizeType fhpReceived,
          FwSizeType dataZoneSize
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_INVALIDFHP;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

#if FW_AMPCS_COMPATIBLE
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(3));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U8))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(vcId);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(FwSizeType))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(fhpReceived);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(FwSizeType))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(dataZoneSize);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Invalid First Header Pointer (FHP) received on VC %" PRIu8 ": FHP was %" PRIu64 " bytes, data zone is only %" PRIu64 " bytes";
#else
        const char* _formatString =
          "%s: Invalid First Header Pointer (FHP) received on VC %" PRIu8 ": FHP was %" PRIu64 " bytes, data zone is only %" PRIu64 " bytes";
#endif

        Fw::TextLogString _logString;
        _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "InvalidFhp ",
          vcId,
          fhpReceived,
          dataZoneSize
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

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

    void AosDeframerComponentBase ::
      tlmWrite(
          FwChanIdType id,
          Fw::TlmBuffer& _tlmBuff,
          Fw::Time _tlmTime
      ) const
    {
      if (this->isConnected_tlmOut_OutputPort(0)) {
        if (
          this->isConnected_timeCaller_OutputPort(0) &&
          (_tlmTime ==  Fw::ZERO_TIME)
        ) {
          this->timeCaller_out(0, _tlmTime);
        }

        FwChanIdType _id;
        _id = this->getIdBase() + id;

        this->tlmOut_out(
          0,
          _id,
          _tlmTime,
          _tlmBuff
        );
      }
    }

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

    void AosDeframerComponentBase ::
      tlmWrite_LatestVcFrameCount(
          U32 arg,
          Fw::Time _tlmTime
      ) const
    {
      if (this->isConnected_tlmOut_OutputPort(0)) {
        Fw::TlmBuffer _tlmBuff;
        Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
        FW_ASSERT(
          _stat == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_stat)
        );

        this->tlmWrite(
          CHANNELID_LATESTVCFRAMECOUNT,
          _tlmBuff,
          _tlmTime
        );
      }
    }

    void AosDeframerComponentBase ::
      tlmWrite_FramesProcessed(
          U32 arg,
          Fw::Time _tlmTime
      ) const
    {
      if (this->isConnected_tlmOut_OutputPort(0)) {
        Fw::TlmBuffer _tlmBuff;
        Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
        FW_ASSERT(
          _stat == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_stat)
        );

        this->tlmWrite(
          CHANNELID_FRAMESPROCESSED,
          _tlmBuff,
          _tlmTime
        );
      }
    }

    void AosDeframerComponentBase ::
      tlmWrite_PacketsExtracted(
          U32 arg,
          Fw::Time _tlmTime
      ) const
    {
      if (this->isConnected_tlmOut_OutputPort(0)) {
        Fw::TlmBuffer _tlmBuff;
        Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
        FW_ASSERT(
          _stat == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_stat)
        );

        this->tlmWrite(
          CHANNELID_PACKETSEXTRACTED,
          _tlmBuff,
          _tlmTime
        );
      }
    }

    void AosDeframerComponentBase ::
      tlmWrite_CrcErrorCount(
          U32 arg,
          Fw::Time _tlmTime
      ) const
    {
      if (this->isConnected_tlmOut_OutputPort(0)) {
        Fw::TlmBuffer _tlmBuff;
        Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
        FW_ASSERT(
          _stat == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_stat)
        );

        this->tlmWrite(
          CHANNELID_CRCERRORCOUNT,
          _tlmBuff,
          _tlmTime
        );
      }
    }

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

    Fw::Time AosDeframerComponentBase ::
      getTime() const
    {
      if (this->isConnected_timeCaller_OutputPort(0)) {
        Fw::Time _time;
        this->timeCaller_out(0, _time);
        return _time;
      }
      else {
        return Fw::Time(TimeBase::TB_NONE, 0, 0);
      }
    }

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

    void AosDeframerComponentBase ::
      lock()
    {
      this->m_guardedPortMutex.lock();
    }

    void AosDeframerComponentBase ::
      unLock()
    {
      this->m_guardedPortMutex.unLock();
    }

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

    void AosDeframerComponentBase ::
      m_p_dataIn_in(
          Fw::PassiveComponentBase* callComp,
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      FW_ASSERT(callComp);
      AosDeframerComponentBase* compPtr = static_cast<AosDeframerComponentBase*>(callComp);
      compPtr->dataIn_handlerBase(
        portNum,
        data,
        context
      );
    }

    void AosDeframerComponentBase ::
      m_p_dataReturnIn_in(
          Fw::PassiveComponentBase* callComp,
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      FW_ASSERT(callComp);
      AosDeframerComponentBase* compPtr = static_cast<AosDeframerComponentBase*>(callComp);
      compPtr->dataReturnIn_handlerBase(
        portNum,
        data,
        context
      );
    }

#if !FW_DIRECT_PORT_CALLS

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

    void AosDeframerComponentBase ::
      logOut_out(
          FwIndexType portNum,
          FwEventIdType id,
          Fw::Time& timeTag,
          const Fw::LogSeverity& severity,
          Fw::LogBuffer& args
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_logOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_logOut_OutputPort[portNum].invoke(
        id,
        timeTag,
        severity,
        args
      );
    }

#if FW_ENABLE_TEXT_LOGGING

    void AosDeframerComponentBase ::
      logTextOut_out(
          FwIndexType portNum,
          FwEventIdType id,
          Fw::Time& timeTag,
          const Fw::LogSeverity& severity,
          Fw::TextLogString& text
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_logTextOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_logTextOut_OutputPort[portNum].invoke(
        id,
        timeTag,
        severity,
        text
      );
    }

#endif

    void AosDeframerComponentBase ::
      timeCaller_out(
          FwIndexType portNum,
          Fw::Time& time
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_timeCaller_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_timeCaller_OutputPort[portNum].invoke(
        time
      );
    }

    void AosDeframerComponentBase ::
      tlmOut_out(
          FwIndexType portNum,
          FwChanIdType id,
          Fw::Time& timeTag,
          Fw::TlmBuffer& val
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_tlmOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_tlmOut_OutputPort[portNum].invoke(
        id,
        timeTag,
        val
      );
    }

#endif

  }

}