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 :
    public FileUplinkComponentBase
  {
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Types
      // ----------------------------------------------------------------------
 
      typedef enum { START, DATA } ReceiveMode;
 
      class File {
 
        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 {
 
        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 {
 
        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 {
 
        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 NATIVE_INT_TYPE portNum, 
          Fw::Buffer& buffer 
      );
 
      void pingIn_handler(
          const NATIVE_INT_TYPE 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