CmdSequencerImpl.hpp

Go to the documentation of this file.

// ======================================================================
// \title  CmdSequencerImpl.hpp
// \author Bocchino/Canham
// \brief  hpp file for CmdSequencer component implementation class
//
// Copyright (C) 2009-2018 California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
// ======================================================================
 
#ifndef Svc_CmdSequencerImpl_HPP
#define Svc_CmdSequencerImpl_HPP
 
#include "Fw/Com/ComBuffer.hpp"
#include "Fw/Types/MemAllocator.hpp"
#include "Os/File.hpp"
#include "Os/ValidateFile.hpp"
#include "Svc/CmdSequencer/CmdSequencerComponentAc.hpp"
 
namespace Svc {
 
  class CmdSequencerComponentImpl :
    public CmdSequencerComponentBase
  {
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Private enumerations
      // ----------------------------------------------------------------------
 
      enum RunMode {
        STOPPED, RUNNING
      };
 
      enum StepMode {
        AUTO, MANUAL
      };
 
    public:
 
      // ----------------------------------------------------------------------
      // Public classes
      // ----------------------------------------------------------------------
 
      class Sequence {
 
        public:
 
          class Events {
 
            public:
 
              Events(
                  Sequence& sequence 
              );
 
            public:
 
              void fileCRCFailure(
                  const U32 storedCRC, 
                  const U32 computedCRC 
              );
 
              void fileInvalid(
                  const CmdSequencer_FileReadStage::t stage, 
                  const I32 error 
              );
 
              void fileNotFound();
 
              void fileReadError();
 
              void fileSizeError(
                  const U32 size 
              );
 
              void recordInvalid(
                  const U32 recordNumber, 
                  const I32 error 
              );
 
              void recordMismatch(
                  const U32 numRecords, 
                  const U32 extraBytes 
              );
 
              void timeBaseMismatch(
                  const TimeBase currTimeBase, 
                  const TimeBase seqTimeBase 
              );
 
              void timeContextMismatch(
                  const FwTimeContextStoreType currTimeContext, 
                  const FwTimeContextStoreType seqTimeContext 
              );
 
            PRIVATE:
 
              Sequence& m_sequence;
 
          };
          class Events {…};
 
        public:
 
          Sequence(
              CmdSequencerComponentImpl& component 
          );
 
          virtual ~Sequence();
 
        public:
 
          class Header {
 
            public:
 
              enum Constants {
                SERIALIZED_SIZE =
                  sizeof(U32) +
                  sizeof(U32) +
                  sizeof(FwTimeBaseStoreType) +
                  sizeof(FwTimeContextStoreType)
              };
              enum Constants {…};
 
            public:
 
              Header();
 
            public:
 
              bool validateTime(
                  CmdSequencerComponentImpl& component 
              );
 
            public:
 
              U32 m_fileSize;
 
              U32 m_numRecords;
 
              TimeBase m_timeBase;
 
              FwTimeContextStoreType m_timeContext;
 
          };
          class Header {…};
 
        public:
 
          class Record {
 
            public:
 
              enum Descriptor {
                ABSOLUTE, 
                RELATIVE, 
                END_OF_SEQUENCE 
              };
              enum Descriptor {…};
 
            public:
 
              Record() :
                m_descriptor(END_OF_SEQUENCE)
              {
 
              }
              Record() : {…}
 
            public:
 
              Descriptor m_descriptor;
 
              Fw::Time m_timeTag;
 
              Fw::ComBuffer m_command;
 
          };
          class Record {…};
 
        public:
 
          void allocateBuffer(
              NATIVE_INT_TYPE identifier, 
              Fw::MemAllocator& allocator, 
              NATIVE_UINT_TYPE bytes 
          );
 
          void deallocateBuffer(
              Fw::MemAllocator& allocator 
          );
 
          void setFileName(const Fw::CmdStringArg& fileName);
 
          Fw::CmdStringArg& getFileName();
 
          Fw::LogStringArg& getLogFileName();
 
          const Header& getHeader() const;
 
          virtual bool loadFile(
              const Fw::CmdStringArg& fileName 
          ) = 0;
 
          virtual bool hasMoreRecords() const = 0;
 
          virtual void nextRecord(
              Record& record 
          ) = 0;
 
          virtual void reset() = 0;
 
          virtual void clear() = 0;
 
        PROTECTED:
 
          CmdSequencerComponentImpl& m_component;
 
          Events m_events;
 
          Fw::CmdStringArg m_fileName;
 
          Fw::LogStringArg m_logFileName;
 
          Fw::ExternalSerializeBuffer m_buffer;
 
          NATIVE_INT_TYPE m_allocatorId;
 
          Header m_header;
 
      };
      class Sequence {…};
 
      class FPrimeSequence :
        public Sequence
      {
 
        PRIVATE:
 
          enum Constants {
            INITIAL_COMPUTED_VALUE = 0xFFFFFFFFU
          };
 
        public:
 
          struct CRC {
 
            CRC();
 
            void init();
 
            void update(
                const BYTE* buffer, 
                NATIVE_UINT_TYPE bufferSize 
            );
 
            void finalize();
 
            U32 m_computed;
 
            U32 m_stored;
 
          };
          struct CRC {…};
 
        public:
 
          FPrimeSequence(
              CmdSequencerComponentImpl& component 
          );
 
        public:
 
          bool loadFile(
              const Fw::CmdStringArg& fileName 
          );
 
          bool hasMoreRecords() const;
 
          void nextRecord(
              Record& record 
          );
 
          void reset();
 
          void clear();
 
        PRIVATE:
 
          bool readFile();
 
          bool readOpenFile();
 
          bool readHeader();
 
          bool deserializeHeader();
 
          bool readRecordsAndCRC();
 
          bool extractCRC();
 
          bool validateCRC();
 
          Fw::SerializeStatus deserializeRecord(
              Record& record 
          );
 
          Fw::SerializeStatus deserializeDescriptor(
              Record::Descriptor& descriptor 
          );
 
          Fw::SerializeStatus deserializeTimeTag(
              Fw::Time& timeTag 
          );
 
          Fw::SerializeStatus deserializeRecordSize(
              U32& recordSize 
          );
 
          Fw::SerializeStatus copyCommand(
              Fw::ComBuffer& comBuffer, 
              const U32 recordSize 
          );
 
          bool validateRecords();
 
        PRIVATE:
 
          CRC m_crc;
 
          Os::File m_sequenceFile;
 
      };
      class FPrimeSequence : {…};
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Private classes
      // ----------------------------------------------------------------------
 
      class Timer {
 
        PRIVATE:
 
          typedef enum {
            SET, CLEAR
          } State;
 
        public:
 
          Timer() :
            m_state(CLEAR)
          {
 
          }
 
          void set(
              Fw::Time time 
          ) {
            this->m_state = SET;
            this->expirationTime = time;
          }
 
          void clear() {
            this->m_state = CLEAR;
          }
 
          bool isExpiredAt(
              Fw::Time time 
          ) {
            if (this->m_state == CLEAR) {
              return false;
            } else if (
                Fw::Time::compare(this->expirationTime, time) == Fw::Time::GT
            ) {
              return false;
            }
            return true;
          }
 
        PRIVATE:
 
          State m_state;
 
          Fw::Time expirationTime;
 
      };
 
 
    public:
 
      // ----------------------------------------------------------------------
      // Construction, initialization, and destruction
      // ----------------------------------------------------------------------
 
      CmdSequencerComponentImpl(
          const char* compName 
      );
 
      void init(
          const NATIVE_INT_TYPE queueDepth, 
          const NATIVE_INT_TYPE instance 
      );
 
      void setTimeout(
          const NATIVE_UINT_TYPE seconds 
      );
 
      void setSequenceFormat(
          Sequence& sequence 
      );
 
      void allocateBuffer(
          const NATIVE_INT_TYPE identifier, 
          Fw::MemAllocator& allocator, 
          const NATIVE_UINT_TYPE bytes 
      );
 
      void loadSequence(
          const Fw::String& fileName 
      );
 
      void deallocateBuffer(
          Fw::MemAllocator& allocator 
      );
 
      ~CmdSequencerComponentImpl();
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Handler implementations for input ports
      // ----------------------------------------------------------------------
 
      void cmdResponseIn_handler(
          NATIVE_INT_TYPE portNum, 
          FwOpcodeType opcode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      );
 
      void schedIn_handler(
          NATIVE_INT_TYPE portNum, 
          NATIVE_UINT_TYPE order 
      );
 
      void seqRunIn_handler(
          NATIVE_INT_TYPE portNum, 
          Fw::String &filename 
      );
 
      void pingIn_handler(
          NATIVE_INT_TYPE portNum, 
          U32 key 
      );
 
      void seqCancelIn_handler(
          const NATIVE_INT_TYPE portNum 
      );
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Command handler implementations
      // ----------------------------------------------------------------------
 
      void CS_AUTO_cmdHandler(
          FwOpcodeType opcode, 
          U32 cmdSeq 
      );
 
      void CS_CANCEL_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq 
      );
 
