F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
FpySequencerRunState.cpp
Go to the documentation of this file.
1 #include <new>
2 #include "Fw/Com/ComPacket.hpp"
3 #include "Fw/Time/Time.hpp"
4 #include "Svc/FpySequencer/FpySequencer.hpp"
5 namespace Svc {
6 
7 // returns the index of the current statement
8 U32 FpySequencer::currentStatementIdx() {
9  if (this->m_runtime.nextStatementIndex == 0) {
10  // haven't started executing the sequence yet
11  return 0;
12  }
13  return this->m_runtime.nextStatementIndex - 1;
14 }
15 
16 Signal FpySequencer::dispatchStatement() {
17  // check to make sure no array out of bounds, or if it is out of bounds it's only 1 out of bound
18  // as that indicates eof
19  FW_ASSERT(this->m_runtime.nextStatementIndex <= this->m_sequenceObj.get_header().get_statementCount());
20 
21  if (this->m_runtime.nextStatementIndex == this->m_sequenceObj.get_header().get_statementCount()) {
22  return Signal::result_dispatchStatement_noMoreStatements;
23  }
24 
25  const Fpy::Statement& nextStatement = this->m_sequenceObj.get_statements()[this->m_runtime.nextStatementIndex];
26  this->m_runtime.nextStatementIndex++;
27  this->m_runtime.currentStatementOpcode = nextStatement.get_opCode();
28  this->m_runtime.currentCmdOpcode = 0; // we haven't deserialized the directive yet, so we don't know if it's a cmd
29 
30  Fw::Success result;
31  DirectiveUnion directiveUnion;
32 
33  result = this->deserializeDirective(nextStatement, directiveUnion);
34 
35  if (!result) {
36  return Signal::result_dispatchStatement_failure;
37  }
38 
39  if (this->m_runtime.currentStatementOpcode == Fpy::DirectiveId::CONST_CMD) {
40  // update the opcode of the cmd we will await
41  this->m_runtime.currentCmdOpcode = directiveUnion.constCmd.get_opCode();
42  }
43 
44  this->dispatchDirective(directiveUnion,
45  Fpy::DirectiveId(static_cast<Fpy::DirectiveId::T>(nextStatement.get_opCode())));
46  this->m_runtime.currentStatementDispatchTime =
47  getTime(); // set dispatch time right after we have successfully dispatched
48 
49  this->m_statementsDispatched++;
50 
51  return Signal::result_dispatchStatement_success;
52 }
53 
54 // deserializes a directive from bytes into the Fpy type
55 // returns success if able to deserialize, and returns the Fpy type object
56 // as a reference, in a union of all the possible directive type objects
57 Fw::Success FpySequencer::deserializeDirective(const Fpy::Statement& stmt, DirectiveUnion& deserializedDirective) {
58  Fw::SerializeStatus status;
59  // make our own esb so we can deser from stmt without breaking its constness
60  Fw::ExternalSerializeBuffer argBuf(const_cast<U8*>(stmt.get_argBuf().getBuffAddr()), stmt.get_argBuf().getSize());
61  argBuf.setBuffLen(stmt.get_argBuf().getSize());
62 
63  switch (stmt.get_opCode()) {
64  case Fpy::DirectiveId::WAIT_REL: {
65  // in order to use a type with non trivial ctor in cpp union, have to manually construct and destruct it
66  new (&deserializedDirective.waitRel) FpySequencer_WaitRelDirective();
67  // wait rel does not need deser
68  if (argBuf.getDeserializeSizeLeft() != 0) {
69  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
70  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
71  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
72  return Fw::Success::FAILURE;
73  }
74  break;
75  }
76  case Fpy::DirectiveId::WAIT_ABS: {
77  new (&deserializedDirective.waitAbs) FpySequencer_WaitAbsDirective();
78  // wait abs does not need deser
79  if (argBuf.getDeserializeSizeLeft() != 0) {
80  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
81  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
82  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
83  return Fw::Success::FAILURE;
84  }
85  break;
86  }
87  case Fpy::DirectiveId::GOTO: {
88  new (&deserializedDirective.gotoDirective) FpySequencer_GotoDirective();
89  status = argBuf.deserializeTo(deserializedDirective.gotoDirective);
90  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
91  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
92  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
93  return Fw::Success::FAILURE;
94  }
95  break;
96  }
97  case Fpy::DirectiveId::IF: {
98  new (&deserializedDirective.ifDirective) FpySequencer_IfDirective();
99  status = argBuf.deserializeTo(deserializedDirective.ifDirective);
100  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
101  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
102  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
103  return Fw::Success::FAILURE;
104  }
105  break;
106  }
107  case Fpy::DirectiveId::NO_OP: {
108  new (&deserializedDirective.noOp) FpySequencer_NoOpDirective();
109  // no op does not need deser
110  if (argBuf.getDeserializeSizeLeft() != 0) {
111  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
112  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
113  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
114  return Fw::Success::FAILURE;
115  }
116  break;
117  }
118  case Fpy::DirectiveId::PUSH_TLM_VAL: {
119  new (&deserializedDirective.pushTlmVal) FpySequencer_PushTlmValDirective();
120  status = argBuf.deserializeTo(deserializedDirective.pushTlmVal);
121  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
122  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
123  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
124  return Fw::Success::FAILURE;
125  }
126  break;
127  }
128  case Fpy::DirectiveId::PUSH_TLM_VAL_AND_TIME: {
129  new (&deserializedDirective.pushTlmValAndTime) FpySequencer_PushTlmValAndTimeDirective();
130  status = argBuf.deserializeTo(deserializedDirective.pushTlmValAndTime);
131  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
132  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
133  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
134  return Fw::Success::FAILURE;
135  }
136  break;
137  }
138  case Fpy::DirectiveId::PUSH_PRM: {
139  new (&deserializedDirective.pushPrm) FpySequencer_PushPrmDirective();
140  status = argBuf.deserializeTo(deserializedDirective.pushPrm);
141  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
142  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
143  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
144  return Fw::Success::FAILURE;
145  }
146  break;
147  }
148  case Fpy::DirectiveId::CONST_CMD: {
149  new (&deserializedDirective.constCmd) FpySequencer_ConstCmdDirective();
150 
151  // first deserialize the opcode
152  FwOpcodeType opcode;
153  status = argBuf.deserializeTo(opcode);
154  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK) {
155  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
156  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
157  return Fw::Success::FAILURE;
158  }
159 
160  deserializedDirective.constCmd.set_opCode(opcode);
161  // how many bytes are left?
162  FwSizeType cmdArgBufSize = argBuf.getDeserializeSizeLeft();
163 
164  // check to make sure the value will fit in the FpySequencer_ConstCmdDirective::argBuf
165  if (cmdArgBufSize > Fpy::MAX_DIRECTIVE_SIZE) {
166  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
167  Fw::SerializeStatus::FW_DESERIALIZE_FORMAT_ERROR,
168  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
169  return Fw::Success::FAILURE;
170  }
171 
172  // okay, it will fit. put it in
173  status = argBuf.deserializeTo(deserializedDirective.constCmd.get_argBuf(), cmdArgBufSize,
174  Fw::Serialization::OMIT_LENGTH);
175 
176  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK) {
177  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
178  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
179  return Fw::Success::FAILURE;
180  }
181 
182  // now there should be nothing left, otherwise coding err
183  FW_ASSERT(argBuf.getDeserializeSizeLeft() == 0,
184  static_cast<FwAssertArgType>(argBuf.getDeserializeSizeLeft()));
185 
186  // and set the buf size now that we know it
187  deserializedDirective.constCmd.set__argBufSize(cmdArgBufSize);
188  break;
189  }
190  // fallthrough on purpose
191  case Fpy::DirectiveId::OR:
192  case Fpy::DirectiveId::AND:
193  case Fpy::DirectiveId::IEQ:
194  case Fpy::DirectiveId::INE:
195  case Fpy::DirectiveId::UGT:
196  case Fpy::DirectiveId::ULT:
197  case Fpy::DirectiveId::ULE:
198  case Fpy::DirectiveId::UGE:
199  case Fpy::DirectiveId::SGT:
200  case Fpy::DirectiveId::SLT:
201  case Fpy::DirectiveId::SLE:
202  case Fpy::DirectiveId::SGE:
203  case Fpy::DirectiveId::FEQ:
204  case Fpy::DirectiveId::FNE:
205  case Fpy::DirectiveId::FLT:
206  case Fpy::DirectiveId::FLE:
207  case Fpy::DirectiveId::FGT:
208  case Fpy::DirectiveId::FGE:
209  case Fpy::DirectiveId::NOT:
210  case Fpy::DirectiveId::FPEXT:
211  case Fpy::DirectiveId::FPTRUNC:
212  case Fpy::DirectiveId::FPTOSI:
213  case Fpy::DirectiveId::FPTOUI:
214  case Fpy::DirectiveId::SITOFP:
215  case Fpy::DirectiveId::UITOFP:
216  case Fpy::DirectiveId::ADD:
217  case Fpy::DirectiveId::SUB:
218  case Fpy::DirectiveId::MUL:
219  case Fpy::DirectiveId::UDIV:
220  case Fpy::DirectiveId::SDIV:
221  case Fpy::DirectiveId::UMOD:
222  case Fpy::DirectiveId::SMOD:
223  case Fpy::DirectiveId::FADD:
224  case Fpy::DirectiveId::FSUB:
225  case Fpy::DirectiveId::FMUL:
226  case Fpy::DirectiveId::FDIV:
227  case Fpy::DirectiveId::FPOW:
228  case Fpy::DirectiveId::FLOG:
229  case Fpy::DirectiveId::FMOD:
230  case Fpy::DirectiveId::SIEXT_8_64:
231  case Fpy::DirectiveId::SIEXT_16_64:
232  case Fpy::DirectiveId::SIEXT_32_64:
233  case Fpy::DirectiveId::ZIEXT_8_64:
234  case Fpy::DirectiveId::ZIEXT_16_64:
235  case Fpy::DirectiveId::ZIEXT_32_64:
236  case Fpy::DirectiveId::ITRUNC_64_8:
237  case Fpy::DirectiveId::ITRUNC_64_16:
238  case Fpy::DirectiveId::ITRUNC_64_32: {
239  new (&deserializedDirective.stackOp) FpySequencer_StackOpDirective();
240  if (argBuf.getDeserializeSizeLeft() != 0) {
241  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
242  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
243  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
244  return Fw::Success::FAILURE;
245  }
246  deserializedDirective.stackOp.set__op(stmt.get_opCode());
247  break;
248  }
249  case Fpy::DirectiveId::EXIT: {
250  new (&deserializedDirective.exit) FpySequencer_ExitDirective();
251  if (argBuf.getDeserializeSizeLeft() != 0) {
252  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
253  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
254  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
255  return Fw::Success::FAILURE;
256  }
257  break;
258  }
259  case Fpy::DirectiveId::ALLOCATE: {
260  new (&deserializedDirective.allocate) FpySequencer_AllocateDirective();
261  status = argBuf.deserializeTo(deserializedDirective.allocate);
262  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
263  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
264  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
265  return Fw::Success::FAILURE;
266  }
267  break;
268  }
269  case Fpy::DirectiveId::STORE_REL_CONST_OFFSET: {
270  new (&deserializedDirective.storeRelConstOffset) FpySequencer_StoreRelConstOffsetDirective();
271  status = argBuf.deserializeTo(deserializedDirective.storeRelConstOffset);
272  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
273  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
274  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
275  return Fw::Success::FAILURE;
276  }
277  break;
278  }
279  case Fpy::DirectiveId::LOAD_REL: {
280  new (&deserializedDirective.loadRel) FpySequencer_LoadRelDirective();
281  status = argBuf.deserializeTo(deserializedDirective.loadRel);
282  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
283  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
284  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
285  return Fw::Success::FAILURE;
286  }
287  break;
288  }
289  case Fpy::DirectiveId::PUSH_VAL: {
290  new (&deserializedDirective.pushVal) FpySequencer_PushValDirective();
291 
292  // how many bytes are left?
293  FwSizeType bufSize = argBuf.getDeserializeSizeLeft();
294 
295  // check to make sure the value will fit in the FpySequencer_PushValDirective::val buf
296  if (bufSize > Fpy::MAX_DIRECTIVE_SIZE) {
297  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
298  Fw::SerializeStatus::FW_DESERIALIZE_FORMAT_ERROR,
299  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
300  return Fw::Success::FAILURE;
301  }
302 
303  // okay, it will fit. put it in
304  status =
305  argBuf.deserializeTo(deserializedDirective.pushVal.get_val(), bufSize, Fw::Serialization::OMIT_LENGTH);
306 
307  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK) {
308  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
309  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
310  return Fw::Success::FAILURE;
311  }
312 
313  // now there should be nothing left, otherwise coding err
314  FW_ASSERT(argBuf.getDeserializeSizeLeft() == 0,
315  static_cast<FwAssertArgType>(argBuf.getDeserializeSizeLeft()));
316 
317  // and set the buf size now that we know it
318  deserializedDirective.pushVal.set__valSize(bufSize);
319  break;
320  }
321  case Fpy::DirectiveId::DISCARD: {
322  new (&deserializedDirective.discard) FpySequencer_DiscardDirective();
323  status = argBuf.deserializeTo(deserializedDirective.discard);
324  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
325  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
326  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
327  return Fw::Success::FAILURE;
328  }
329  break;
330  }
331  case Fpy::DirectiveId::MEMCMP: {
332  new (&deserializedDirective.memCmp) FpySequencer_MemCmpDirective();
333  status = argBuf.deserializeTo(deserializedDirective.memCmp);
334  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
335  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
336  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
337  return Fw::Success::FAILURE;
338  }
339  break;
340  }
341  case Fpy::DirectiveId::STACK_CMD: {
342  new (&deserializedDirective.stackCmd) FpySequencer_StackCmdDirective();
343  status = argBuf.deserializeTo(deserializedDirective.stackCmd);
344  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
345  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
346  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
347  return Fw::Success::FAILURE;
348  }
349  break;
350  }
351  case Fpy::DirectiveId::PUSH_TIME: {
352  new (&deserializedDirective.pushTime) FpySequencer_PushTimeDirective();
353  if (argBuf.getDeserializeSizeLeft() != 0) {
354  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
355  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
356  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
357  return Fw::Success::FAILURE;
358  }
359  break;
360  }
361  case Fpy::DirectiveId::SET_FLAG: {
362  new (&deserializedDirective.setFlag) FpySequencer_SetFlagDirective();
363  status = argBuf.deserializeTo(deserializedDirective.setFlag);
364  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
365  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
366  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
367  return Fw::Success::FAILURE;
368  }
369  break;
370  }
371  case Fpy::DirectiveId::GET_FLAG: {
372  new (&deserializedDirective.getFlag) FpySequencer_GetFlagDirective();
373  status = argBuf.deserializeTo(deserializedDirective.getFlag);
374  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
375  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
376  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
377  return Fw::Success::FAILURE;
378  }
379  break;
380  }
381  case Fpy::DirectiveId::GET_FIELD: {
382  new (&deserializedDirective.getField) FpySequencer_GetFieldDirective();
383  status = argBuf.deserializeTo(deserializedDirective.getField);
384  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
385  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
386  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
387  return Fw::Success::FAILURE;
388  }
389  break;
390  }
391  case Fpy::DirectiveId::PEEK: {
392  new (&deserializedDirective.peek) FpySequencer_PeekDirective();
393  if (argBuf.getDeserializeSizeLeft() != 0) {
394  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
395  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
396  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
397  return Fw::Success::FAILURE;
398  }
399  break;
400  }
401  case Fpy::DirectiveId::STORE_REL: {
402  new (&deserializedDirective.storeRel) FpySequencer_StoreRelDirective();
403  status = argBuf.deserializeTo(deserializedDirective.storeRel);
404  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
405  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
406  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
407  return Fw::Success::FAILURE;
408  }
409  break;
410  }
411  case Fpy::DirectiveId::CALL: {
412  new (&deserializedDirective.call) FpySequencer_CallDirective();
413  if (argBuf.getDeserializeSizeLeft() != 0) {
414  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
415  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
416  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
417  return Fw::Success::FAILURE;
418  }
419  break;
420  }
421  case Fpy::DirectiveId::RETURN: {
422  new (&deserializedDirective.returnDirective) FpySequencer_ReturnDirective();
423  status = argBuf.deserializeTo(deserializedDirective.returnDirective);
424  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
425  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
426  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
427  return Fw::Success::FAILURE;
428  }
429  break;
430  }
431  case Fpy::DirectiveId::LOAD_ABS: {
432  new (&deserializedDirective.loadAbs) FpySequencer_LoadAbsDirective();
433  status = argBuf.deserializeTo(deserializedDirective.loadAbs);
434  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
435  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
436  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
437  return Fw::Success::FAILURE;
438  }
439  break;
440  }
441  case Fpy::DirectiveId::STORE_ABS: {
442  new (&deserializedDirective.storeAbs) FpySequencer_StoreAbsDirective();
443  status = argBuf.deserializeTo(deserializedDirective.storeAbs);
444  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
445  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
446  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
447  return Fw::Success::FAILURE;
448  }
449  break;
450  }
451  case Fpy::DirectiveId::STORE_ABS_CONST_OFFSET: {
452  new (&deserializedDirective.storeAbsConstOffset) FpySequencer_StoreAbsConstOffsetDirective();
453  status = argBuf.deserializeTo(deserializedDirective.storeAbsConstOffset);
454  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
455  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
456  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
457  return Fw::Success::FAILURE;
458  }
459  break;
460  }
461  default: {
462  // unsure what this opcode is. check compiler version matches sequencer
463  this->log_WARNING_HI_UnknownSequencerDirective(stmt.get_opCode(), this->currentStatementIdx(),
464  this->m_sequenceFilePath);
465  return Fw::Success::FAILURE;
466  }
467  }
468  return Fw::Success::SUCCESS;
469 }
470 
471 // dispatches a deserialized sequencer directive to the right handler.
472 void FpySequencer::dispatchDirective(const DirectiveUnion& directive, const Fpy::DirectiveId& id) {
473  switch (id) {
474  case Fpy::DirectiveId::INVALID: {
475  // coding err
476  FW_ASSERT(0);
477  return;
478  }
479  case Fpy::DirectiveId::WAIT_REL: {
480  this->directive_waitRel_internalInterfaceInvoke(directive.waitRel);
481  return;
482  }
483  case Fpy::DirectiveId::WAIT_ABS: {
484  this->directive_waitAbs_internalInterfaceInvoke(directive.waitAbs);
485  return;
486  }
487  case Fpy::DirectiveId::GOTO: {
488  this->directive_goto_internalInterfaceInvoke(directive.gotoDirective);
489  return;
490  }
491  case Fpy::DirectiveId::IF: {
492  this->directive_if_internalInterfaceInvoke(directive.ifDirective);
493  return;
494  }
495  case Fpy::DirectiveId::NO_OP: {
496  this->directive_noOp_internalInterfaceInvoke(directive.noOp);
497  return;
498  }
499  case Fpy::DirectiveId::PUSH_TLM_VAL: {
500  this->directive_pushTlmVal_internalInterfaceInvoke(directive.pushTlmVal);
501  return;
502  }
503  case Fpy::DirectiveId::PUSH_TLM_VAL_AND_TIME: {
504  this->directive_pushTlmValAndTime_internalInterfaceInvoke(directive.pushTlmValAndTime);
505  return;
506  }
507  case Fpy::DirectiveId::PUSH_PRM: {
508  this->directive_pushPrm_internalInterfaceInvoke(directive.pushPrm);
509  return;
510  }
511  case Fpy::DirectiveId::CONST_CMD: {
512  this->directive_constCmd_internalInterfaceInvoke(directive.constCmd);
513  return;
514  }
515  // fallthrough on purpose
516  case Fpy::DirectiveId::OR:
517  case Fpy::DirectiveId::AND:
518  case Fpy::DirectiveId::IEQ:
519  case Fpy::DirectiveId::INE:
520  case Fpy::DirectiveId::UGT:
521  case Fpy::DirectiveId::ULT:
522  case Fpy::DirectiveId::ULE:
523  case Fpy::DirectiveId::UGE:
524  case Fpy::DirectiveId::SGT:
525  case Fpy::DirectiveId::SLT:
526  case Fpy::DirectiveId::SLE:
527  case Fpy::DirectiveId::SGE:
528  case Fpy::DirectiveId::FEQ:
529  case Fpy::DirectiveId::FNE:
530  case Fpy::DirectiveId::FLT:
531  case Fpy::DirectiveId::FLE:
532  case Fpy::DirectiveId::FGT:
533  case Fpy::DirectiveId::FGE:
534  case Fpy::DirectiveId::NOT:
535  case Fpy::DirectiveId::FPEXT:
536  case Fpy::DirectiveId::FPTRUNC:
537  case Fpy::DirectiveId::FPTOSI:
538  case Fpy::DirectiveId::FPTOUI:
539  case Fpy::DirectiveId::SITOFP:
540  case Fpy::DirectiveId::UITOFP:
541  case Fpy::DirectiveId::ADD:
542  case Fpy::DirectiveId::SUB:
543  case Fpy::DirectiveId::MUL:
544  case Fpy::DirectiveId::UDIV:
545  case Fpy::DirectiveId::SDIV:
546  case Fpy::DirectiveId::UMOD:
547  case Fpy::DirectiveId::SMOD:
548  case Fpy::DirectiveId::FADD:
549  case Fpy::DirectiveId::FSUB:
550  case Fpy::DirectiveId::FMUL:
551  case Fpy::DirectiveId::FDIV:
552  case Fpy::DirectiveId::FPOW:
553  case Fpy::DirectiveId::FLOG:
554  case Fpy::DirectiveId::FMOD:
555  case Fpy::DirectiveId::SIEXT_8_64:
556  case Fpy::DirectiveId::SIEXT_16_64:
557  case Fpy::DirectiveId::SIEXT_32_64:
558  case Fpy::DirectiveId::ZIEXT_8_64:
559  case Fpy::DirectiveId::ZIEXT_16_64:
560  case Fpy::DirectiveId::ZIEXT_32_64:
561  case Fpy::DirectiveId::ITRUNC_64_8:
562  case Fpy::DirectiveId::ITRUNC_64_16:
563  case Fpy::DirectiveId::ITRUNC_64_32: {
564  this->directive_stackOp_internalInterfaceInvoke(directive.stackOp);
565  return;
566  }
567  case Fpy::DirectiveId::EXIT: {
568  this->directive_exit_internalInterfaceInvoke(directive.exit);
569  return;
570  }
571  case Fpy::DirectiveId::ALLOCATE: {
572  this->directive_allocate_internalInterfaceInvoke(directive.allocate);
573  return;
574  }
575  case Fpy::DirectiveId::STORE_REL_CONST_OFFSET: {
576  this->directive_storeRelConstOffset_internalInterfaceInvoke(directive.storeRelConstOffset);
577  return;
578  }
579  case Fpy::DirectiveId::LOAD_REL: {
580  this->directive_loadRel_internalInterfaceInvoke(directive.loadRel);
581  return;
582  }
583  case Fpy::DirectiveId::PUSH_VAL: {
584  this->directive_pushVal_internalInterfaceInvoke(directive.pushVal);
585  return;
586  }
587  case Fpy::DirectiveId::DISCARD: {
588  this->directive_discard_internalInterfaceInvoke(directive.discard);
589  return;
590  }
591  case Fpy::DirectiveId::MEMCMP: {
592  this->directive_memCmp_internalInterfaceInvoke(directive.memCmp);
593  return;
594  }
595  case Fpy::DirectiveId::STACK_CMD: {
596  this->directive_stackCmd_internalInterfaceInvoke(directive.stackCmd);
597  return;
598  }
599  case Fpy::DirectiveId::PUSH_TIME: {
600  this->directive_pushTime_internalInterfaceInvoke(directive.pushTime);
601  return;
602  }
603  case Fpy::DirectiveId::SET_FLAG: {
604  this->directive_setFlag_internalInterfaceInvoke(directive.setFlag);
605  return;
606  }
607  case Fpy::DirectiveId::GET_FLAG: {
608  this->directive_getFlag_internalInterfaceInvoke(directive.getFlag);
609  return;
610  }
611  case Fpy::DirectiveId::GET_FIELD: {
612  this->directive_getField_internalInterfaceInvoke(directive.getField);
613  return;
614  }
615  case Fpy::DirectiveId::PEEK: {
616  this->directive_peek_internalInterfaceInvoke(directive.peek);
617  return;
618  }
619  case Fpy::DirectiveId::STORE_REL: {
620  this->directive_storeRel_internalInterfaceInvoke(directive.storeRel);
621  return;
622  }
623  case Fpy::DirectiveId::CALL: {
624  this->directive_call_internalInterfaceInvoke(directive.call);
625  return;
626  }
627  case Fpy::DirectiveId::RETURN: {
628  this->directive_return_internalInterfaceInvoke(directive.returnDirective);
629  return;
630  }
631  case Fpy::DirectiveId::LOAD_ABS: {
632  this->directive_loadAbs_internalInterfaceInvoke(directive.loadAbs);
633  return;
634  }
635  case Fpy::DirectiveId::STORE_ABS: {
636  this->directive_storeAbs_internalInterfaceInvoke(directive.storeAbs);
637  return;
638  }
639  case Fpy::DirectiveId::STORE_ABS_CONST_OFFSET: {
640  this->directive_storeAbsConstOffset_internalInterfaceInvoke(directive.storeAbsConstOffset);
641  return;
642  }
643  }
644  // coding err
645  FW_ASSERT(0, static_cast<FwAssertArgType>(id));
646 }
647 
648 Signal FpySequencer::checkShouldWake() {
649  Fw::Time currentTime = this->getTime();
650 
651  if (currentTime.getTimeBase() != this->m_runtime.wakeupTime.getTimeBase()) {
652  // cannot compare these times.
653  this->log_WARNING_HI_MismatchedTimeBase(currentTime.getTimeBase(), this->m_runtime.wakeupTime.getTimeBase());
654 
655  return Signal::result_timeOpFailed;
656  }
657 
658  // Do not compare time context
659 
660  if (currentTime < this->m_runtime.wakeupTime) {
661  // not time to wake up!
662  return Signal::result_checkShouldWake_keepSleeping;
663  }
664 
665  // say we've finished our sleep
666  return Signal::result_checkShouldWake_wakeup;
667 }
668 
669 // checks whether the currently executing statement timed out
670 Signal FpySequencer::checkStatementTimeout() {
671  Fw::ParamValid valid;
672  F32 timeout = this->paramGet_STATEMENT_TIMEOUT_SECS(valid);
673  if (timeout <= 0 || timeout > static_cast<F32>(std::numeric_limits<U32>::max())) {
674  // no timeout
675  return Signal::result_checkStatementTimeout_noTimeout;
676  }
677 
678  Fw::Time currentTime = getTime();
679 
680  if (currentTime.getTimeBase() != this->m_runtime.currentStatementDispatchTime.getTimeBase()) {
681  // can't compare time base. must have changed
682  this->log_WARNING_HI_MismatchedTimeBase(currentTime.getTimeBase(),
683  this->m_runtime.currentStatementDispatchTime.getTimeBase());
684  return Signal::result_timeOpFailed;
685  }
686 
687  // Do not compare time context
688 
689  if (this->m_runtime.currentStatementDispatchTime.getSeconds() > currentTime.getSeconds()) {
690  // somehow we've gone back in time... just ignore it and move on. should get fixed
691  // if we wait I guess
692  return Signal::result_checkStatementTimeout_noTimeout;
693  }
694 
695  if (this->m_runtime.currentStatementDispatchTime.getSeconds() == currentTime.getSeconds() &&
696  this->m_runtime.currentStatementDispatchTime.getUSeconds() > currentTime.getUSeconds()) {
697  // same as above
698  return Signal::result_checkStatementTimeout_noTimeout;
699  }
700 
701  U64 currentUSeconds = currentTime.getSeconds() * 1000000 + currentTime.getUSeconds();
702  U64 dispatchUSeconds = this->m_runtime.currentStatementDispatchTime.getSeconds() * 1000000 +
703  this->m_runtime.currentStatementDispatchTime.getUSeconds();
704 
705  U64 timeoutUSeconds = static_cast<U64>(timeout * 1000000.0f);
706 
707  if (currentUSeconds - dispatchUSeconds < timeoutUSeconds) {
708  // not over timeout
709  return Signal::result_checkStatementTimeout_noTimeout;
710  }
711 
712  // we timed out
713  if (this->m_runtime.currentStatementOpcode == Fpy::DirectiveId::CONST_CMD ||
714  this->m_runtime.currentStatementOpcode == Fpy::DirectiveId::STACK_CMD) {
715  // if we were executing a command, warn that the cmd timed out with its opcode
716  this->log_WARNING_HI_CommandTimedOut(this->m_runtime.currentCmdOpcode, this->currentStatementIdx(),
717  this->m_sequenceFilePath);
718  } else {
719  this->log_WARNING_HI_DirectiveTimedOut(this->m_runtime.currentStatementOpcode, this->currentStatementIdx(),
720  this->m_sequenceFilePath);
721  }
722 
723  return Signal::result_checkStatementTimeout_statementTimeout;
724 }
725 
726 } // namespace Svc
Fw::FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_dispatchStatement_failure
called in dispatchStatement method when a statement was unable to be sent out
Svc::FpySequencerComponentBase::log_WARNING_HI_DirectiveTimedOut
void log_WARNING_HI_DirectiveTimedOut(U8 opCode, U32 stmtIdx, const Fw::StringBase &filePath) const
Log event DirectiveTimedOut.
Definition: FpySequencerComponentAc.cpp:7093
FwOpcodeType
FwIdType FwOpcodeType
The type of a command opcode.
Definition: FwOpcodeTypeAliasAc.h:14
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_dispatchStatement_noMoreStatements
called in dispatchStatement method when there were no more statements in the sequence ...
Svc::FpySequencerComponentBase::directive_pushVal_internalInterfaceInvoke
void directive_pushVal_internalInterfaceInvoke(const Svc::FpySequencer_PushValDirective &directive)
Internal interface base-class function for directive_pushVal.
Definition: FpySequencerComponentAc.cpp:2804
Fw::Success::SUCCESS
Representing success.
Definition: SuccessEnumAc.hpp:35
FwSizeType
PlatformSizeType FwSizeType
Definition: FwSizeTypeAliasAc.h:15
FpySequencer.hpp
Svc::FpySequencerComponentBase::directive_stackOp_internalInterfaceInvoke
void directive_stackOp_internalInterfaceInvoke(const Svc::FpySequencer_StackOpDirective &directive)
Internal interface base-class function for directive_stackOp.
Definition: FpySequencerComponentAc.cpp:2948
Svc::FpySequencerComponentBase::directive_pushTlmVal_internalInterfaceInvoke
void directive_pushTlmVal_internalInterfaceInvoke(const Svc::FpySequencer_PushTlmValDirective &directive)
Internal interface base-class function for directive_pushTlmVal.
Definition: FpySequencerComponentAc.cpp:2732
ComPacket.hpp
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_checkShouldWake_keepSleeping
raised when we should keep sleeping
Svc::FpySequencerComponentBase::directive_if_internalInterfaceInvoke
void directive_if_internalInterfaceInvoke(const Svc::FpySequencer_IfDirective &directive)
Internal interface base-class function for directive_if.
Definition: FpySequencerComponentAc.cpp:2444
Fw::Time::getTimeBase
TimeBase getTimeBase() const
Definition: Time.cpp:96
Fw::FW_DESERIALIZE_FORMAT_ERROR
Deserialization data had incorrect values (unexpected data types)
Definition: Serializable.hpp:19
Svc::FpySequencerComponentBase::directive_noOp_internalInterfaceInvoke
void directive_noOp_internalInterfaceInvoke(const Svc::FpySequencer_NoOpDirective &directive)
Internal interface base-class function for directive_noOp.
Definition: FpySequencerComponentAc.cpp:2588
Svc::FpySequencerComponentBase::directive_allocate_internalInterfaceInvoke
void directive_allocate_internalInterfaceInvoke(const Svc::FpySequencer_AllocateDirective &directive)
Internal interface base-class function for directive_allocate.
Definition: FpySequencerComponentAc.cpp:2156
Svc::FpySequencerComponentBase::directive_storeRelConstOffset_internalInterfaceInvoke
void directive_storeRelConstOffset_internalInterfaceInvoke(const Svc::FpySequencer_StoreRelConstOffsetDirective &directive)
Internal interface base-class function for directive_storeRelConstOffset.
Definition: FpySequencerComponentAc.cpp:3092
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_timeOpFailed
Svc::FpySequencerComponentBase::directive_pushTlmValAndTime_internalInterfaceInvoke
void directive_pushTlmValAndTime_internalInterfaceInvoke(const Svc::FpySequencer_PushTlmValAndTimeDirective &directive)
Internal interface base-class function for directive_pushTlmValAndTime.
Definition: FpySequencerComponentAc.cpp:2768
Svc::FpySequencerComponentBase::directive_stackCmd_internalInterfaceInvoke
void directive_stackCmd_internalInterfaceInvoke(const Svc::FpySequencer_StackCmdDirective &directive)
Internal interface base-class function for directive_stackCmd.
Definition: FpySequencerComponentAc.cpp:2912
Svc::FpySequencerComponentBase::log_WARNING_HI_DirectiveDeserializeError
void log_WARNING_HI_DirectiveDeserializeError(U8 opcode, U32 stmtIdx, I32 errorCode, U64 buffLeft, U64 buffLength) const
Log event DirectiveDeserializeError.
Definition: FpySequencerComponentAc.cpp:6623
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
F32
float F32
32-bit floating point
Definition: BasicTypes.h:83
Svc::FpySequencerComponentBase::directive_loadAbs_internalInterfaceInvoke
void directive_loadAbs_internalInterfaceInvoke(const Svc::FpySequencer_LoadAbsDirective &directive)
Internal interface base-class function for directive_loadAbs.
Definition: FpySequencerComponentAc.cpp:2480
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_dispatchStatement_success
called in dispatchStatement method when a statement was successfully dispatched
Svc::FpySequencerComponentBase::paramGet_STATEMENT_TIMEOUT_SECS
F32 paramGet_STATEMENT_TIMEOUT_SECS(Fw::ParamValid &valid)
Definition: FpySequencerComponentAc.cpp:8688
Svc::FpySequencerComponentBase::directive_memCmp_internalInterfaceInvoke
void directive_memCmp_internalInterfaceInvoke(const Svc::FpySequencer_MemCmpDirective &directive)
Internal interface base-class function for directive_memCmp.
Definition: FpySequencerComponentAc.cpp:2552
Svc::FpySequencerComponentBase::directive_pushTime_internalInterfaceInvoke
void directive_pushTime_internalInterfaceInvoke(const Svc::FpySequencer_PushTimeDirective &directive)
Internal interface base-class function for directive_pushTime.
Definition: FpySequencerComponentAc.cpp:2696
Fw::Serialization::OMIT_LENGTH
Omit length from serialization.
Definition: Serializable.hpp:34
Fw::FW_DESERIALIZE_SIZE_MISMATCH
Data was left in the buffer, but not enough to deserialize.
Definition: Serializable.hpp:20
Fw::ExternalSerializeBuffer
External serialize buffer with no copy semantics.
Definition: Serializable.hpp:1394
Fw::Time::getSeconds
U32 getSeconds() const
Definition: Time.cpp:88
Svc::FpySequencerComponentBase::directive_setFlag_internalInterfaceInvoke
void directive_setFlag_internalInterfaceInvoke(const Svc::FpySequencer_SetFlagDirective &directive)
Internal interface base-class function for directive_setFlag.
Definition: FpySequencerComponentAc.cpp:2876
Svc::Fpy::Sequence::get_statements
Type_of_statements & get_statements()
Get member statements.
Definition: SequenceSerializableAc.hpp:173
Svc::FpySequencerComponentBase::directive_waitAbs_internalInterfaceInvoke
void directive_waitAbs_internalInterfaceInvoke(const Svc::FpySequencer_WaitAbsDirective &directive)
Internal interface base-class function for directive_waitAbs.
Definition: FpySequencerComponentAc.cpp:3128
Svc::FpySequencerComponentBase::directive_peek_internalInterfaceInvoke
void directive_peek_internalInterfaceInvoke(const Svc::FpySequencer_PeekDirective &directive)
Internal interface base-class function for directive_peek.
Definition: FpySequencerComponentAc.cpp:2624
Svc::FpySequencerComponentBase::log_WARNING_HI_CommandTimedOut
void log_WARNING_HI_CommandTimedOut(FwOpcodeType opCode, U32 stmtIdx, const Fw::StringBase &filePath) const
Log event CommandTimedOut.
Definition: FpySequencerComponentAc.cpp:6983
Fw::Success::FAILURE
Representing failure.
Definition: SuccessEnumAc.hpp:33
Time.hpp
Svc::FpySequencerComponentBase::directive_getField_internalInterfaceInvoke
void directive_getField_internalInterfaceInvoke(const Svc::FpySequencer_GetFieldDirective &directive)
Internal interface base-class function for directive_getField.
Definition: FpySequencerComponentAc.cpp:2336
Svc::FpySequencerComponentBase::directive_discard_internalInterfaceInvoke
void directive_discard_internalInterfaceInvoke(const Svc::FpySequencer_DiscardDirective &directive)
Internal interface base-class function for directive_discard.
Definition: FpySequencerComponentAc.cpp:2264
Svc::FpySequencerComponentBase::directive_pushPrm_internalInterfaceInvoke
void directive_pushPrm_internalInterfaceInvoke(const Svc::FpySequencer_PushPrmDirective &directive)
Internal interface base-class function for directive_pushPrm.
Definition: FpySequencerComponentAc.cpp:2660
Fw::Time::getUSeconds
U32 getUSeconds() const
Definition: Time.cpp:92
Svc::FpySequencerComponentBase::directive_constCmd_internalInterfaceInvoke
void directive_constCmd_internalInterfaceInvoke(const Svc::FpySequencer_ConstCmdDirective &directive)
Internal interface base-class function for directive_constCmd.
Definition: FpySequencerComponentAc.cpp:2228
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_checkStatementTimeout_noTimeout
raised when the statement has not timed out yet
Svc::FpySequencerComponentBase::directive_return_internalInterfaceInvoke
void directive_return_internalInterfaceInvoke(const Svc::FpySequencer_ReturnDirective &directive)
Internal interface base-class function for directive_return.
Definition: FpySequencerComponentAc.cpp:2840
Svc::FpySequencerComponentBase::directive_getFlag_internalInterfaceInvoke
void directive_getFlag_internalInterfaceInvoke(const Svc::FpySequencer_GetFlagDirective &directive)
Internal interface base-class function for directive_getFlag.
Definition: FpySequencerComponentAc.cpp:2372
Svc::FpySequencerComponentBase::log_WARNING_HI_UnknownSequencerDirective
void log_WARNING_HI_UnknownSequencerDirective(U8 opcode, U32 stmtIdx, const Fw::StringBase &filePath) const
Log event UnknownSequencerDirective.
Definition: FpySequencerComponentAc.cpp:5757
Svc
RateGroupDivider component implementation.
Definition: ActiveRateGroupCfg.hpp:18
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_checkShouldWake_wakeup
raised when we are done sleeping
Fw::ParamValid
Enum representing parameter validity.
Definition: ParamValidEnumAc.hpp:17
Svc::FpySequencerComponentBase::directive_storeAbs_internalInterfaceInvoke
void directive_storeAbs_internalInterfaceInvoke(const Svc::FpySequencer_StoreAbsDirective &directive)
Internal interface base-class function for directive_storeAbs.
Definition: FpySequencerComponentAc.cpp:2984
Svc::FpySequencerComponentBase::log_WARNING_HI_MismatchedTimeBase
void log_WARNING_HI_MismatchedTimeBase(I32 internalTimeBase, I32 otherTimeBase) const
Log event MismatchedTimeBase.
Definition: FpySequencerComponentAc.cpp:6779
Svc::FpySequencerComponentBase::directive_call_internalInterfaceInvoke
void directive_call_internalInterfaceInvoke(const Svc::FpySequencer_CallDirective &directive)
Internal interface base-class function for directive_call.
Definition: FpySequencerComponentAc.cpp:2192
Svc::FpySequencerComponentBase::directive_exit_internalInterfaceInvoke
void directive_exit_internalInterfaceInvoke(const Svc::FpySequencer_ExitDirective &directive)
Internal interface base-class function for directive_exit.
Definition: FpySequencerComponentAc.cpp:2300
Svc::FpySequencer_SequencerStateMachineStateMachineBase::Signal::result_checkStatementTimeout_statementTimeout
raised when the statement times out, according to the timeout parameter
Svc::FpySequencerComponentBase::directive_storeAbsConstOffset_internalInterfaceInvoke
void directive_storeAbsConstOffset_internalInterfaceInvoke(const Svc::FpySequencer_StoreAbsConstOffsetDirective &directive)
Internal interface base-class function for directive_storeAbsConstOffset.
Definition: FpySequencerComponentAc.cpp:3020
Fw::LinearBufferBase::setBuffLen
SerializeStatus setBuffLen(Serializable::SizeType length) override
Set buffer length manually.
Definition: Serializable.cpp:668
Svc::FpySequencerComponentBase::directive_goto_internalInterfaceInvoke
void directive_goto_internalInterfaceInvoke(const Svc::FpySequencer_GotoDirective &directive)
Internal interface base-class function for directive_goto.
Definition: FpySequencerComponentAc.cpp:2408
Svc::FpySequencerComponentBase::directive_waitRel_internalInterfaceInvoke
void directive_waitRel_internalInterfaceInvoke(const Svc::FpySequencer_WaitRelDirective &directive)
Internal interface base-class function for directive_waitRel.
Definition: FpySequencerComponentAc.cpp:3164
Svc::FpySequencerComponentBase::directive_storeRel_internalInterfaceInvoke
void directive_storeRel_internalInterfaceInvoke(const Svc::FpySequencer_StoreRelDirective &directive)
Internal interface base-class function for directive_storeRel.
Definition: FpySequencerComponentAc.cpp:3056
Svc::FpySequencerComponentBase::directive_loadRel_internalInterfaceInvoke
void directive_loadRel_internalInterfaceInvoke(const Svc::FpySequencer_LoadRelDirective &directive)
Internal interface base-class function for directive_loadRel.
Definition: FpySequencerComponentAc.cpp:2516
Svc::Signal
FpySequencer_SequencerStateMachineStateMachineBase::Signal Signal
Definition: FpySequencer.hpp:40
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:14
Fw::Success
Success/Failure.
Definition: SuccessEnumAc.hpp:17
FwAssertArgType
PlatformAssertArgType FwAssertArgType
The type of arguments to assert functions.
Definition: FwAssertArgTypeAliasAc.h:14
U64
#define U64(C)
Definition: sha.h:181