FileUplink.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FileUplink.hpp
// \author bocchino
// \brief  hpp file for FileUplink component implementation class
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================

#ifndef Svc_FileUplink_HPP
#define Svc_FileUplink_HPP

#include <Svc/FileUplink/FileUplinkComponentAc.hpp>
#include <Fw/FilePacket/FilePacket.hpp>
#include <Os/File.hpp>

namespace Svc {

  class FileUplink final :
    public FileUplinkComponentBase
  {

    friend class FileUplinkTester;

    private:

      // ----------------------------------------------------------------------
      // Types
      // ----------------------------------------------------------------------

      typedef enum { START, DATA } ReceiveMode;

      class File {

        friend class FileUplinkTester;

        public:

          U32 size;

          Fw::LogStringArg name;

          Os::File osFile;

        private:

          ::CFDP::Checksum m_checksum;

        public:

          Os::File::Status open(
              const Fw::FilePacket::StartPacket& startPacket
          );

          Os::File::Status write(
              const U8 *const data,
              const U32 byteOffset,
              const U32 length
          );

          void getChecksum(::CFDP::Checksum& checksum) {
            checksum = this->m_checksum;
          }

      };

      class FilesReceived {

        friend class FileUplinkTester;

        public:

          FilesReceived(FileUplink *const fileUplink) :
            m_received_files_counter(0),
            m_fileUplink(fileUplink)
          { }

        public:

          void fileReceived() {
            ++this->m_received_files_counter;
            this->m_fileUplink->tlmWrite_FilesReceived(m_received_files_counter);
          }

        private:

          U32 m_received_files_counter;

          FileUplink *const m_fileUplink;

      };

      class PacketsReceived {

        friend class FileUplinkTester;

        public:

          PacketsReceived(FileUplink *const fileUplink) :
            m_received_packet_count(0),
            m_fileUplink(fileUplink)
          { }

        public:

          void packetReceived() {
            ++this->m_received_packet_count;
            this->m_fileUplink->tlmWrite_PacketsReceived(m_received_packet_count);
          }

        private:

          U32 m_received_packet_count;

          FileUplink *const m_fileUplink;

      };

      class Warnings {

        friend class FileUplinkTester;

        public:

          Warnings(FileUplink *const fileUplink) :
            m_warning_count(0),
            m_fileUplink(fileUplink)
          { }

        public:

          void invalidReceiveMode(const Fw::FilePacket::Type packetType);

          void fileOpen(Fw::LogStringArg& fileName);

          void packetOutOfBounds(
              const U32 sequenceIndex,
              Fw::LogStringArg& fileName
          );

          void packetOutOfOrder(
              const U32 sequenceIndex,
              const U32 lastSequenceIndex
          );

          void packetDuplicate(
              const U32 sequenceIndex
          );

          void fileWrite(Fw::LogStringArg& fileName);

          void badChecksum(
              const U32 computed,
              const U32 read
          );

        private:

          void warning() {
            ++this->m_warning_count;
            this->m_fileUplink->tlmWrite_Warnings(m_warning_count);
          }

        private:

          U32 m_warning_count;

          FileUplink *const m_fileUplink;

      };

    public:

      // ----------------------------------------------------------------------
      // Construction, initialization, and destruction
      // ----------------------------------------------------------------------

      FileUplink(
          const char *const name 
      );

      ~FileUplink();

    private:

      // ----------------------------------------------------------------------
      // Handler implementations for user-defined typed input ports
      // ----------------------------------------------------------------------

      void bufferSendIn_handler(
          const FwIndexType portNum, 
          Fw::Buffer& buffer 
      );

      void pingIn_handler(
          const FwIndexType portNum, 
          U32 key 
      );


    private:

      // ----------------------------------------------------------------------
      // Private helper functions
      // ----------------------------------------------------------------------

      void handleStartPacket(const Fw::FilePacket::StartPacket& startPacket);

      void handleDataPacket(const Fw::FilePacket::DataPacket& dataPacket);

      void handleEndPacket(const Fw::FilePacket::EndPacket& endPacket);

      void handleCancelPacket();

      void checkSequenceIndex(const U32 sequenceIndex);

      bool checkDuplicatedPacket(const U32 sequenceIndex);

      void compareChecksums(const Fw::FilePacket::EndPacket& endPacket);

      void goToStartMode();

      void goToDataMode();

    private:

      // ----------------------------------------------------------------------
      // Member variables
      // ----------------------------------------------------------------------

      ReceiveMode m_receiveMode;

      U32 m_lastSequenceIndex;

      Os::File::Status m_lastPacketWriteStatus;

      File m_file;

      FilesReceived m_filesReceived;

      PacketsReceived m_packetsReceived;

      Warnings m_warnings;

  };

}

#endif