      void CS_MANUAL_cmdHandler(
          FwOpcodeType opcode, 
          U32 cmdSeq 
      );
 
      void CS_RUN_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName, 
          Svc::CmdSequencer_BlockState block 
      );
 
      void CS_START_cmdHandler(
          FwOpcodeType opcode, 
          U32 cmdSeq 
      );
 
      void CS_STEP_cmdHandler(
          FwOpcodeType opcode, 
          U32 cmdSeq 
      );
 
      void CS_VALIDATE_cmdHandler(
          FwOpcodeType opCode, 
          U32 cmdSeq, 
          const Fw::CmdStringArg& fileName 
      );
 
      void CS_JOIN_WAIT_cmdHandler(
          const FwOpcodeType opCode, 
          const U32 cmdSeq 
      );
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Private helper methods
      // ----------------------------------------------------------------------
 
      bool loadFile(
          const Fw::CmdStringArg& fileName 
      );
 
      void performCmd_Cancel();
 
      void performCmd_Step();
 
      void performCmd_Step_RELATIVE(
          Fw::Time& currentTime 
      );
 
      void performCmd_Step_ABSOLUTE(
          Fw::Time& currentTime 
      );
 
      void commandComplete(
          const U32 opCode 
      );
 
      void sequenceComplete();
 
      void error();
 
      void commandError(
          const U32 number, 
          const U32 opCode, 
          const U32 error 
      );
 
      bool requireRunMode(
          RunMode mode 
      );
 
      void setCmdTimeout(
          const Fw::Time &currentTime 
      );
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Private member variables
      // ----------------------------------------------------------------------
 
      FPrimeSequence m_FPrimeSequence;
 
      Sequence *m_sequence;
 
      U32 m_loadCmdCount;
 
      U32 m_cancelCmdCount;
 
      U32 m_errorCount;
 
      RunMode m_runMode;
 
      StepMode m_stepMode;
 
      Sequence::Record m_record;
 
      Timer m_cmdTimer;
 
      U32 m_executedCount;
 
      U32 m_totalExecutedCount;
 
      U32 m_sequencesCompletedCount;
 
      NATIVE_UINT_TYPE m_timeout;
 
      Timer m_cmdTimeoutTimer;
 
      Svc::CmdSequencer_BlockState::t m_blockState;
      FwOpcodeType m_opCode;
      U32 m_cmdSeq;
      bool m_join_waiting;
  };
  class CmdSequencerComponentImpl : {…};
 
}
 
#endif