FileWorkerComponentAc.cpp

Go to the documentation of this file.

// ======================================================================
// \title  FileWorkerComponentAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for FileWorker 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/FileWorker/FileWorkerComponentAc.hpp"

namespace Svc {

  namespace {
    enum MsgTypeEnum {
      FILEWORKER_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
      READIN_FILEREAD,
      VERIFYIN_VERIFYSTATUS,
      WRITEIN_FILEWRITE,
    };

    // Get the max size by constructing a union of the async input, command, and
    // internal port serialization sizes
    union BuffUnion {
      BYTE readInPortSize[Svc::InputFileReadPort::SERIALIZED_SIZE];
      BYTE verifyInPortSize[Svc::InputVerifyStatusPort::SERIALIZED_SIZE];
      BYTE writeInPortSize[Svc::InputFileWritePort::SERIALIZED_SIZE];
      BYTE cmdPortSize[Fw::InputCmdPort::SERIALIZED_SIZE];
    };

    // Define a message buffer class large enough to handle all the
    // asynchronous inputs to the component
    class ComponentIpcSerializableBuffer :
      public Fw::LinearBufferBase
    {

      public:

        enum {
          // Offset into data in buffer: Size of message ID and port number
          DATA_OFFSET = sizeof(FwEnumStoreType) + sizeof(FwIndexType),
          // Max data size
          MAX_DATA_SIZE = sizeof(BuffUnion),
          // Max message size: Size of message id + size of port + max data size
          SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE
        };

        Fw::Serializable::SizeType getCapacity() const {
          return sizeof(m_buff);
        }

        U8* getBuffAddr() {
          return m_buff;
        }

        const U8* getBuffAddr() const {
          return m_buff;
        }

      private:
        // Should be the max of all the input ports serialized sizes...
        U8 m_buff[SERIALIZATION_SIZE];

    };
  }

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

