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 final :
    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 
              );

              // No Records 
              void noRecords();

            PRIVATE:

              Sequence& m_sequence;

          };

        public:

          Sequence(
              CmdSequencerComponentImpl& component 
          );

          virtual ~Sequence();

        public:

          class Header {

            public:

              enum Constants {
                SERIALIZED_SIZE =
                  sizeof(U32) +
                  sizeof(U32) +
                  sizeof(FwTimeBaseStoreType) +
                  sizeof(FwTimeContextStoreType)
              };

            public:

              Header();

            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() :
                m_descriptor(END_OF_SEQUENCE)
              {

              }

            public:

              Descriptor m_descriptor;

              Fw::Time m_timeTag;

              Fw::ComBuffer m_command;

          };

        public:

          void allocateBuffer(
              FwEnumStoreType identifier, 
              Fw::MemAllocator& allocator, 
              FwSizeType bytes 
          );

          void deallocateBuffer(
              Fw::MemAllocator& allocator 
          );

          void setFileName(const Fw::StringBase& fileName);

          Fw::CmdStringArg& getFileName();

          Fw::LogStringArg& getLogFileName();

          Fw::String& getStringFileName();

          const Header& getHeader() const;

          virtual bool loadFile(
              const Fw::StringBase& 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::String m_stringFileName;

          Fw::ExternalSerializeBuffer m_buffer;

          FwEnumStoreType m_allocatorId;

          Header m_header;

      };

      class FPrimeSequence :
        public Sequence
      {

        PRIVATE:

          enum Constants {
            INITIAL_COMPUTED_VALUE = 0xFFFFFFFFU
          };

        public:

          struct CRC {

            CRC();

            void init();

            void update(
                const BYTE* buffer, 
                FwSizeType bufferSize 
            );

            void finalize();

            U32 m_computed;

            U32 m_stored;

          };

        public:

          FPrimeSequence(
              CmdSequencerComponentImpl& component 
          );

        public:

          bool loadFile(
              const Fw::StringBase& 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;

      };

    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 setTimeout(
          const U32 seconds 
      );

      void setSequenceFormat(
          Sequence& sequence 
      );

      void allocateBuffer(
          const FwEnumStoreType identifier, 
          Fw::MemAllocator& allocator, 
          const FwSizeType bytes 
      );

      void loadSequence(
          const Fw::StringBase& fileName 
      );

      void deallocateBuffer(
          Fw::MemAllocator& allocator 
      );

      ~CmdSequencerComponentImpl();

    PRIVATE:

      // ----------------------------------------------------------------------
      // Handler implementations for input ports
      // ----------------------------------------------------------------------

      void cmdResponseIn_handler(
          FwIndexType portNum, 
          FwOpcodeType opcode, 
          U32 cmdSeq, 
          const Fw::CmdResponse& response 
      );

      void schedIn_handler(
          FwIndexType portNum, 
          U32 order 
      );

      void seqRunIn_handler(
          FwIndexType portNum, 
          const Fw::StringBase& filename 
      );

      void pingIn_handler(
          FwIndexType portNum, 
          U32 key 
      );

      void seqCancelIn_handler(
          const FwIndexType 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::StringBase& 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;

      U32 m_timeout;

      Timer m_cmdTimeoutTimer;

      Svc::CmdSequencer_BlockState::t m_blockState;
      FwOpcodeType m_opCode;
      U32 m_cmdSeq;
      bool m_join_waiting;
  };

}

#endif