CmdSequencerImpl.hpp

Go to the documentation of this file.

// ====================================================================== 
// \title  CmdSequencerImpl.hpp
// \author Bocchino/Canham
// \brief  hpp file for CmdSequencer component implementation class
//
// \copyright
// 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:
 
              struct FileReadStage {
 
                typedef enum {
                  READ_HEADER,
                  READ_HEADER_SIZE,
                  DESER_SIZE,
                  DESER_NUM_RECORDS,
                  DESER_TIME_BASE,
                  DESER_TIME_CONTEXT,
                  READ_SEQ_CRC,
                  READ_SEQ_DATA,
                  READ_SEQ_DATA_SIZE,
                } t;
 
                static CmdSequencerComponentImpl::FileReadStage 
                  toComponentEnum(
                      const t fileReadStage 
                  );
 
              }; 
 
            public:
 
              Events(
                  Sequence& sequence 
              );
 
            public:
 
              void fileCRCFailure(
                  const U32 storedCRC, 
                  const U32 computedCRC 
              );
 
              void fileInvalid(
                  const FileReadStage::t stage, 
                  const I32 error 
              );
 
              void fileNotFound(void);
 
              void fileReadError(void);
 
              void fileSizeError(
                  const U32 size 
              );
 
              void recordInvalid(
                  const U32 recordNumber, 
                  const I32 error 
              );
 
              void recordMismatch(
                  const U32 numRecords, 
                  const U32 extraBytes 
              );
 
              void timeBaseMismatch(
                  const FwTimeBaseStoreType currTimeBase, 
                  const FwTimeBaseStoreType seqTimeBase 
              );
 
              void timeContextMismatch(
                  const FwTimeContextStoreType currTimeContext, 
                  const FwTimeContextStoreType seqTimeContext 
              );
 
            PRIVATE:
 
              Sequence& m_sequence;
 
          };
 
        public:
 
          Sequence(
              CmdSequencerComponentImpl& component 
          );
 
          virtual ~Sequence(void);
 
        public:
 
          class Header {
 
            public:
 
              enum Constants {
                SERIALIZED_SIZE =
                  sizeof(U32) +
                  sizeof(U32) +
                  sizeof(FwTimeBaseStoreType) +
                  sizeof(FwTimeContextStoreType)
              };
 
            public:
 
              Header(void);
 
            public:
 
              bool validateTime(
                  CmdSequencerComponentImpl& component 
              );
 
            public:
 
              U32 m_fileSize;
 
              U32 m_numRecords;
 
              TimeBase m_timeBase;
 
              FwTimeContextStoreType m_timeContext;
 
          };
 
        public:
 
          class Record {
 
            public:
 
              enum Descriptor {
                ABSOLUTE, 
                RELATIVE, 
                END_OF_SEQUENCE 
              };
 
            public:
 
              Record(void) :
                m_descriptor(END_OF_SEQUENCE) 
              {
 
              }
 
            public:
 
              Descriptor m_descriptor;
 
              Fw::Time m_timeTag;
 
              Fw::ComBuffer m_command;
 
          };
 
        public:
 
          void allocateBuffer(
              const NATIVE_INT_TYPE identifier, 
              Fw::MemAllocator& allocator, 
              const NATIVE_UINT_TYPE bytes 
          );
 
          void deallocateBuffer(
              Fw::MemAllocator& allocator 
          );
 
          void setFileName(const Fw::CmdStringArg& fileName);
 
          Fw::CmdStringArg& getFileName(void);
 
          Fw::LogStringArg& getLogFileName(void);
 
          const Header& getHeader(void) const;
 
          virtual bool loadFile(
              const Fw::CmdStringArg& fileName 
          ) = 0;
 
          virtual bool hasMoreRecords(void) const = 0;
 
          virtual void nextRecord(
              Record& record 
          ) = 0;
 
          virtual void reset(void) = 0;
 
          virtual void clear(void) = 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 FPrimeSequence :
        public Sequence
      {
 
        PRIVATE:
 
          enum Constants {
            INITIAL_COMPUTED_VALUE = 0xFFFFFFFFU
          };
 
        public:
 
          struct CRC {
 
            CRC(void);
 
            void init(void);
 
            void update(
                const BYTE* buffer, 
                NATIVE_UINT_TYPE bufferSize 
            );
 
            void finalize(void);
 
            U32 m_computed;
 
            U32 m_stored;
 
          };
 
        public:
 
          FPrimeSequence(
              CmdSequencerComponentImpl& component 
          );
 
        public:
 
          bool loadFile(
              const Fw::CmdStringArg& fileName 
          );
 
          bool hasMoreRecords(void) const;
 
          void nextRecord(
              Record& record 
          );
 
          void reset(void);
 
          void clear(void);
 
        PRIVATE:
 
          bool readFile(void);
 
          bool readOpenFile(void);
 
          bool readHeader(void);
 
          bool deserializeHeader(void);
 
          bool readRecordsAndCRC(void);
 
          bool extractCRC(void);
 
          bool validateCRC(void);
 
          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(void);
 
        PRIVATE:
 
          CRC m_crc;
 
          Os::File m_sequenceFile;
 
      };
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Private classes 
      // ----------------------------------------------------------------------
 
      class Timer {
 
        PRIVATE:
 
          typedef enum {
            SET, CLEAR
          } State;
 
        public:
 
          Timer(void) :
            m_state(CLEAR) 
          {
 
          }
 
          void set(
              Fw::Time time 
          ) {
            this->m_state = SET;
            this->expirationTime = time;
          }
 
          void clear(void) {
            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(
          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::EightyCharString& fileName 
      );
 
      void deallocateBuffer(
          Fw::MemAllocator& allocator 
      );
 
      ~CmdSequencerComponentImpl(void);
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Handler implementations for input ports
      // ----------------------------------------------------------------------
 
      void cmdResponseIn_handler(
          NATIVE_INT_TYPE portNum, 
          FwOpcodeType opcode, 
          U32 cmdSeq, 
          Fw::CommandResponse response 
      );
 
      void schedIn_handler(
          NATIVE_INT_TYPE portNum, 
          NATIVE_UINT_TYPE order 
      );
 
      void seqRunIn_handler(
          NATIVE_INT_TYPE portNum, 
          Fw::EightyCharString &filename 
      );
 
      void pingIn_handler(
          NATIVE_INT_TYPE portNum, 
          U32 key 
      );
 
    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 
      );
 
      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 
      );
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Private helper methods
      // ----------------------------------------------------------------------
 
      bool loadFile(
          const Fw::CmdStringArg& fileName 
      );
 
      void performCmd_Cancel(void);
 
      void performCmd_Step(void);
 
      void performCmd_Step_RELATIVE(
          Fw::Time& currentTime 
      );
 
      void performCmd_Step_ABSOLUTE(
          Fw::Time& currentTime 
      );
 
      void commandComplete(
          const U32 opCode 
      );
 
      void sequenceComplete(void);
 
      void error(void);
 
      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;
 
  };
 
};
 
#endif