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    
) {
    Fw::ParamValid valid;
    Fw::ParamString baseDir = this->paramGet_SEQ_BASE_DIR(valid);
    if (baseDir.length() == 0) {
        // the assignment here ensures the string is null terminated
        // because it uses the string_copy method
        // also, the filePath string in SequenceExecutionArgs is guaranteed
        // to be truncated to FileNameStringSize chars, so it will not
        // be truncated by this assignment
        this->m_sequenceFilePath = value.get_filePath();
        return;
    }

    Fw::FormatStatus status;
    // the result will get truncated to FileNameStringSize
    status = this->m_sequenceFilePath.format("%s/%s", baseDir.toChar(), value.get_filePath().toChar());
    if (status == Fw::FormatStatus::SUCCESS) {
        return;
    }

    // the only runtime-reachable non-success status is OVERFLOWED, which means the
    // base dir and file name together are longer than the sequence file path buffer.
    // the other statuses can only result from a bad format string literal, which is a
    // coding error. let the user know the path was truncated; validate() will then fail
    // to open the (truncated) path and report a FileOpenError.
    FW_ASSERT(status == Fw::FormatStatus::OVERFLOWED, static_cast<I32>(status));
    this->log_WARNING_HI_SequenceFilePathTooLong(baseDir, value.get_filePath());
}

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

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

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);
    this->m_sequenceFilePath = NO_SEQ;
    if (this->isConnected_seqDoneOut_OutputPort(0)) {
        // report that the sequence succeeded to internal callers
        this->seqDoneOut_out(0, 0, 0, Fw::CmdResponse::OK);
    }
}

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);
    if (this->isConnected_seqDoneOut_OutputPort(0)) {
        // report that the sequence failed to internal callers
        this->seqDoneOut_out(0, 0, 0, Fw::CmdResponse::EXECUTION_ERROR);
    }
}

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(false, 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 == 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 == 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();
    FW_ASSERT(result == Fw::Success::SUCCESS || result == Fw::Success::FAILURE, static_cast<FwAssertArgType>(result));
    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(false, 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(false, 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_pushArgsToStack(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    const Svc::SeqArgs& args = this->m_sequenceArgs;

    // Early return if no arguments provided
    if (args.get_size() == 0) {
        return;
    }

    // Push args buffer to stack. Args are already serialized in big-endian format
    // by F' serialization system, so no endianness conversion is needed.
    this->m_runtime.stack.push(args.get_buffer(), static_cast<Fpy::StackSizeType>(args.get_size()));
}

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

void FpySequencer ::Svc_FpySequencer_SequencerStateMachine_action_clearSequenceArguments(
    SmId smId,
    Svc_FpySequencer_SequencerStateMachine::Signal signal) {
    this->m_sequenceArgs = {0, 0};
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_clearBreakpoint(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_breakpoint.breakpointInUse = false;
    this->m_breakpoint.breakpointIndex = 0;
    this->m_breakpoint.breakOnlyOnceOnBreakpoint = false;
    this->m_breakpoint.breakBeforeNextLine = false;
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_report_seqBroken(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->log_ACTIVITY_HI_SequencePaused(this->m_runtime.nextStatementIndex);
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_setBreakpoint(
    SmId smId,                                              
    Svc_FpySequencer_SequencerStateMachine::Signal signal,  
    const Svc::FpySequencer_BreakpointArgs& value           
) {
    this->m_breakpoint.breakpointInUse = value.get_breakOnBreakpoint();
    this->m_breakpoint.breakOnlyOnceOnBreakpoint = value.get_breakOnlyOnceOnBreakpoint();
    this->m_breakpoint.breakpointIndex = value.get_breakpointIndex();
    this->log_ACTIVITY_HI_BreakpointSet(value.get_breakpointIndex(), value.get_breakOnlyOnceOnBreakpoint());
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_setBreakBeforeNextLine(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_breakpoint.breakBeforeNextLine = true;
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_clearBreakBeforeNextLine(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    this->m_breakpoint.breakBeforeNextLine = false;
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_report_seqFailed(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    if (this->isConnected_seqDoneOut_OutputPort(0)) {
        // report that the sequence failed to internal callers
        this->seqDoneOut_out(0, 0, 0, Fw::CmdResponse::EXECUTION_ERROR);
    }
}

void FpySequencer::Svc_FpySequencer_SequencerStateMachine_action_report_seqStarted(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) {
    if (this->isConnected_seqStartOut_OutputPort(0)) {
        // report that the sequence started to internal callers
        // NOTE: Sequence Arguments would be cleared if a VALIDATION command is sent, not a full RUN command.
        this->seqStartOut_out(0, this->m_sequenceFilePath, this->m_sequenceArgs);
    }
}
// ----------------------------------------------------------------------
// 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;
}

bool FpySequencer::Svc_FpySequencer_SequencerStateMachine_guard_shouldBreak(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) const {
    // there are really two mechanisms for pausing the execution of the seq
    // one is the "break on next line flag", and the other is the breakpoint
    return this->m_breakpoint.breakBeforeNextLine ||
           (this->m_breakpoint.breakpointInUse &&
            this->m_breakpoint.breakpointIndex == this->m_runtime.nextStatementIndex);
}

bool FpySequencer::Svc_FpySequencer_SequencerStateMachine_guard_breakOnce(
    SmId smId,                                             
    Svc_FpySequencer_SequencerStateMachine::Signal signal  
) const {
    return this->m_breakpoint.breakOnlyOnceOnBreakpoint;
}
}  // namespace Svc