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 {

// Forward declaration for UTs
namespace ImmediateBase {
class CmdSequencerTester;
}
namespace Immediate {
class CmdSequencerTester;
}
namespace ImmediateEOS {
class CmdSequencerTester;
}
namespace Mixed {
class CmdSequencerTester;
}
namespace MixedRelativeBase {
class CmdSequencerTester;
}
namespace Relative {
class CmdSequencerTester;
}
namespace JoinWait {
class CmdSequencerTester;
}

class CmdSequencerComponentImpl final : public CmdSequencerComponentBase {
    friend class CmdSequencerTester;
    friend class Svc::ImmediateBase::CmdSequencerTester;
    friend class Svc::Immediate::CmdSequencerTester;
    friend class Svc::ImmediateEOS::CmdSequencerTester;
    friend class Svc::Mixed::CmdSequencerTester;
    friend class Svc::MixedRelativeBase::CmdSequencerTester;
    friend class Svc::Relative::CmdSequencerTester;
    friend class Svc::JoinWait::CmdSequencerTester;

  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::ConstStringBase& fileName);

        Fw::CmdStringArg& getFileName();

        Fw::LogStringArg& getLogFileName();

        Fw::String& getStringFileName();

        const Header& getHeader() const;

        virtual bool loadFile(const Fw::ConstStringBase& 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::ConstStringBase& 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 {
        friend class CmdSequencerTester;
        friend class Svc::ImmediateBase::CmdSequencerTester;
        friend class Svc::Immediate::CmdSequencerTester;
        friend class Svc::ImmediateEOS::CmdSequencerTester;
        friend class Svc::Mixed::CmdSequencerTester;
        friend class Svc::MixedRelativeBase::CmdSequencerTester;
        friend class Svc::Relative::CmdSequencerTester;
        friend class Svc::JoinWait::CmdSequencerTester;

      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::TimeComparison::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::ConstStringBase& 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  
                               ) override;

    void schedIn_handler(FwIndexType portNum,  
                         U32 order             
                         ) override;

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

    void seqDispatchIn_handler(FwIndexType portNum,       
                               Fw::StringBase& file_name  
                               ) override;

    void pingIn_handler(FwIndexType portNum,  
                        U32 key               
                        ) override;

    void seqCancelIn_handler(const FwIndexType portNum 
                             ) override;

  private:
    // ----------------------------------------------------------------------
    // Command handler implementations
    // ----------------------------------------------------------------------

    void CS_AUTO_cmdHandler(FwOpcodeType opcode,  
                            U32 cmdSeq            
                            ) override;

    void CS_CANCEL_cmdHandler(FwOpcodeType opCode,  
                              U32 cmdSeq            
                              ) override;

    void CS_MANUAL_cmdHandler(FwOpcodeType opcode,  
                              U32 cmdSeq            
                              ) override;

    void CS_RUN_cmdHandler(FwOpcodeType opCode,               
                           U32 cmdSeq,                        
                           const Fw::CmdStringArg& fileName,  
                           Svc::CmdSequencer_BlockState block 
                           ) override;

    void CS_START_cmdHandler(FwOpcodeType opcode,  
                             U32 cmdSeq            
                             ) override;

    void CS_STEP_cmdHandler(FwOpcodeType opcode,  
                            U32 cmdSeq            
                            ) override;

    void CS_VALIDATE_cmdHandler(FwOpcodeType opCode,              
                                U32 cmdSeq,                       
                                const Fw::CmdStringArg& fileName  
                                ) override;

    void CS_JOIN_WAIT_cmdHandler(const FwOpcodeType opCode, 
                                 const U32 cmdSeq           
                                 ) override;

  private:
    // ----------------------------------------------------------------------
    // Private helper methods
    // ----------------------------------------------------------------------

    bool loadFile(const Fw::ConstStringBase& fileName  
    );

    void performCmd_Cancel();

    void performCmd_Step();

    void performCmd_Step_RELATIVE(Fw::Time& currentTime  
    );

    void performCmd_Step_ABSOLUTE(Fw::Time& currentTime  
    );

    void commandComplete(const FwOpcodeType opCode  
    );

    void sequenceComplete();

    void error();

    void commandError(const U32 number,           
                      const FwOpcodeType opCode,  
                      const U32 error             
    );

    bool requireRunMode(RunMode mode  
    );

    void setCmdTimeout(const Fw::Time& currentTime  
    );

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

  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;
};

}  // namespace Svc

#endif