FpySequencer.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FpySequencer.hpp
// \author zimri.leisher
// \brief  hpp file for FpySequencer component implementation class
// ======================================================================

#ifndef FpySequencer_HPP
#define FpySequencer_HPP

#include "FppConstantsAc.hpp"
#include "Fw/Types/MemAllocator.hpp"
#include "Fw/Types/StringBase.hpp"
#include "Fw/Types/WaitEnumAc.hpp"
#include "Fw/Types/SuccessEnumAc.hpp"
#include "Os/File.hpp"
#include "Svc/FpySequencer/DirectiveIdEnumAc.hpp"
#include "Svc/FpySequencer/FooterSerializableAc.hpp"
#include "Svc/FpySequencer/FpySequencerComponentAc.hpp"
#include "Svc/FpySequencer/FpySequencer_GoalStateEnumAc.hpp"
#include "Svc/FpySequencer/HeaderSerializableAc.hpp"
#include "Svc/FpySequencer/SequenceSerializableAc.hpp"
#include "Svc/FpySequencer/StatementSerializableAc.hpp"

static_assert(Svc::Fpy::MAX_SEQUENCE_ARG_COUNT <= std::numeric_limits<U8>::max(), "Sequence arg count must be below U8 max");
static_assert(Svc::Fpy::MAX_SEQUENCE_STATEMENT_COUNT <= std::numeric_limits<U16>::max(), "Sequence statement count must be below U16 max");

namespace Svc {

using Signal = FpySequencer_SequencerStateMachineStateMachineBase::Signal;
using State = FpySequencer_SequencerStateMachineStateMachineBase::State;

class FpySequencer : public FpySequencerComponentBase {
  public:
    // ----------------------------------------------------------------------
    // Construction, initialization, and destruction
    // ----------------------------------------------------------------------

    FpySequencer(const char* const compName 
    );

    ~FpySequencer();

    PRIVATE :

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

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

    void RUN_VALIDATED_cmdHandler(FwOpcodeType opCode,           
                                  U32 cmdSeq,                    
                                  FpySequencer_BlockState block  
                                  ) override;

    void CANCEL_cmdHandler(FwOpcodeType opCode,  
                           U32 cmdSeq            
                           ) override;

    // ----------------------------------------------------------------------
    // Functions to implement for internal state machine actions
    // ----------------------------------------------------------------------