  void FileWorkerComponentBase ::
    init(
        FwSizeType queueDepth,
        FwEnumStoreType instance
    )
  {
    // Initialize base class
    Fw::ActiveComponentBase::init(instance);

    // Connect input port cmdIn
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_cmdIn_InputPorts());
      port++
    ) {
      this->m_cmdIn_InputPort[port].init();
      this->m_cmdIn_InputPort[port].addCallComp(
        this,
        m_p_cmdIn_in
      );
      this->m_cmdIn_InputPort[port].setPortNum(port);

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

    // Connect input port cancelIn
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_cancelIn_InputPorts());
      port++
    ) {
      this->m_cancelIn_InputPort[port].init();
      this->m_cancelIn_InputPort[port].addCallComp(
        this,
        m_p_cancelIn_in
      );
      this->m_cancelIn_InputPort[port].setPortNum(port);

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

    // Connect input port readIn
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_readIn_InputPorts());
      port++
    ) {
      this->m_readIn_InputPort[port].init();
      this->m_readIn_InputPort[port].addCallComp(
        this,
        m_p_readIn_in
      );
      this->m_readIn_InputPort[port].setPortNum(port);

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

    // Connect input port verifyIn
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_verifyIn_InputPorts());
      port++
    ) {
      this->m_verifyIn_InputPort[port].init();
      this->m_verifyIn_InputPort[port].addCallComp(
        this,
        m_p_verifyIn_in
      );
      this->m_verifyIn_InputPort[port].setPortNum(port);

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

    // Connect input port writeIn
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_writeIn_InputPorts());
      port++
    ) {
      this->m_writeIn_InputPort[port].init();
      this->m_writeIn_InputPort[port].addCallComp(
        this,
        m_p_writeIn_in
      );
      this->m_writeIn_InputPort[port].setPortNum(port);

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

    // Connect output port cmdRegOut
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_cmdRegOut_OutputPorts());
      port++
    ) {
      this->m_cmdRegOut_OutputPort[port].init();

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

    // Connect output port cmdResponseOut
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_cmdResponseOut_OutputPorts());
      port++
    ) {
      this->m_cmdResponseOut_OutputPort[port].init();

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

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

#if FW_ENABLE_TEXT_LOGGING == 1
    // 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

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

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

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

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

    // Connect output port readDoneOut
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_readDoneOut_OutputPorts());
      port++
    ) {
      this->m_readDoneOut_OutputPort[port].init();

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

    // Connect output port verifyDoneOut
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_verifyDoneOut_OutputPorts());
      port++
    ) {
      this->m_verifyDoneOut_OutputPort[port].init();

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

    // Connect output port writeDoneOut
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_writeDoneOut_OutputPorts());
      port++
    ) {
      this->m_writeDoneOut_OutputPort[port].init();

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

    // Create the queue
    Os::Queue::Status qStat = this->createQueue(
      queueDepth,
      static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
    );
    FW_ASSERT(
      Os::Queue::Status::OP_OK == qStat,
      static_cast<FwAssertArgType>(qStat)
    );
  }

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

  Fw::InputCmdPort* FileWorkerComponentBase ::
    get_cmdIn_InputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cmdIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    return &this->m_cmdIn_InputPort[portNum];
  }

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

  Svc::InputCancelStatusPort* FileWorkerComponentBase ::
    get_cancelIn_InputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cancelIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    return &this->m_cancelIn_InputPort[portNum];
  }

  Svc::InputFileReadPort* FileWorkerComponentBase ::
    get_readIn_InputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_readIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    return &this->m_readIn_InputPort[portNum];
  }

  Svc::InputVerifyStatusPort* FileWorkerComponentBase ::
    get_verifyIn_InputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_verifyIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    return &this->m_verifyIn_InputPort[portNum];
  }

  Svc::InputFileWritePort* FileWorkerComponentBase ::
    get_writeIn_InputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_writeIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    return &this->m_writeIn_InputPort[portNum];
  }

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

  void FileWorkerComponentBase ::
    set_cmdRegOut_OutputPort(
        FwIndexType portNum,
        Fw::InputCmdRegPort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cmdRegOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    set_cmdResponseOut_OutputPort(
        FwIndexType portNum,
        Fw::InputCmdResponsePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cmdResponseOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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);
  }

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

  void FileWorkerComponentBase ::
    set_readDoneOut_OutputPort(
        FwIndexType portNum,
        Svc::InputSignalDonePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_readDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    set_verifyDoneOut_OutputPort(
        FwIndexType portNum,
        Svc::InputSignalDonePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_verifyDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    set_writeDoneOut_OutputPort(
        FwIndexType portNum,
        Svc::InputSignalDonePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_writeDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

#if FW_PORT_SERIALIZATION

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

  void FileWorkerComponentBase ::
    set_cmdRegOut_OutputPort(
        FwIndexType portNum,
        Fw::InputSerializePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cmdRegOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    set_cmdResponseOut_OutputPort(
        FwIndexType portNum,
        Fw::InputSerializePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cmdResponseOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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 FileWorkerComponentBase ::
    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_PORT_SERIALIZATION

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

  void FileWorkerComponentBase ::
    set_readDoneOut_OutputPort(
        FwIndexType portNum,
        Fw::InputSerializePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_readDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    set_verifyDoneOut_OutputPort(
        FwIndexType portNum,
        Fw::InputSerializePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_verifyDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void FileWorkerComponentBase ::
    set_writeDoneOut_OutputPort(
        FwIndexType portNum,
        Fw::InputSerializePort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_writeDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

#endif

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

  FileWorkerComponentBase ::
    FileWorkerComponentBase(const char* compName) :
      Fw::ActiveComponentBase(compName)
  {
    this->m_NotInIdleThrottle = 0;
    this->m_CrcFailedThrottle = 0;
    this->m_ReadFailedFileSizeThrottle = 0;
    this->m_OpenFileErrorThrottle = 0;
    this->m_WriteFileErrorThrottle = 0;
    this->m_WriteValidationOpenErrorThrottle = 0;
    this->m_WriteValidationReadErrorThrottle = 0;

    this->m_NotInIdleThrottleTime = Fw::Time();
    this->m_CrcFailedThrottleTime = Fw::Time();
    this->m_ReadFailedFileSizeThrottleTime = Fw::Time();
    this->m_OpenFileErrorThrottleTime = Fw::Time();
    this->m_WriteFileErrorThrottleTime = Fw::Time();
    this->m_WriteValidationOpenErrorThrottleTime = Fw::Time();
    this->m_WriteValidationReadErrorThrottleTime = Fw::Time();
  }

  FileWorkerComponentBase ::
    ~FileWorkerComponentBase()
  {

  }

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

  bool FileWorkerComponentBase ::
    isConnected_cmdRegOut_OutputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cmdRegOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  bool FileWorkerComponentBase ::
    isConnected_cmdResponseOut_OutputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cmdResponseOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  bool FileWorkerComponentBase ::
    isConnected_logOut_OutputPort(FwIndexType portNum)
  {
    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 FileWorkerComponentBase ::
    isConnected_logTextOut_OutputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

#endif

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

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

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

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

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

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

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

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

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

  bool FileWorkerComponentBase ::
    isConnected_readDoneOut_OutputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_readDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  bool FileWorkerComponentBase ::
    isConnected_verifyDoneOut_OutputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_verifyDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  bool FileWorkerComponentBase ::
    isConnected_writeDoneOut_OutputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_writeDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

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

  void FileWorkerComponentBase ::
    cancelIn_handlerBase(FwIndexType portNum)
  {
    // Make sure port number is valid
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_cancelIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

    // Call handler function
    this->cancelIn_handler(portNum);

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

  void FileWorkerComponentBase ::
    readIn_handlerBase(
        FwIndexType portNum,
        const Fw::StringBase& path,
        Fw::Buffer& buffer
    )
  {
    // Make sure port number is valid
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_readIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    // Call pre-message hook
    readIn_preMsgHook(
      portNum,
      path,
      buffer
    );
    ComponentIpcSerializableBuffer msg;
    Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

    // Serialize message ID
    _status = msg.serializeFrom(
      static_cast<FwEnumStoreType>(READIN_FILEREAD)
    );
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize port number
    _status = msg.serializeFrom(portNum);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument path
    _status = path.serializeTo(msg, 200);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument buffer
    _status = msg.serializeFrom(buffer);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Send message
    Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
    Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

    FW_ASSERT(
      qStatus == Os::Queue::OP_OK,
      static_cast<FwAssertArgType>(qStatus)
    );
  }

  void FileWorkerComponentBase ::
    verifyIn_handlerBase(
        FwIndexType portNum,
        const Fw::StringBase& path,
        U32 crc
    )
  {
    // Make sure port number is valid
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_verifyIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    // Call pre-message hook
    verifyIn_preMsgHook(
      portNum,
      path,
      crc
    );
    ComponentIpcSerializableBuffer msg;
    Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

    // Serialize message ID
    _status = msg.serializeFrom(
      static_cast<FwEnumStoreType>(VERIFYIN_VERIFYSTATUS)
    );
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize port number
    _status = msg.serializeFrom(portNum);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument path
    _status = path.serializeTo(msg, 200);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument crc
    _status = msg.serializeFrom(crc);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Send message
    Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
    Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

    FW_ASSERT(
      qStatus == Os::Queue::OP_OK,
      static_cast<FwAssertArgType>(qStatus)
    );
  }

  void FileWorkerComponentBase ::
    writeIn_handlerBase(
        FwIndexType portNum,
        const Fw::StringBase& path,
        Fw::Buffer& buffer,
        FwSizeType offsetBytes,
        bool append
    )
  {
    // Make sure port number is valid
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_writeIn_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    // Call pre-message hook
    writeIn_preMsgHook(
      portNum,
      path,
      buffer,
      offsetBytes,
      append
    );
    ComponentIpcSerializableBuffer msg;
    Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

    // Serialize message ID
    _status = msg.serializeFrom(
      static_cast<FwEnumStoreType>(WRITEIN_FILEWRITE)
    );
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize port number
    _status = msg.serializeFrom(portNum);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument path
    _status = path.serializeTo(msg, 200);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument buffer
    _status = msg.serializeFrom(buffer);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument offsetBytes
    _status = msg.serializeFrom(offsetBytes);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Serialize argument append
    _status = msg.serializeFrom(append);
    FW_ASSERT(
      _status == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_status)
    );

    // Send message
    Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
    Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

    FW_ASSERT(
      qStatus == Os::Queue::OP_OK,
      static_cast<FwAssertArgType>(qStatus)
    );
  }

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

  void FileWorkerComponentBase ::
    readIn_preMsgHook(
        FwIndexType portNum,
        const Fw::StringBase& path,
        Fw::Buffer& buffer
    )
  {
    // Default: no-op
  }

  void FileWorkerComponentBase ::
    verifyIn_preMsgHook(
        FwIndexType portNum,
        const Fw::StringBase& path,
        U32 crc
    )
  {
    // Default: no-op
  }

  void FileWorkerComponentBase ::
    writeIn_preMsgHook(
        FwIndexType portNum,
        const Fw::StringBase& path,
        Fw::Buffer& buffer,
        FwSizeType offsetBytes,
        bool append
    )
  {
    // Default: no-op
  }

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

  void FileWorkerComponentBase ::
    readDoneOut_out(
        FwIndexType portNum,
        U32 status,
        FwSizeType sizeBytes
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_readDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    FW_ASSERT(
      this->m_readDoneOut_OutputPort[portNum].isConnected(),
      static_cast<FwAssertArgType>(portNum)
    );
    this->m_readDoneOut_OutputPort[portNum].invoke(
      status,
      sizeBytes
    );
  }

  void FileWorkerComponentBase ::
    verifyDoneOut_out(
        FwIndexType portNum,
        U32 status,
        FwSizeType sizeBytes
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_verifyDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    FW_ASSERT(
      this->m_verifyDoneOut_OutputPort[portNum].isConnected(),
      static_cast<FwAssertArgType>(portNum)
    );
    this->m_verifyDoneOut_OutputPort[portNum].invoke(
      status,
      sizeBytes
    );
  }

  void FileWorkerComponentBase ::
    writeDoneOut_out(
        FwIndexType portNum,
        U32 status,
        FwSizeType sizeBytes
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_writeDoneOut_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    FW_ASSERT(
      this->m_writeDoneOut_OutputPort[portNum].isConnected(),
      static_cast<FwAssertArgType>(portNum)
    );
    this->m_writeDoneOut_OutputPort[portNum].invoke(
      status,
      sizeBytes
    );
  }

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

  void FileWorkerComponentBase ::
    log_WARNING_HI_NotInIdle(U32 currState)
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_NOTINIDLE;

    // Check throttle value & throttle timeout
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      if (this->m_NotInIdleThrottle >= EVENTID_NOTINIDLE_THROTTLE) {
        // The counter has overflowed, check if time interval has passed
        if (Fw::TimeInterval(this->m_NotInIdleThrottleTime, _logTime) >= Fw::TimeInterval(10, 0)) {
          // Reset the count
          this->m_NotInIdleThrottle = 0;
        } else {
          // Throttle the event
          return;
        }
      }

      // Reset the throttle time if needed
      if (this->m_NotInIdleThrottle == 0) {
        // This is the first event, reset the throttle time
        this->m_NotInIdleThrottleTime = _logTime;
      }

      // Increment the count
      this->m_NotInIdleThrottle++;
    }

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(U32))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(currState);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Not in IDLE state, currently in state: %" PRIu32 "";
#else
      const char* _formatString =
        "%s: Not in IDLE state, currently in state: %" PRIu32 "";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_CrcFailed(U32 crcStat)
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_CRCFAILED;

    // Check throttle value & throttle timeout
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      if (this->m_CrcFailedThrottle >= EVENTID_CRCFAILED_THROTTLE) {
        // The counter has overflowed, check if time interval has passed
        if (Fw::TimeInterval(this->m_CrcFailedThrottleTime, _logTime) >= Fw::TimeInterval(10, 0)) {
          // Reset the count
          this->m_CrcFailedThrottle = 0;
        } else {
          // Throttle the event
          return;
        }
      }

      // Reset the throttle time if needed
      if (this->m_CrcFailedThrottle == 0) {
        // This is the first event, reset the throttle time
        this->m_CrcFailedThrottleTime = _logTime;
      }

      // Increment the count
      this->m_CrcFailedThrottle++;
    }

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(U32))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(crcStat);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed CRC check with %" PRIu32 " status";
#else
      const char* _formatString =
        "%s: Failed CRC check with %" PRIu32 " status";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_LO_CrcVerificationError(
        U32 crcExp,
        U32 crcCalculated
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_CRCVERIFICATIONERROR;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(U32))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(crcExp);
      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(crcCalculated);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed to verify file. Expected CRC %" PRIu32 ". Actual CRC %" PRIu32 "";
#else
      const char* _formatString =
        "%s: Failed to verify file. Expected CRC %" PRIu32 ". Actual CRC %" PRIu32 "";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_ReadFailedFileSize(U32 fsStat)
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_READFAILEDFILESIZE;

    // Check throttle value & throttle timeout
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      if (this->m_ReadFailedFileSizeThrottle >= EVENTID_READFAILEDFILESIZE_THROTTLE) {
        // The counter has overflowed, check if time interval has passed
        if (Fw::TimeInterval(this->m_ReadFailedFileSizeThrottleTime, _logTime) >= Fw::TimeInterval(10, 0)) {
          // Reset the count
          this->m_ReadFailedFileSizeThrottle = 0;
        } else {
          // Throttle the event
          return;
        }
      }

      // Reset the throttle time if needed
      if (this->m_ReadFailedFileSizeThrottle == 0) {
        // This is the first event, reset the throttle time
        this->m_ReadFailedFileSizeThrottleTime = _logTime;
      }

      // Increment the count
      this->m_ReadFailedFileSizeThrottle++;
    }

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(U32))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(fsStat);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed to get filesize with stat %" PRIu32 " in read handler";
#else
      const char* _formatString =
        "%s: Failed to get filesize with stat %" PRIu32 " in read handler";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_OpenFileError(
        const Fw::StringBase& fileName,
        U32 fsStat
    )
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_OPENFILEERROR;

    // Check throttle value & throttle timeout
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      if (this->m_OpenFileErrorThrottle >= EVENTID_OPENFILEERROR_THROTTLE) {
        // The counter has overflowed, check if time interval has passed
        if (Fw::TimeInterval(this->m_OpenFileErrorThrottleTime, _logTime) >= Fw::TimeInterval(10, 0)) {
          // Reset the count
          this->m_OpenFileErrorThrottle = 0;
        } else {
          // Throttle the event
          return;
        }
      }

      // Reset the throttle time if needed
      if (this->m_OpenFileErrorThrottle == 0) {
        // This is the first event, reset the throttle time
        this->m_OpenFileErrorThrottleTime = _logTime;
      }

      // Increment the count
      this->m_OpenFileErrorThrottle++;
    }

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      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(fsStat);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed to open file %s with stat %" PRIu32 "";
#else
      const char* _formatString =
        "%s: Failed to open file %s with stat %" PRIu32 "";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_ACTIVITY_LO_ReadBegin(
        FwSizeType fileSize,
        const Fw::StringBase& fileName
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_READBEGIN;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(fileSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Reading %" PRIu64 " bytes from %s";
#else
      const char* _formatString =
        "%s: Reading %" PRIu64 " bytes from %s";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_ACTIVITY_LO_ReadCompleted(
        FwSizeType fileSize,
        const Fw::StringBase& fileName
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_READCOMPLETED;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(fileSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Finished reading %" PRIu64 " bytes from %s";
#else
      const char* _formatString =
        "%s: Finished reading %" PRIu64 " bytes from %s";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_ReadError(
        FwSizeType bytesRead,
        FwSizeType readSize,
        const Fw::StringBase& fileName
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_READERROR;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(bytesRead);
      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(readSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed after %" PRIu64 " of %" PRIu64 " bytes read to %s";
#else
      const char* _formatString =
        "%s: Failed after %" PRIu64 " of %" PRIu64 " bytes read to %s";
#endif

      Fw::TextLogString _logString;
      _logString.format(
        _formatString,
#if FW_OBJECT_NAMES == 1
        this->m_objName.toChar(),
#endif
        "ReadError ",
        bytesRead,
        readSize,
        fileName.toChar()
      );

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_LO_ReadAborted(
        FwSizeType bytesRead,
        FwSizeType readSize,
        const Fw::StringBase& fileName
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_READABORTED;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(bytesRead);
      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(readSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Aborted after %" PRIu64 " of %" PRIu64 " bytes read to %s";
#else
      const char* _formatString =
        "%s: Aborted after %" PRIu64 " of %" PRIu64 " bytes read to %s";
#endif

      Fw::TextLogString _logString;
      _logString.format(
        _formatString,
#if FW_OBJECT_NAMES == 1
        this->m_objName.toChar(),
#endif
        "ReadAborted ",
        bytesRead,
        readSize,
        fileName.toChar()
      );

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_ReadTimeout(
        FwSizeType bytesRead,
        FwSizeType readSize,
        const Fw::StringBase& fileName,
        U64 timeout
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_READTIMEOUT;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(bytesRead);
      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(readSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      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(U64))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(timeout);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed after %" PRIu64 " of %" PRIu64 " bytes read to %s after exceeding timeout of %" PRIu64 " microseconds";
#else
      const char* _formatString =
        "%s: Failed after %" PRIu64 " of %" PRIu64 " bytes read to %s after exceeding timeout of %" PRIu64 " microseconds";
#endif

      Fw::TextLogString _logString;
      _logString.format(
        _formatString,
#if FW_OBJECT_NAMES == 1
        this->m_objName.toChar(),
#endif
        "ReadTimeout ",
        bytesRead,
        readSize,
        fileName.toChar(),
        timeout
      );

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_ACTIVITY_LO_WriteBegin(
        FwSizeType writeSize,
        const Fw::StringBase& fileName
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITEBEGIN;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(writeSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Beginning write of size %" PRIu64 " to %s";
#else
      const char* _formatString =
        "%s: Beginning write of size %" PRIu64 " to %s";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_ACTIVITY_LO_WriteCompleted(
        FwSizeType writeSize,
        const Fw::StringBase& fileName
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITECOMPLETED;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(writeSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Completed write of size %" PRIu64 " to %s";
#else
      const char* _formatString =
        "%s: Completed write of size %" PRIu64 " to %s";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::ACTIVITY_LO,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_WriteFileError(
        FwSizeType bytesWritten,
        FwSizeType writeSize,
        const Fw::StringBase& fileName,
        I32 status
    )
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITEFILEERROR;

    // Check throttle value & throttle timeout
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      if (this->m_WriteFileErrorThrottle >= EVENTID_WRITEFILEERROR_THROTTLE) {
        // The counter has overflowed, check if time interval has passed
        if (Fw::TimeInterval(this->m_WriteFileErrorThrottleTime, _logTime) >= Fw::TimeInterval(10, 0)) {
          // Reset the count
          this->m_WriteFileErrorThrottle = 0;
        } else {
          // Throttle the event
          return;
        }
      }

      // Reset the throttle time if needed
      if (this->m_WriteFileErrorThrottle == 0) {
        // This is the first event, reset the throttle time
        this->m_WriteFileErrorThrottleTime = _logTime;
      }

      // Increment the count
      this->m_WriteFileErrorThrottle++;
    }

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(bytesWritten);
      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(writeSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      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(I32))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(status);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed after %" PRIu64 " of %" PRIu64 " bytes written to %s with write status %" PRIi32 "";
#else
      const char* _formatString =
        "%s: Failed after %" PRIu64 " of %" PRIu64 " bytes written to %s with write status %" PRIi32 "";
#endif

      Fw::TextLogString _logString;
      _logString.format(
        _formatString,
#if FW_OBJECT_NAMES == 1
        this->m_objName.toChar(),
#endif
        "WriteFileError ",
        bytesWritten,
        writeSize,
        fileName.toChar(),
        status
      );

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_WriteValidationOpenError(
        const Fw::StringBase& hashFileName,
        I32 status
    )
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITEVALIDATIONOPENERROR;

    // Check throttle value & throttle timeout
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      if (this->m_WriteValidationOpenErrorThrottle >= EVENTID_WRITEVALIDATIONOPENERROR_THROTTLE) {
        // The counter has overflowed, check if time interval has passed
        if (Fw::TimeInterval(this->m_WriteValidationOpenErrorThrottleTime, _logTime) >= Fw::TimeInterval(10, 0)) {
          // Reset the count
          this->m_WriteValidationOpenErrorThrottle = 0;
        } else {
          // Throttle the event
          return;
        }
      }

      // Reset the throttle time if needed
      if (this->m_WriteValidationOpenErrorThrottle == 0) {
        // This is the first event, reset the throttle time
        this->m_WriteValidationOpenErrorThrottleTime = _logTime;
      }

      // Increment the count
      this->m_WriteValidationOpenErrorThrottle++;
    }

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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

      _status = hashFileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      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(I32))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(status);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed to open validation file %s with status %" PRIi32 "";
#else
      const char* _formatString =
        "%s: Failed to open validation file %s with status %" PRIi32 "";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_WriteValidationReadError(
        const Fw::StringBase& hashFileName,
        I32 status
    )
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITEVALIDATIONREADERROR;

    // Check throttle value & throttle timeout
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      if (this->m_WriteValidationReadErrorThrottle >= EVENTID_WRITEVALIDATIONREADERROR_THROTTLE) {
        // The counter has overflowed, check if time interval has passed
        if (Fw::TimeInterval(this->m_WriteValidationReadErrorThrottleTime, _logTime) >= Fw::TimeInterval(10, 0)) {
          // Reset the count
          this->m_WriteValidationReadErrorThrottle = 0;
        } else {
          // Throttle the event
          return;
        }
      }

      // Reset the throttle time if needed
      if (this->m_WriteValidationReadErrorThrottle == 0) {
        // This is the first event, reset the throttle time
        this->m_WriteValidationReadErrorThrottleTime = _logTime;
      }

      // Increment the count
      this->m_WriteValidationReadErrorThrottle++;
    }

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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

      _status = hashFileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      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(I32))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(status);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed to read validation file %s with status %" PRIi32 "";
#else
      const char* _formatString =
        "%s: Failed to read validation file %s with status %" PRIi32 "";
#endif

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

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_LO_WriteValidationError(
        const Fw::StringBase& hashFileName,
        FwSizeType bytesWritten,
        FwSizeType hashSize
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITEVALIDATIONERROR;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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

      _status = hashFileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      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(bytesWritten);
      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(hashSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed to create hash file %s. Wrote %" PRIu64 " bytes when expected to write %" PRIu64 " bytes to hash file";
#else
      const char* _formatString =
        "%s: Failed to create hash file %s. Wrote %" PRIu64 " bytes when expected to write %" PRIu64 " bytes to hash file";
#endif

      Fw::TextLogString _logString;
      _logString.format(
        _formatString,
#if FW_OBJECT_NAMES == 1
        this->m_objName.toChar(),
#endif
        "WriteValidationError ",
        hashFileName.toChar(),
        bytesWritten,
        hashSize
      );

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_WriteTimeout(
        FwSizeType bytesWritten,
        FwSizeType writeSize,
        const Fw::StringBase& fileName,
        U64 timeout
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITETIMEOUT;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(bytesWritten);
      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(writeSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      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(U64))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(timeout);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Failed after %" PRIu64 " of %" PRIu64 " bytes written to %s after exceeding timeout of %" PRIu64 " microseconds";
#else
      const char* _formatString =
        "%s: Failed after %" PRIu64 " of %" PRIu64 " bytes written to %s after exceeding timeout of %" PRIu64 " microseconds";
#endif

      Fw::TextLogString _logString;
      _logString.format(
        _formatString,
#if FW_OBJECT_NAMES == 1
        this->m_objName.toChar(),
#endif
        "WriteTimeout ",
        bytesWritten,
        writeSize,
        fileName.toChar(),
        timeout
      );

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_HI,
        _logString
      );
    }
#endif
  }

  void FileWorkerComponentBase ::
    log_WARNING_LO_WriteAborted(
        FwSizeType bytesWritten,
        FwSizeType writeSize,
        const Fw::StringBase& fileName
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      this->m_timeCaller_OutputPort[0].invoke(_logTime);
    }

    FwEventIdType _id = static_cast<FwEventIdType>(0);

    _id = this->getIdBase() + EVENTID_WRITEABORTED;

    // Emit the event on the log port
    if (this->m_logOut_OutputPort[0].isConnected()) {
      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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(bytesWritten);
      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(writeSize);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      _status = fileName.serializeTo(_logBuff, FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200));
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

      this->m_logOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logBuff
      );
    }

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Aborted after %" PRIu64 " of %" PRIu64 " bytes written to %s";
#else
      const char* _formatString =
        "%s: Aborted after %" PRIu64 " of %" PRIu64 " bytes written to %s";
#endif

      Fw::TextLogString _logString;
      _logString.format(
        _formatString,
#if FW_OBJECT_NAMES == 1
        this->m_objName.toChar(),
#endif
        "WriteAborted ",
        bytesWritten,
        writeSize,
        fileName.toChar()
      );

      this->m_logTextOut_OutputPort[0].invoke(
        _id,
        _logTime,
        Fw::LogSeverity::WARNING_LO,
        _logString
      );
    }
#endif
  }

  // ----------------------------------------------------------------------
  // Event throttle reset functions
  // ----------------------------------------------------------------------

  void FileWorkerComponentBase ::
    log_WARNING_HI_NotInIdle_ThrottleClear()
  {
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      // Reset throttle counter
      this->m_NotInIdleThrottle = 0;

      // Reset the throttle time
      this->m_NotInIdleThrottleTime = Fw::Time(0, 0);
    }
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_CrcFailed_ThrottleClear()
  {
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      // Reset throttle counter
      this->m_CrcFailedThrottle = 0;

      // Reset the throttle time
      this->m_CrcFailedThrottleTime = Fw::Time(0, 0);
    }
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_ReadFailedFileSize_ThrottleClear()
  {
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      // Reset throttle counter
      this->m_ReadFailedFileSizeThrottle = 0;

      // Reset the throttle time
      this->m_ReadFailedFileSizeThrottleTime = Fw::Time(0, 0);
    }
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_OpenFileError_ThrottleClear()
  {
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      // Reset throttle counter
      this->m_OpenFileErrorThrottle = 0;

      // Reset the throttle time
      this->m_OpenFileErrorThrottleTime = Fw::Time(0, 0);
    }
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_WriteFileError_ThrottleClear()
  {
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      // Reset throttle counter
      this->m_WriteFileErrorThrottle = 0;

      // Reset the throttle time
      this->m_WriteFileErrorThrottleTime = Fw::Time(0, 0);
    }
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_WriteValidationOpenError_ThrottleClear()
  {
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      // Reset throttle counter
      this->m_WriteValidationOpenErrorThrottle = 0;

      // Reset the throttle time
      this->m_WriteValidationOpenErrorThrottleTime = Fw::Time(0, 0);
    }
  }

  void FileWorkerComponentBase ::
    log_WARNING_HI_WriteValidationReadError_ThrottleClear()
  {
    {
      Os::ScopeLock scopedLock(this->m_eventLock);

      // Reset throttle counter
      this->m_WriteValidationReadErrorThrottle = 0;

      // Reset the throttle time
      this->m_WriteValidationReadErrorThrottleTime = Fw::Time(0, 0);
    }
  }

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

  Fw::Time FileWorkerComponentBase ::
    getTime() const
  {
    if (this->m_timeCaller_OutputPort[0].isConnected()) {
      Fw::Time _time;
      this->m_timeCaller_OutputPort[0].invoke(_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 FileWorkerComponentBase ::
    lock()
  {
    this->m_guardedPortMutex.lock();
  }

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

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

  Fw::QueuedComponentBase::MsgDispatchStatus FileWorkerComponentBase ::
    doDispatch()
  {
    ComponentIpcSerializableBuffer _msg;
    FwQueuePriorityType _priority = 0;

    Os::Queue::Status _msgStatus = this->m_queue.receive(
      _msg,
      Os::Queue::BLOCKING,
      _priority
    );
    FW_ASSERT(
      _msgStatus == Os::Queue::OP_OK,
      static_cast<FwAssertArgType>(_msgStatus)
    );

    // Reset to beginning of buffer
    _msg.resetDeser();

    FwEnumStoreType _desMsg = 0;
    Fw::SerializeStatus _deserStatus = _msg.deserializeTo(_desMsg);
    FW_ASSERT(
      _deserStatus == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_deserStatus)
    );

    MsgTypeEnum _msgType = static_cast<MsgTypeEnum>(_desMsg);

    if (_msgType == FILEWORKER_COMPONENT_EXIT) {
      return MSG_DISPATCH_EXIT;
    }

    FwIndexType portNum = 0;
    _deserStatus = _msg.deserializeTo(portNum);
    FW_ASSERT(
      _deserStatus == Fw::FW_SERIALIZE_OK,
      static_cast<FwAssertArgType>(_deserStatus)
    );

    switch (_msgType) {
      // Handle async input port readIn
      case READIN_FILEREAD: {
        // Deserialize argument path
        char __fprime_ac_path_buffer[Fw::StringBase::BUFFER_SIZE(200)];
        Fw::ExternalString path(__fprime_ac_path_buffer, sizeof __fprime_ac_path_buffer);
        _deserStatus = _msg.deserializeTo(path);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );

        // Deserialize argument buffer
        Fw::Buffer buffer;
        _deserStatus = _msg.deserializeTo(buffer);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );
        // Call handler function
        this->readIn_handler(
          portNum,
          path,
          buffer
        );

        break;
      }

      // Handle async input port verifyIn
      case VERIFYIN_VERIFYSTATUS: {
        // Deserialize argument path
        char __fprime_ac_path_buffer[Fw::StringBase::BUFFER_SIZE(200)];
        Fw::ExternalString path(__fprime_ac_path_buffer, sizeof __fprime_ac_path_buffer);
        _deserStatus = _msg.deserializeTo(path);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );

        // Deserialize argument crc
        U32 crc;
        _deserStatus = _msg.deserializeTo(crc);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );
        // Call handler function
        this->verifyIn_handler(
          portNum,
          path,
          crc
        );

        break;
      }

      // Handle async input port writeIn
      case WRITEIN_FILEWRITE: {
        // Deserialize argument path
        char __fprime_ac_path_buffer[Fw::StringBase::BUFFER_SIZE(200)];
        Fw::ExternalString path(__fprime_ac_path_buffer, sizeof __fprime_ac_path_buffer);
        _deserStatus = _msg.deserializeTo(path);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );

        // Deserialize argument buffer
        Fw::Buffer buffer;
        _deserStatus = _msg.deserializeTo(buffer);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );

        // Deserialize argument offsetBytes
        FwSizeType offsetBytes;
        _deserStatus = _msg.deserializeTo(offsetBytes);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );

        // Deserialize argument append
        bool append;
        _deserStatus = _msg.deserializeTo(append);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );
        // Call handler function
        this->writeIn_handler(
          portNum,
          path,
          buffer,
          offsetBytes,
          append
        );

        break;
      }

      default:
        return MSG_DISPATCH_ERROR;
    }

    return MSG_DISPATCH_OK;
  }

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

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

    const U32 idBase = callComp->getIdBase();
    FW_ASSERT(opCode >= idBase, static_cast<FwAssertArgType>(opCode), static_cast<FwAssertArgType>(idBase));
  }

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

  void FileWorkerComponentBase ::
    m_p_cancelIn_in(
        Fw::PassiveComponentBase* callComp,
        FwIndexType portNum
    )
  {
    FW_ASSERT(callComp);
    FileWorkerComponentBase* compPtr = static_cast<FileWorkerComponentBase*>(callComp);
    compPtr->cancelIn_handlerBase(portNum);
  }

  void FileWorkerComponentBase ::
    m_p_readIn_in(
        Fw::PassiveComponentBase* callComp,
        FwIndexType portNum,
        const Fw::StringBase& path,
        Fw::Buffer& buffer
    )
  {
    FW_ASSERT(callComp);
    FileWorkerComponentBase* compPtr = static_cast<FileWorkerComponentBase*>(callComp);
    compPtr->readIn_handlerBase(
      portNum,
      path,
      buffer
    );
  }

  void FileWorkerComponentBase ::
    m_p_verifyIn_in(
        Fw::PassiveComponentBase* callComp,
        FwIndexType portNum,
        const Fw::StringBase& path,
        U32 crc
    )
  {
    FW_ASSERT(callComp);
    FileWorkerComponentBase* compPtr = static_cast<FileWorkerComponentBase*>(callComp);
    compPtr->verifyIn_handlerBase(
      portNum,
      path,
      crc
    );
  }

  void FileWorkerComponentBase ::
    m_p_writeIn_in(
        Fw::PassiveComponentBase* callComp,
        FwIndexType portNum,
        const Fw::StringBase& path,
        Fw::Buffer& buffer,
        FwSizeType offsetBytes,
        bool append
    )
  {
    FW_ASSERT(callComp);
    FileWorkerComponentBase* compPtr = static_cast<FileWorkerComponentBase*>(callComp);
    compPtr->writeIn_handlerBase(
      portNum,
      path,
      buffer,
      offsetBytes,
      append
    );
  }

}