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::GET_FIELD: {
362  new (&deserializedDirective.getField) FpySequencer_GetFieldDirective();
363  status = argBuf.deserializeTo(deserializedDirective.getField);
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::PEEK: {
372  new (&deserializedDirective.peek) FpySequencer_PeekDirective();
373  if (argBuf.getDeserializeSizeLeft() != 0) {
374  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
375  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
376  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
377  return Fw::Success::FAILURE;
378  }
379  break;
380  }
381  case Fpy::DirectiveId::STORE_REL: {
382  new (&deserializedDirective.storeRel) FpySequencer_StoreRelDirective();
383  status = argBuf.deserializeTo(deserializedDirective.storeRel);
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::CALL: {
392  new (&deserializedDirective.call) FpySequencer_CallDirective();
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::RETURN: {
402  new (&deserializedDirective.returnDirective) FpySequencer_ReturnDirective();
403  status = argBuf.deserializeTo(deserializedDirective.returnDirective);
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::LOAD_ABS: {
412  new (&deserializedDirective.loadAbs) FpySequencer_LoadAbsDirective();
413  status = argBuf.deserializeTo(deserializedDirective.loadAbs);
414  if (status != Fw::SerializeStatus::FW_SERIALIZE_OK || argBuf.getDeserializeSizeLeft() != 0) {
415  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(), status,
416  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
417  return Fw::Success::FAILURE;
418  }
419  break;
420  }
421  case Fpy::DirectiveId::STORE_ABS: {
422  new (&deserializedDirective.storeAbs) FpySequencer_StoreAbsDirective();
423  status = argBuf.deserializeTo(deserializedDirective.storeAbs);
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::STORE_ABS_CONST_OFFSET: {
432  new (&deserializedDirective.storeAbsConstOffset) FpySequencer_StoreAbsConstOffsetDirective();
433  status = argBuf.deserializeTo(deserializedDirective.storeAbsConstOffset);
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::POP_EVENT: {
442  new (&deserializedDirective.popEvent) FpySequencer_PopEventDirective();
443  // pop event has no hardcoded args
444  if (argBuf.getDeserializeSizeLeft() != 0) {
445  this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
446  Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
447  argBuf.getDeserializeSizeLeft(), argBuf.getSize());
448  return Fw::Success::FAILURE;
449  }
450  break;
451  }
452  default: {
453  // unsure what this opcode is. check compiler version matches sequencer
454  this->log_WARNING_HI_UnknownSequencerDirective(stmt.get_opCode(), this->currentStatementIdx(),
455  this->m_sequenceFilePath);
456  return Fw::Success::FAILURE;
457  }
458  }
459  return Fw::Success::SUCCESS;
460 }
461 
462 // dispatches a deserialized sequencer directive to the right handler.
463 void FpySequencer::dispatchDirective(const DirectiveUnion& directive, const Fpy::DirectiveId& id) {
464  switch (id) {
465  case Fpy::DirectiveId::INVALID: {
466  // coding err
467  FW_ASSERT(0);
468  return;
469  }
470  case Fpy::DirectiveId::WAIT_REL: {
471  this->directive_waitRel_internalInterfaceInvoke(directive.waitRel);
472  return;
473  }
474  case Fpy::DirectiveId::WAIT_ABS: {
475  this->directive_waitAbs_internalInterfaceInvoke(directive.waitAbs);
476  return;
477  }
478  case Fpy::DirectiveId::GOTO: {
479  this->directive_goto_internalInterfaceInvoke(directive.gotoDirective);
480  return;
481  }
482  case Fpy::DirectiveId::IF: {
483  this->directive_if_internalInterfaceInvoke(directive.ifDirective);
484  return;
485  }
486  case Fpy::DirectiveId::NO_OP: {
487  this->directive_noOp_internalInterfaceInvoke(directive.noOp);
488  return;
489  }
490  case Fpy::DirectiveId::PUSH_TLM_VAL: {
491  this->directive_pushTlmVal_internalInterfaceInvoke(directive.pushTlmVal);
492  return;
493  }
494  case Fpy::DirectiveId::PUSH_TLM_VAL_AND_TIME: {
495  this->directive_pushTlmValAndTime_internalInterfaceInvoke(directive.pushTlmValAndTime);
496  return;
497  }
498  case Fpy::DirectiveId::PUSH_PRM: {
499  this->directive_pushPrm_internalInterfaceInvoke(directive.pushPrm);
500  return;
501  }
502  case Fpy::DirectiveId::CONST_CMD: {
503  this->directive_constCmd_internalInterfaceInvoke(directive.constCmd);
504  return;
505  }
506  // fallthrough on purpose
507  case Fpy::DirectiveId::OR:
508  case Fpy::DirectiveId::AND:
509  case Fpy::DirectiveId::IEQ:
510  case Fpy::DirectiveId::INE:
511  case Fpy::DirectiveId::UGT:
512  case Fpy::DirectiveId::ULT:
513  case Fpy::DirectiveId::ULE:
514  case Fpy::DirectiveId::UGE:
515  case Fpy::DirectiveId::SGT:
516  case Fpy::DirectiveId::SLT:
517  case Fpy::DirectiveId::SLE:
518  case Fpy::DirectiveId::SGE:
519  case Fpy::DirectiveId::FEQ:
520  case Fpy::DirectiveId::FNE:
521  case Fpy::DirectiveId::FLT:
522  case Fpy::DirectiveId::FLE:
523  case Fpy::DirectiveId::FGT:
524  case Fpy::DirectiveId::FGE:
525  case Fpy::DirectiveId::NOT:
526  case Fpy::DirectiveId::FPEXT:
527  case Fpy::DirectiveId::FPTRUNC:
528  case Fpy::DirectiveId::FPTOSI:
529  case Fpy::DirectiveId::FPTOUI:
530  case Fpy::DirectiveId::SITOFP:
531  case Fpy::DirectiveId::UITOFP:
532  case Fpy::DirectiveId::ADD:
533  case Fpy::DirectiveId::SUB:
534  case Fpy::DirectiveId::MUL:
535  case Fpy::DirectiveId::UDIV:
536  case Fpy::DirectiveId::SDIV:
537  case Fpy::DirectiveId::UMOD:
538  case Fpy::DirectiveId::SMOD:
539  case Fpy::DirectiveId::FADD:
540  case Fpy::DirectiveId::FSUB:
541  case Fpy::DirectiveId::FMUL:
542  case Fpy::DirectiveId::FDIV:
543  case Fpy::DirectiveId::FPOW:
544  case Fpy::DirectiveId::FLOG:
545  case Fpy::DirectiveId::FMOD:
546  case Fpy::DirectiveId::SIEXT_8_64:
547  case Fpy::DirectiveId::SIEXT_16_64:
548  case Fpy::DirectiveId::SIEXT_32_64:
549  case Fpy::DirectiveId::ZIEXT_8_64:
550  case Fpy::DirectiveId::ZIEXT_16_64:
551  case Fpy::DirectiveId::ZIEXT_32_64:
552  case Fpy::DirectiveId::ITRUNC_64_8:
553  case Fpy::DirectiveId::ITRUNC_64_16:
554  case Fpy::DirectiveId::ITRUNC_64_32: {
555  this->directive_stackOp_internalInterfaceInvoke(directive.stackOp);
556  return;
557  }
558  case Fpy::DirectiveId::EXIT: {
559  this->directive_exit_internalInterfaceInvoke(directive.exit);
560  return;
561  }
562  case Fpy::DirectiveId::ALLOCATE: {
563  this->directive_allocate_internalInterfaceInvoke(directive.allocate);
564  return;
565  }
566  case Fpy::DirectiveId::STORE_REL_CONST_OFFSET: {
567  this->directive_storeRelConstOffset_internalInterfaceInvoke(directive.storeRelConstOffset);
568  return;
569  }
570  case Fpy::DirectiveId::LOAD_REL: {
571  this->directive_loadRel_internalInterfaceInvoke(directive.loadRel);
572  return;
573  }
574  case Fpy::DirectiveId::PUSH_VAL: {
575  this->directive_pushVal_internalInterfaceInvoke(directive.pushVal);
576  return;
577  }
578  case Fpy::DirectiveId::DISCARD: {
579  this->directive_discard_internalInterfaceInvoke(directive.discard);
580  return;
581  }
582  case Fpy::DirectiveId::MEMCMP: {
583  this->directive_memCmp_internalInterfaceInvoke(directive.memCmp);
584  return;
585  }
586  case Fpy::DirectiveId::STACK_CMD: {
587  this->directive_stackCmd_internalInterfaceInvoke(directive.stackCmd);
588  return;
589  }
590  case Fpy::DirectiveId::PUSH_TIME: {
591  this->directive_pushTime_internalInterfaceInvoke(directive.pushTime);
592  return;
593  }
594  case Fpy::DirectiveId::GET_FIELD: {
595  this->directive_getField_internalInterfaceInvoke(directive.getField);
596  return;
597  }
598  case Fpy::DirectiveId::PEEK: {
599  this->directive_peek_internalInterfaceInvoke(directive.peek);
600  return;
601  }
602  case Fpy::DirectiveId::STORE_REL: {
603  this->directive_storeRel_internalInterfaceInvoke(directive.storeRel);
604  return;
605  }
606  case Fpy::DirectiveId::CALL: {
607  this->directive_call_internalInterfaceInvoke(directive.call);
608  return;
609  }
610  case Fpy::DirectiveId::RETURN: {
611  this->directive_return_internalInterfaceInvoke(directive.returnDirective);
612  return;
613  }
614  case Fpy::DirectiveId::LOAD_ABS: {
615  this->directive_loadAbs_internalInterfaceInvoke(directive.loadAbs);
616  return;
617  }
618  case Fpy::DirectiveId::STORE_ABS: {
619  this->directive_storeAbs_internalInterfaceInvoke(directive.storeAbs);
620  return;
621  }
622  case Fpy::DirectiveId::STORE_ABS_CONST_OFFSET: {
623  this->directive_storeAbsConstOffset_internalInterfaceInvoke(directive.storeAbsConstOffset);
624  return;
625  }
626  case Fpy::DirectiveId::POP_EVENT: {
627  this->directive_popEvent_internalInterfaceInvoke(directive.popEvent);
628  return;
629  }
630  }
631  // coding err
632  FW_ASSERT(0, static_cast<FwAssertArgType>(id));
633 }
634 
635 Signal FpySequencer::checkShouldWake() {
636  Fw::Time currentTime = this->getTime();
637 
638  if (currentTime.getTimeBase() != this->m_runtime.wakeupTime.getTimeBase()) {
639  // cannot compare these times.
640  this->log_WARNING_HI_MismatchedTimeBase(currentTime.getTimeBase(), this->m_runtime.wakeupTime.getTimeBase());
641 
642  return Signal::result_timeOpFailed;
643  }
644 
645  // Do not compare time context
646 
647  if (currentTime < this->m_runtime.wakeupTime) {
648  // not time to wake up!
649  return Signal::result_checkShouldWake_keepSleeping;
650  }
651 
652  // say we've finished our sleep
653  return Signal::result_checkShouldWake_wakeup;
654 }
655 
656 // checks whether the currently executing statement timed out
657 Signal FpySequencer::checkStatementTimeout() {
658  Fw::ParamValid valid;
659  F32 timeout = this->paramGet_STATEMENT_TIMEOUT_SECS(valid);
660  if (timeout <= 0 || timeout > static_cast<F32>(std::numeric_limits<U32>::max())) {
661  // no timeout
662  return Signal::result_checkStatementTimeout_noTimeout;
663  }
664 
665  Fw::Time currentTime = getTime();
666 
667  if (currentTime.getTimeBase() != this->m_runtime.currentStatementDispatchTime.getTimeBase()) {
668  // can't compare time base. must have changed
669  this->log_WARNING_HI_MismatchedTimeBase(currentTime.getTimeBase(),
670  this->m_runtime.currentStatementDispatchTime.getTimeBase());
671  return Signal::result_timeOpFailed;
672  }
673 
674  // Do not compare time context
675 
676  if (this->m_runtime.currentStatementDispatchTime.getSeconds() > currentTime.getSeconds()) {
677  // somehow we've gone back in time... just ignore it and move on. should get fixed
678  // if we wait I guess
679  return Signal::result_checkStatementTimeout_noTimeout;
680  }
681 
682  if (this->m_runtime.currentStatementDispatchTime.getSeconds() == currentTime.getSeconds() &&
683  this->m_runtime.currentStatementDispatchTime.getUSeconds() > currentTime.getUSeconds()) {
684  // same as above
685  return Signal::result_checkStatementTimeout_noTimeout;
686  }
687 
688  U64 currentUSeconds = currentTime.getSeconds() * 1000000 + currentTime.getUSeconds();
689  U64 dispatchUSeconds = this->m_runtime.currentStatementDispatchTime.getSeconds() * 1000000 +
690  this->m_runtime.currentStatementDispatchTime.getUSeconds();
691 
692  U64 timeoutUSeconds = static_cast<U64>(timeout * 1000000.0f);
693 
694  if (currentUSeconds - dispatchUSeconds < timeoutUSeconds) {
695  // not over timeout
696  return Signal::result_checkStatementTimeout_noTimeout;
697  }
698 
699  // we timed out
700  if (this->m_runtime.currentStatementOpcode == Fpy::DirectiveId::CONST_CMD ||
701  this->m_runtime.currentStatementOpcode == Fpy::DirectiveId::STACK_CMD) {
702  // if we were executing a command, warn that the cmd timed out with its opcode
703  this->log_WARNING_HI_CommandTimedOut(this->m_runtime.currentCmdOpcode, this->currentStatementIdx(),
704  this->m_sequenceFilePath);
705  } else {
706  this->log_WARNING_HI_DirectiveTimedOut(this->m_runtime.currentStatementOpcode, this->currentStatementIdx(),
707  this->m_sequenceFilePath);
708  }
709 
710  return Signal::result_checkStatementTimeout_statementTimeout;
711 }
712 
713 } // 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:7188
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:2969
Fw::Success::SUCCESS
Representing success.
Definition: SuccessEnumAc.hpp:35
FwSizeType
PlatformSizeType FwSizeType
Definition: FwSizeTypeAliasAc.h:15
Svc::FpySequencerComponentBase::directive_popEvent_internalInterfaceInvoke
void directive_popEvent_internalInterfaceInvoke(const Svc::FpySequencer_PopEventDirective &directive)
Internal interface base-class function for directive_popEvent.
Definition: FpySequencerComponentAc.cpp:2789
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:3077
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:2897
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:2573
Fw::Time::getTimeBase
TimeBase getTimeBase() const
Definition: Time.cpp:126
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:2717
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:2321
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:3221
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:2933
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:3041
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:6715
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:2609
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:9439
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:2681
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:2861
Fw::Serialization::OMIT_LENGTH
Omit length from serialization.
Definition: Serializable.hpp:33
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:1397
Fw::Time::getSeconds
U32 getSeconds() const
Definition: Time.cpp:118
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:3257
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:2753
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:7075
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:2501
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:2429
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:2825
Fw::Time::getUSeconds
U32 getUSeconds() const
Definition: Time.cpp:122
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:2393
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:3005
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:5846
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:3113
Svc::FpySequencerComponentBase::log_WARNING_HI_MismatchedTimeBase
void log_WARNING_HI_MismatchedTimeBase(I32 internalTimeBase, I32 otherTimeBase) const
Log event MismatchedTimeBase.
Definition: FpySequencerComponentAc.cpp:6871
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:2357
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:2465
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:3149
Fw::LinearBufferBase::setBuffLen
SerializeStatus setBuffLen(Serializable::SizeType length) override
Set buffer length manually.
Definition: Serializable.cpp:678
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:2537
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:3293
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:3185
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:2645
Svc::Signal
FpySequencer_SequencerStateMachineStateMachineBase::Signal Signal
Definition: FpySequencer.hpp:38
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