    void Svc_FpySequencer_SequencerStateMachine_action_signalEntered(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setSequenceFilePath(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_SequenceExecutionArgs& value    
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setSequenceBlockState(
        SmId smId,                                              
        Svc_FpySequencer_SequencerStateMachine::Signal signal,  
        const Svc::FpySequencer_SequenceExecutionArgs& value    
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_validate(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqSucceeded(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_report_seqCancelled(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_RUNNING(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_VALID(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_setGoalState_IDLE(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_OK(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_EXECUTION_ERROR(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_dispatchStatement(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_clearSequenceFile(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_checkShouldWake(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_resetRuntime(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_checkStatementTimeout(
        SmId smId,                                             
        Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) override;

    void Svc_FpySequencer_SequencerStateMachine_action_incrementSequenceCounter(
        SmId smId, 
        Svc_FpySequencer_SequencerStateMachine::Signal signal 
        ) override;

    PROTECTED :

        // ----------------------------------------------------------------------
        // Functions to implement for internal state machine guards
        // ----------------------------------------------------------------------

        bool
        Svc_FpySequencer_SequencerStateMachine_guard_goalStateIs_RUNNING(
            SmId smId,                                             
            Svc_FpySequencer_SequencerStateMachine::Signal signal  
        ) const override;

    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------

    void checkTimers_handler(FwIndexType portNum,  
                             U32 context           
                             ) override;

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

    void pingIn_handler(FwIndexType portNum,  
                        U32 key               
                        ) override;

    void tlmWrite_handler(FwIndexType portNum,  
                          U32 context           
                          ) override;

    void directive_waitAbs_internalInterfaceHandler(const FpySequencer_WaitAbsDirective& directive) override;

    void directive_waitRel_internalInterfaceHandler(const FpySequencer_WaitRelDirective& directive) override;

    void parametersLoaded() override;
    void parameterUpdated(FwPrmIdType id) override;

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

    void deallocateBuffer(Fw::MemAllocator& allocator);
    PRIVATE :

        static constexpr U32 CRC_INITIAL_VALUE = 0xFFFFFFFFU;

    // allocated at startup
    Fw::ExternalSerializeBuffer m_sequenceBuffer;
    // id of allocator that gave us m_sequenceBuffer
    FwEnumStoreType m_allocatorId;

    // assigned by the user via cmd
    Fw::String m_sequenceFilePath;
    // the sequence, loaded in memory
    Fpy::Sequence m_sequenceObj;
    // live running computation of CRC (updated as we read)
    U32 m_computedCRC;

    // whether or not the sequence we're about to run should return immediately or
    // block on completion
    FpySequencer_BlockState m_sequenceBlockState;
    // if we are to block on completion, save the opCode and cmdSeq we should
    // return
    FwOpcodeType m_savedOpCode;
    U32 m_savedCmdSeq;

    // the goal state is the state that we're trying to reach in the sequencer
    // if it's RUNNING, then we should promptly go to RUNNING once we validate the
    // sequence. if it's VALID, we should wait after VALIDATING
    FpySequencer_GoalState m_goalState;

    // the total number of sequences this sequencer has started since construction
    U64 m_sequencesStarted;
    // the total number of statements this sequencer has dispatched, successfully or
    // otherwise, since construction
    U64 m_statementsDispatched;

    // the runtime state of the sequence. encapsulates all state
    // needed to run the sequence.
    // this is distinct from the state of the sequencer. the
    // sequencer and all its state is really just a shell to load
    // and execute this runtime.
    struct Runtime {
        // the index of the next statement to be executed
        U32 nextStatementIndex = 0;

        // the opcode of the statement that is currently executing
        FwOpcodeType currentStatementOpcode = Fpy::DirectiveId::INVALID;
        // the stmt type of the stmt currently executing (cmd or directive)
        Fpy::StatementType currentStatementType = Fpy::StatementType::DIRECTIVE;
        // the time we dispatched the statement that is currently executing
        Fw::Time currentStatementDispatchTime = Fw::Time();

        // the absolute time we should wait for until returning
        // a statement response
        Fw::Time wakeupTime = Fw::Time();
    } m_runtime;

    struct Telemetry {
        // the number of statements that failed to execute
        U64 statementsFailed = 0;

        // the number of sequences successfully completed
        U64 sequencesSucceeded = 0;

        // the number of sequences that failed to validate or execute
        U64 sequencesFailed = 0;

        // the number of sequences that have been cancelled
        U64 sequencesCancelled = 0;
    } m_tlm;

    // ----------------------------------------------------------------------
    // Validation state
    // ----------------------------------------------------------------------

    void updateComputedCRC(const U8* buffer,      
                           FwSizeType bufferSize  
    );

    // loads the sequence in memory, and does header/crc/integrity checks.
    // return success if sequence is valid
    Fw::Success validate();

    // reads some bytes from the open file into the m_sequenceBuffer.
    // updates the CRC by default, but can be turned off if the contents
    // aren't included in CRC.
    // return success if successful
    Fw::Success readBytes(Os::File& file, FwSizeType readLen, bool updateCRC = true);

    // ----------------------------------------------------------------------
    // Run state
    // ----------------------------------------------------------------------

    // dispatches the next statement
    Signal dispatchStatement();

    // dispatches a command out via port.
    // return success if successfully dispatched.
    Fw::Success dispatchCommand(const Fpy::Statement& stmt);

    // dispatches a sequencer directive to the right handler.
    // return success if successfully handled.
    Fw::Success dispatchDirective(const Fpy::Statement& stmt);

    // checks whether the currently executing statement timed out
    Signal checkStatementTimeout();
    // checks whether the sequencer should wake from sleeping
    Signal checkShouldWake();

    // ----------------------------------------------------------------------
    // Directives
    // ----------------------------------------------------------------------

    // sends a signal based on a signal id
    void sendSignal(Signal signal);

    // we split these functions up into the internalInterfaceInvoke and these custom member funcs
    // so that we can unit test them easier
    Signal waitRel_directiveHandler(const FpySequencer_WaitRelDirective& directive);
    Signal waitAbs_directiveHandler(const FpySequencer_WaitAbsDirective& directive);
};

}  // namespace Svc

#endif