FpySequencerStateMachine.cpp

Go to the documentation of this file.

#include <new>
#include "Svc/FpySequencer/FpySequencer.hpp"
namespace Svc {

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

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_signalEntered(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->sequencer_sendSignal_entered();
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_setSequenceFilePath(
    SmId smId,                                              
    Svc_FpySequencer_SequencerStateMachine::Signal signal,  
    const Svc::FpySequencer_SequenceExecutionArgs& value    
) {
    this->m_sequenceFilePath = value.getfilePath();
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_setSequenceBlockState(
    SmId smId,                                              
    Svc_FpySequencer_SequencerStateMachine::Signal signal,  
    const Svc::FpySequencer_SequenceExecutionArgs& value    
) {
    this->m_sequenceBlockState = value.getblock();
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_report_seqSucceeded(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_tlm.sequencesSucceeded++;
    this->log_ACTIVITY_HI_SequenceDone(this->m_sequenceFilePath);
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_report_seqCancelled(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_tlm.sequencesCancelled++;
    this->log_ACTIVITY_HI_SequenceCancelled(this->m_sequenceFilePath);
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_dispatchStatement(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    Signal result = this->dispatchStatement();
    switch (result) {
        case Signal::result_dispatchStatement_noMoreStatements: {
            this->sequencer_sendSignal_result_dispatchStatement_noMoreStatements();
            break;
        }
        case Signal::result_dispatchStatement_success: {
            this->sequencer_sendSignal_result_dispatchStatement_success();
            break;
        }
        case Signal::result_dispatchStatement_failure: {
            this->sequencer_sendSignal_result_dispatchStatement_failure();
            break;
        }
        default: {
            FW_ASSERT(0, static_cast<FwAssertArgType>(result));
        }
    }
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_setGoalState_RUNNING(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_goalState = FpySequencer_GoalState::RUNNING;
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_setGoalState_VALID(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_goalState = FpySequencer_GoalState::VALID;
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_setGoalState_IDLE(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_goalState = FpySequencer_GoalState::IDLE;
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_OK(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    if (this->m_sequenceBlockState == FpySequencer_BlockState::BLOCK) {
        // respond if we were waiting on a response
        this->cmdResponse_out(this->m_savedOpCode, this->m_savedCmdSeq, Fw::CmdResponse::OK);
    }
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_sendCmdResponse_EXECUTION_ERROR(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    if (this->m_sequenceBlockState == FpySequencer_BlockState::BLOCK) {
        // respond if we were waiting on a response
        this->cmdResponse_out(this->m_savedOpCode, this->m_savedCmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
    }
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_resetRuntime(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    // explicitly call dtor
    this->m_runtime.~Runtime();
    new (&this->m_runtime) Runtime();
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_validate(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    Fw::Success result = this->validate();
    if (result == Fw::Success::FAILURE) {
        this->sequencer_sendSignal_result_failure();
        return;
    }
    this->sequencer_sendSignal_result_success();
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_checkShouldWake(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    Signal result = this->checkShouldWake();
    switch (result) {
        case Signal::result_checkShouldWake_keepSleeping: {
            this->sequencer_sendSignal_result_checkShouldWake_keepSleeping();
            break;
        }
        case Signal::result_checkShouldWake_wakeup: {
            this->sequencer_sendSignal_result_checkShouldWake_wakeup();
            break;
        }
        case Signal::result_timeOpFailed: {
            this->sequencer_sendSignal_result_timeOpFailed();
            break;
        }
        default: {
            FW_ASSERT(0, static_cast<FwAssertArgType>(result));
        }
    }
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_checkStatementTimeout(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    Signal result = this->checkStatementTimeout();
    switch (result) {
        case Signal::result_checkStatementTimeout_noTimeout: {
            this->sequencer_sendSignal_result_checkStatementTimeout_noTimeout();
            break;
        }
        case Signal::result_checkStatementTimeout_statementTimeout: {
            this->sequencer_sendSignal_result_checkStatementTimeout_statementTimeout();
            break;
        }
        case Signal::result_timeOpFailed: {
            this->sequencer_sendSignal_result_timeOpFailed();
            break;
        }
        default: {
            FW_ASSERT(0, static_cast<FwAssertArgType>(result));
        }
    }
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_incrementSequenceCounter(
    SmId smId, 
    Svc_FpySequencer_SequencerStateMachine::Signal signal 
) {
    this->m_sequencesStarted++;
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_clearSequenceFile(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_sequenceFilePath = "";
}

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

bool FpySequencer::Svc_FpySequencer_SequencerStateMachine_guard_goalStateIs_RUNNING(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) const {
    return this->m_goalState == FpySequencer_GoalState::RUNNING;
}

}  // namespace Svc