9 #if FW_ENABLE_TEXT_LOGGING 19 CMDRESPONSEIN_CMDRESPONSE,
22 SEQCANCELIN_CMDSEQCANCEL,
23 SEQDISPATCHIN_FILEDISPATCH,
48 class ComponentIpcSerializableBuffer :
58 MAX_DATA_SIZE =
sizeof(BuffUnion),
60 SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE
63 ComponentIpcSerializableBuffer() :
Fw::LinearBufferBase(m_buff, sizeof(m_buff)) {
69 U8 m_buff[SERIALIZATION_SIZE];
87 #if !FW_DIRECT_PORT_CALLS 94 this->m_cmdIn_InputPort[port].
init();
99 this->m_cmdIn_InputPort[port].
setPortNum(port);
101 #if FW_OBJECT_NAMES == 1 105 this->m_objName.toChar(),
108 this->m_cmdIn_InputPort[port].setObjName(portName.
toChar());
113 #if !FW_DIRECT_PORT_CALLS 120 this->m_cmdResponseIn_InputPort[port].
init();
125 this->m_cmdResponseIn_InputPort[port].
setPortNum(port);
127 #if FW_OBJECT_NAMES == 1 131 this->m_objName.toChar(),
134 this->m_cmdResponseIn_InputPort[port].setObjName(portName.
toChar());
139 #if !FW_DIRECT_PORT_CALLS 146 this->m_pingIn_InputPort[port].
init();
151 this->m_pingIn_InputPort[port].
setPortNum(port);
153 #if FW_OBJECT_NAMES == 1 157 this->m_objName.toChar(),
160 this->m_pingIn_InputPort[port].setObjName(portName.
toChar());
165 #if !FW_DIRECT_PORT_CALLS 172 this->m_schedIn_InputPort[port].
init();
177 this->m_schedIn_InputPort[port].
setPortNum(port);
179 #if FW_OBJECT_NAMES == 1 183 this->m_objName.toChar(),
186 this->m_schedIn_InputPort[port].setObjName(portName.
toChar());
191 #if !FW_DIRECT_PORT_CALLS 198 this->m_seqCancelIn_InputPort[port].
init();
203 this->m_seqCancelIn_InputPort[port].
setPortNum(port);
205 #if FW_OBJECT_NAMES == 1 209 this->m_objName.toChar(),
212 this->m_seqCancelIn_InputPort[port].setObjName(portName.
toChar());
217 #if !FW_DIRECT_PORT_CALLS 224 this->m_seqDispatchIn_InputPort[port].
init();
229 this->m_seqDispatchIn_InputPort[port].
setPortNum(port);
231 #if FW_OBJECT_NAMES == 1 235 this->m_objName.toChar(),
238 this->m_seqDispatchIn_InputPort[port].setObjName(portName.
toChar());
243 #if !FW_DIRECT_PORT_CALLS 250 this->m_seqRunIn_InputPort[port].
init();
255 this->m_seqRunIn_InputPort[port].
setPortNum(port);
257 #if FW_OBJECT_NAMES == 1 261 this->m_objName.toChar(),
264 this->m_seqRunIn_InputPort[port].setObjName(portName.
toChar());
269 #if !FW_DIRECT_PORT_CALLS && FW_ENABLE_TEXT_LOGGING 273 port < static_cast<FwIndexType>(this->getNum_LogText_OutputPorts());
276 this->m_LogText_OutputPort[port].
init();
278 #if FW_OBJECT_NAMES == 1 282 this->m_objName.toChar(),
285 this->m_LogText_OutputPort[port].setObjName(portName.
toChar());
290 #if !FW_DIRECT_PORT_CALLS 297 this->m_cmdRegOut_OutputPort[port].
init();
299 #if FW_OBJECT_NAMES == 1 303 this->m_objName.toChar(),
306 this->m_cmdRegOut_OutputPort[port].setObjName(portName.
toChar());
311 #if !FW_DIRECT_PORT_CALLS 318 this->m_cmdResponseOut_OutputPort[port].
init();
320 #if FW_OBJECT_NAMES == 1 324 this->m_objName.toChar(),
327 this->m_cmdResponseOut_OutputPort[port].setObjName(portName.
toChar());
332 #if !FW_DIRECT_PORT_CALLS 339 this->m_logOut_OutputPort[port].
init();
341 #if FW_OBJECT_NAMES == 1 345 this->m_objName.toChar(),
348 this->m_logOut_OutputPort[port].setObjName(portName.
toChar());
353 #if !FW_DIRECT_PORT_CALLS 360 this->m_timeCaller_OutputPort[port].
init();
362 #if FW_OBJECT_NAMES == 1 366 this->m_objName.toChar(),
369 this->m_timeCaller_OutputPort[port].setObjName(portName.
toChar());
374 #if !FW_DIRECT_PORT_CALLS 381 this->m_tlmOut_OutputPort[port].
init();
383 #if FW_OBJECT_NAMES == 1 387 this->m_objName.toChar(),
390 this->m_tlmOut_OutputPort[port].setObjName(portName.
toChar());
395 #if !FW_DIRECT_PORT_CALLS 402 this->m_comCmdOut_OutputPort[port].
init();
404 #if FW_OBJECT_NAMES == 1 408 this->m_objName.toChar(),
411 this->m_comCmdOut_OutputPort[port].setObjName(portName.
toChar());
416 #if !FW_DIRECT_PORT_CALLS 423 this->m_pingOut_OutputPort[port].
init();
425 #if FW_OBJECT_NAMES == 1 429 this->m_objName.toChar(),
432 this->m_pingOut_OutputPort[port].setObjName(portName.
toChar());
437 #if !FW_DIRECT_PORT_CALLS 444 this->m_seqDone_OutputPort[port].
init();
446 #if FW_OBJECT_NAMES == 1 450 this->m_objName.toChar(),
453 this->m_seqDone_OutputPort[port].setObjName(portName.
toChar());
458 #if !FW_DIRECT_PORT_CALLS 465 this->m_seqStartOut_OutputPort[port].
init();
467 #if FW_OBJECT_NAMES == 1 471 this->m_objName.toChar(),
474 this->m_seqStartOut_OutputPort[port].setObjName(portName.
toChar());
482 static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
486 static_cast<FwAssertArgType>(qStat)
490 #if !FW_DIRECT_PORT_CALLS 501 static_cast<FwAssertArgType>(portNum)
504 return &this->m_cmdIn_InputPort[portNum];
509 #if !FW_DIRECT_PORT_CALLS 520 static_cast<FwAssertArgType>(portNum)
523 return &this->m_cmdResponseIn_InputPort[portNum];
531 static_cast<FwAssertArgType>(portNum)
534 return &this->m_pingIn_InputPort[portNum];
542 static_cast<FwAssertArgType>(portNum)
545 return &this->m_schedIn_InputPort[portNum];
553 static_cast<FwAssertArgType>(portNum)
556 return &this->m_seqCancelIn_InputPort[portNum];
564 static_cast<FwAssertArgType>(portNum)
567 return &this->m_seqDispatchIn_InputPort[portNum];
575 static_cast<FwAssertArgType>(portNum)
578 return &this->m_seqRunIn_InputPort[portNum];
583 #if !FW_DIRECT_PORT_CALLS 589 #if FW_ENABLE_TEXT_LOGGING == 1 591 void CmdSequencerComponentBase ::
592 set_LogText_OutputPort(
598 (0 <= portNum) && (portNum < this->getNum_LogText_OutputPorts()),
599 static_cast<FwAssertArgType>(portNum)
602 this->m_LogText_OutputPort[portNum].addCallPort(port);
615 static_cast<FwAssertArgType>(portNum)
618 this->m_cmdRegOut_OutputPort[portNum].
addCallPort(port);
629 static_cast<FwAssertArgType>(portNum)
632 this->m_cmdResponseOut_OutputPort[portNum].
addCallPort(port);
643 static_cast<FwAssertArgType>(portNum)
646 this->m_logOut_OutputPort[portNum].
addCallPort(port);
657 static_cast<FwAssertArgType>(portNum)
660 this->m_timeCaller_OutputPort[portNum].
addCallPort(port);
671 static_cast<FwAssertArgType>(portNum)
674 this->m_tlmOut_OutputPort[portNum].
addCallPort(port);
679 #if !FW_DIRECT_PORT_CALLS 693 static_cast<FwAssertArgType>(portNum)
696 this->m_comCmdOut_OutputPort[portNum].
addCallPort(port);
707 static_cast<FwAssertArgType>(portNum)
710 this->m_pingOut_OutputPort[portNum].
addCallPort(port);
721 static_cast<FwAssertArgType>(portNum)
724 this->m_seqDone_OutputPort[portNum].
addCallPort(port);
735 static_cast<FwAssertArgType>(portNum)
738 this->m_seqStartOut_OutputPort[portNum].
addCallPort(port);
743 #if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION 749 #if FW_ENABLE_TEXT_LOGGING == 1 751 void CmdSequencerComponentBase ::
752 set_LogText_OutputPort(
754 Fw::InputSerializePort* port
758 (0 <= portNum) && (portNum < this->getNum_LogText_OutputPorts()),
759 static_cast<FwAssertArgType>(portNum)
762 this->m_LogText_OutputPort[portNum].registerSerialPort(port);
770 Fw::InputSerializePort* port
775 static_cast<FwAssertArgType>(portNum)
778 this->m_cmdRegOut_OutputPort[portNum].registerSerialPort(port);
784 Fw::InputSerializePort* port
789 static_cast<FwAssertArgType>(portNum)
792 this->m_cmdResponseOut_OutputPort[portNum].registerSerialPort(port);
798 Fw::InputSerializePort* port
803 static_cast<FwAssertArgType>(portNum)
806 this->m_logOut_OutputPort[portNum].registerSerialPort(port);
812 Fw::InputSerializePort* port
817 static_cast<FwAssertArgType>(portNum)
820 this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
826 Fw::InputSerializePort* port
831 static_cast<FwAssertArgType>(portNum)
834 this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
839 #if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION 848 Fw::InputSerializePort* port
853 static_cast<FwAssertArgType>(portNum)
856 this->m_comCmdOut_OutputPort[portNum].registerSerialPort(port);
862 Fw::InputSerializePort* port
867 static_cast<FwAssertArgType>(portNum)
870 this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
876 Fw::InputSerializePort* port
881 static_cast<FwAssertArgType>(portNum)
884 this->m_seqDone_OutputPort[portNum].registerSerialPort(port);
890 Fw::InputSerializePort* port
895 static_cast<FwAssertArgType>(portNum)
898 this->m_seqStartOut_OutputPort[portNum].registerSerialPort(port);
959 Fw::ActiveComponentBase(compName)
970 #if !FW_DIRECT_PORT_CALLS 976 #if FW_ENABLE_TEXT_LOGGING == 1 978 bool CmdSequencerComponentBase ::
979 isConnected_LogText_OutputPort(
FwIndexType portNum)
const 982 (0 <= portNum) && (portNum < this->getNum_LogText_OutputPorts()),
983 static_cast<FwAssertArgType>(portNum)
986 return this->m_LogText_OutputPort[portNum].isConnected();
996 static_cast<FwAssertArgType>(portNum)
999 return this->m_cmdRegOut_OutputPort[portNum].
isConnected();
1007 static_cast<FwAssertArgType>(portNum)
1010 return this->m_cmdResponseOut_OutputPort[portNum].
isConnected();
1018 static_cast<FwAssertArgType>(portNum)
1021 return this->m_logOut_OutputPort[portNum].
isConnected();
1029 static_cast<FwAssertArgType>(portNum)
1032 return this->m_timeCaller_OutputPort[portNum].
isConnected();
1040 static_cast<FwAssertArgType>(portNum)
1043 return this->m_tlmOut_OutputPort[portNum].
isConnected();
1048 #if !FW_DIRECT_PORT_CALLS 1059 static_cast<FwAssertArgType>(portNum)
1062 return this->m_comCmdOut_OutputPort[portNum].
isConnected();
1070 static_cast<FwAssertArgType>(portNum)
1073 return this->m_pingOut_OutputPort[portNum].
isConnected();
1081 static_cast<FwAssertArgType>(portNum)
1084 return this->m_seqDone_OutputPort[portNum].
isConnected();
1092 static_cast<FwAssertArgType>(portNum)
1095 return this->m_seqStartOut_OutputPort[portNum].
isConnected();
1116 FW_ASSERT(opCode >= idBase, static_cast<FwAssertArgType>(opCode), static_cast<FwAssertArgType>(idBase));
1119 switch (opCode - idBase) {
1214 static_cast<FwAssertArgType>(portNum)
1224 ComponentIpcSerializableBuffer msg;
1228 _status = msg.serializeFrom(
1229 static_cast<FwEnumStoreType>(CMDRESPONSEIN_CMDRESPONSE)
1233 static_cast<FwAssertArgType>(_status)
1237 _status = msg.serializeFrom(portNum);
1240 static_cast<FwAssertArgType>(_status)
1244 _status = msg.serializeFrom(opCode);
1247 static_cast<FwAssertArgType>(_status)
1251 _status = msg.serializeFrom(cmdSeq);
1254 static_cast<FwAssertArgType>(_status)
1258 _status = msg.serializeFrom(response);
1261 static_cast<FwAssertArgType>(_status)
1270 static_cast<FwAssertArgType>(qStatus)
1283 static_cast<FwAssertArgType>(portNum)
1291 ComponentIpcSerializableBuffer msg;
1295 _status = msg.serializeFrom(
1296 static_cast<FwEnumStoreType>(PINGIN_PING)
1300 static_cast<FwAssertArgType>(_status)
1304 _status = msg.serializeFrom(portNum);
1307 static_cast<FwAssertArgType>(_status)
1311 _status = msg.serializeFrom(key);
1314 static_cast<FwAssertArgType>(_status)
1321 if (qStatus == Os::Queue::Status::FULL) {
1328 static_cast<FwAssertArgType>(qStatus)
1341 static_cast<FwAssertArgType>(portNum)
1349 ComponentIpcSerializableBuffer msg;
1353 _status = msg.serializeFrom(
1354 static_cast<FwEnumStoreType>(SCHEDIN_SCHED)
1358 static_cast<FwAssertArgType>(_status)
1362 _status = msg.serializeFrom(portNum);
1365 static_cast<FwAssertArgType>(_status)
1369 _status = msg.serializeFrom(context);
1372 static_cast<FwAssertArgType>(_status)
1381 static_cast<FwAssertArgType>(qStatus)
1391 static_cast<FwAssertArgType>(portNum)
1396 ComponentIpcSerializableBuffer msg;
1400 _status = msg.serializeFrom(
1401 static_cast<FwEnumStoreType>(SEQCANCELIN_CMDSEQCANCEL)
1405 static_cast<FwAssertArgType>(_status)
1409 _status = msg.serializeFrom(portNum);
1412 static_cast<FwAssertArgType>(_status)
1421 static_cast<FwAssertArgType>(qStatus)
1434 static_cast<FwAssertArgType>(portNum)
1442 ComponentIpcSerializableBuffer msg;
1446 _status = msg.serializeFrom(
1447 static_cast<FwEnumStoreType>(SEQDISPATCHIN_FILEDISPATCH)
1451 static_cast<FwAssertArgType>(_status)
1455 _status = msg.serializeFrom(portNum);
1458 static_cast<FwAssertArgType>(_status)
1465 static_cast<FwAssertArgType>(_status)
1474 static_cast<FwAssertArgType>(qStatus)
1488 static_cast<FwAssertArgType>(portNum)
1497 ComponentIpcSerializableBuffer msg;
1501 _status = msg.serializeFrom(
1502 static_cast<FwEnumStoreType>(SEQRUNIN_CMDSEQIN)
1506 static_cast<FwAssertArgType>(_status)
1510 _status = msg.serializeFrom(portNum);
1513 static_cast<FwAssertArgType>(_status)
1520 static_cast<FwAssertArgType>(_status)
1524 _status = msg.serializeFrom(args);
1527 static_cast<FwAssertArgType>(_status)
1536 static_cast<FwAssertArgType>(qStatus)
1602 #if !FW_DIRECT_PORT_CALLS 1617 static_cast<FwAssertArgType>(portNum)
1621 this->m_comCmdOut_OutputPort[portNum].isConnected(),
1622 static_cast<FwAssertArgType>(portNum)
1624 this->m_comCmdOut_OutputPort[portNum].
invoke(
1638 static_cast<FwAssertArgType>(portNum)
1642 this->m_pingOut_OutputPort[portNum].isConnected(),
1643 static_cast<FwAssertArgType>(portNum)
1645 this->m_pingOut_OutputPort[portNum].
invoke(
1660 static_cast<FwAssertArgType>(portNum)
1664 this->m_seqDone_OutputPort[portNum].isConnected(),
1665 static_cast<FwAssertArgType>(portNum)
1667 this->m_seqDone_OutputPort[portNum].
invoke(
1683 static_cast<FwAssertArgType>(portNum)
1687 this->m_seqStartOut_OutputPort[portNum].isConnected(),
1688 static_cast<FwAssertArgType>(portNum)
1690 this->m_seqStartOut_OutputPort[portNum].
invoke(
1710 this->cmdResponseOut_out(0, opCode, cmdSeq, response);
1731 ComponentIpcSerializableBuffer msg;
1735 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_RUN));
1738 static_cast<FwAssertArgType>(_status)
1744 _status = msg.serializeFrom(port);
1747 static_cast<FwAssertArgType>(_status)
1750 _status = msg.serializeFrom(opCode);
1753 static_cast<FwAssertArgType>(_status)
1756 _status = msg.serializeFrom(cmdSeq);
1759 static_cast<FwAssertArgType>(_status)
1762 _status = msg.serializeFrom(args);
1765 static_cast<FwAssertArgType>(_status)
1774 static_cast<FwAssertArgType>(qStatus)
1790 ComponentIpcSerializableBuffer msg;
1794 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_VALIDATE));
1797 static_cast<FwAssertArgType>(_status)
1803 _status = msg.serializeFrom(port);
1806 static_cast<FwAssertArgType>(_status)
1809 _status = msg.serializeFrom(opCode);
1812 static_cast<FwAssertArgType>(_status)
1815 _status = msg.serializeFrom(cmdSeq);
1818 static_cast<FwAssertArgType>(_status)
1821 _status = msg.serializeFrom(args);
1824 static_cast<FwAssertArgType>(_status)
1833 static_cast<FwAssertArgType>(qStatus)
1849 ComponentIpcSerializableBuffer msg;
1853 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_CANCEL));
1856 static_cast<FwAssertArgType>(_status)
1862 _status = msg.serializeFrom(port);
1865 static_cast<FwAssertArgType>(_status)
1868 _status = msg.serializeFrom(opCode);
1871 static_cast<FwAssertArgType>(_status)
1874 _status = msg.serializeFrom(cmdSeq);
1877 static_cast<FwAssertArgType>(_status)
1880 _status = msg.serializeFrom(args);
1883 static_cast<FwAssertArgType>(_status)
1892 static_cast<FwAssertArgType>(qStatus)
1908 ComponentIpcSerializableBuffer msg;
1912 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_START));
1915 static_cast<FwAssertArgType>(_status)
1921 _status = msg.serializeFrom(port);
1924 static_cast<FwAssertArgType>(_status)
1927 _status = msg.serializeFrom(opCode);
1930 static_cast<FwAssertArgType>(_status)
1933 _status = msg.serializeFrom(cmdSeq);
1936 static_cast<FwAssertArgType>(_status)
1939 _status = msg.serializeFrom(args);
1942 static_cast<FwAssertArgType>(_status)
1951 static_cast<FwAssertArgType>(qStatus)
1967 ComponentIpcSerializableBuffer msg;
1971 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_STEP));
1974 static_cast<FwAssertArgType>(_status)
1980 _status = msg.serializeFrom(port);
1983 static_cast<FwAssertArgType>(_status)
1986 _status = msg.serializeFrom(opCode);
1989 static_cast<FwAssertArgType>(_status)
1992 _status = msg.serializeFrom(cmdSeq);
1995 static_cast<FwAssertArgType>(_status)
1998 _status = msg.serializeFrom(args);
2001 static_cast<FwAssertArgType>(_status)
2010 static_cast<FwAssertArgType>(qStatus)
2026 ComponentIpcSerializableBuffer msg;
2030 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_AUTO));
2033 static_cast<FwAssertArgType>(_status)
2039 _status = msg.serializeFrom(port);
2042 static_cast<FwAssertArgType>(_status)
2045 _status = msg.serializeFrom(opCode);
2048 static_cast<FwAssertArgType>(_status)
2051 _status = msg.serializeFrom(cmdSeq);
2054 static_cast<FwAssertArgType>(_status)
2057 _status = msg.serializeFrom(args);
2060 static_cast<FwAssertArgType>(_status)
2069 static_cast<FwAssertArgType>(qStatus)
2085 ComponentIpcSerializableBuffer msg;
2089 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_MANUAL));
2092 static_cast<FwAssertArgType>(_status)
2098 _status = msg.serializeFrom(port);
2101 static_cast<FwAssertArgType>(_status)
2104 _status = msg.serializeFrom(opCode);
2107 static_cast<FwAssertArgType>(_status)
2110 _status = msg.serializeFrom(cmdSeq);
2113 static_cast<FwAssertArgType>(_status)
2116 _status = msg.serializeFrom(args);
2119 static_cast<FwAssertArgType>(_status)
2128 static_cast<FwAssertArgType>(qStatus)
2144 ComponentIpcSerializableBuffer msg;
2148 _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CS_JOIN_WAIT));
2151 static_cast<FwAssertArgType>(_status)
2157 _status = msg.serializeFrom(port);
2160 static_cast<FwAssertArgType>(_status)
2163 _status = msg.serializeFrom(opCode);
2166 static_cast<FwAssertArgType>(_status)
2169 _status = msg.serializeFrom(cmdSeq);
2172 static_cast<FwAssertArgType>(_status)
2175 _status = msg.serializeFrom(args);
2178 static_cast<FwAssertArgType>(_status)
2187 static_cast<FwAssertArgType>(qStatus)
2297 this->timeCaller_out(0, _logTime);
2307 #if FW_AMPCS_COMPATIBLE 2312 static_cast<FwAssertArgType>(_status)
2322 static_cast<FwAssertArgType>(_status)
2335 #if FW_ENABLE_TEXT_LOGGING 2336 if (this->isConnected_LogText_OutputPort(0)) {
2337 #if FW_OBJECT_NAMES == 1 2338 const char* _formatString =
2339 "(%s) %s: Loaded sequence %s";
2341 const char* _formatString =
2342 "%s: Loaded sequence %s";
2346 (void) _logString.
format(
2349 this->m_objName.toChar(),
2351 "CS_SequenceLoaded ",
2372 this->timeCaller_out(0, _logTime);
2382 #if FW_AMPCS_COMPATIBLE 2387 static_cast<FwAssertArgType>(_status)
2397 static_cast<FwAssertArgType>(_status)
2410 #if FW_ENABLE_TEXT_LOGGING 2411 if (this->isConnected_LogText_OutputPort(0)) {
2412 #if FW_OBJECT_NAMES == 1 2413 const char* _formatString =
2414 "(%s) %s: Sequence file %s canceled";
2416 const char* _formatString =
2417 "%s: Sequence file %s canceled";
2421 (void) _logString.
format(
2424 this->m_objName.toChar(),
2426 "CS_SequenceCanceled ",
2447 this->timeCaller_out(0, _logTime);
2457 #if FW_AMPCS_COMPATIBLE 2462 static_cast<FwAssertArgType>(_status)
2472 static_cast<FwAssertArgType>(_status)
2485 #if FW_ENABLE_TEXT_LOGGING 2486 if (this->isConnected_LogText_OutputPort(0)) {
2487 #if FW_OBJECT_NAMES == 1 2488 const char* _formatString =
2489 "(%s) %s: Error reading sequence file %s";
2491 const char* _formatString =
2492 "%s: Error reading sequence file %s";
2496 (void) _logString.
format(
2499 this->m_objName.toChar(),
2501 "CS_FileReadError ",
2526 this->timeCaller_out(0, _logTime);
2536 #if FW_AMPCS_COMPATIBLE 2541 static_cast<FwAssertArgType>(_status)
2551 static_cast<FwAssertArgType>(_status)
2554 #if FW_AMPCS_COMPATIBLE 2561 static_cast<FwAssertArgType>(_status)
2567 static_cast<FwAssertArgType>(_status)
2570 #if FW_AMPCS_COMPATIBLE 2573 static_cast<U8>(
sizeof(I32))
2577 static_cast<FwAssertArgType>(_status)
2583 static_cast<FwAssertArgType>(_status)
2596 #if FW_ENABLE_TEXT_LOGGING 2597 if (this->isConnected_LogText_OutputPort(0)) {
2598 #if FW_OBJECT_NAMES == 1 2599 const char* _formatString =
2600 "(%s) %s: Sequence file %s invalid. Stage: %s Error: %" PRIi32
"";
2602 const char* _formatString =
2603 "%s: Sequence file %s invalid. Stage: %s Error: %" PRIi32
"";
2607 stage.toString(stageStr);
2610 (void) _logString.
format(
2613 this->m_objName.toChar(),
2642 this->timeCaller_out(0, _logTime);
2652 #if FW_AMPCS_COMPATIBLE 2657 static_cast<FwAssertArgType>(_status)
2667 static_cast<FwAssertArgType>(_status)
2670 #if FW_AMPCS_COMPATIBLE 2673 static_cast<U8>(
sizeof(U32))
2677 static_cast<FwAssertArgType>(_status)
2683 static_cast<FwAssertArgType>(_status)
2686 #if FW_AMPCS_COMPATIBLE 2689 static_cast<U8>(
sizeof(I32))
2693 static_cast<FwAssertArgType>(_status)
2699 static_cast<FwAssertArgType>(_status)
2712 #if FW_ENABLE_TEXT_LOGGING 2713 if (this->isConnected_LogText_OutputPort(0)) {
2714 #if FW_OBJECT_NAMES == 1 2715 const char* _formatString =
2716 "(%s) %s: Sequence file %s: Record %" PRIu32
" invalid. Err: %" PRIi32
"";
2718 const char* _formatString =
2719 "%s: Sequence file %s: Record %" PRIu32
" invalid. Err: %" PRIi32
"";
2723 (void) _logString.
format(
2726 this->m_objName.toChar(),
2728 "CS_RecordInvalid ",
2754 this->timeCaller_out(0, _logTime);
2764 #if FW_AMPCS_COMPATIBLE 2769 static_cast<FwAssertArgType>(_status)
2779 static_cast<FwAssertArgType>(_status)
2782 #if FW_AMPCS_COMPATIBLE 2785 static_cast<U8>(
sizeof(U32))
2789 static_cast<FwAssertArgType>(_status)
2795 static_cast<FwAssertArgType>(_status)
2808 #if FW_ENABLE_TEXT_LOGGING 2809 if (this->isConnected_LogText_OutputPort(0)) {
2810 #if FW_OBJECT_NAMES == 1 2811 const char* _formatString =
2812 "(%s) %s: Sequence file %s too large. Size: %" PRIu32
"";
2814 const char* _formatString =
2815 "%s: Sequence file %s too large. Size: %" PRIu32
"";
2819 (void) _logString.
format(
2822 this->m_objName.toChar(),
2824 "CS_FileSizeError ",
2846 this->timeCaller_out(0, _logTime);
2856 #if FW_AMPCS_COMPATIBLE 2861 static_cast<FwAssertArgType>(_status)
2871 static_cast<FwAssertArgType>(_status)
2884 #if FW_ENABLE_TEXT_LOGGING 2885 if (this->isConnected_LogText_OutputPort(0)) {
2886 #if FW_OBJECT_NAMES == 1 2887 const char* _formatString =
2888 "(%s) %s: Sequence file %s not found.";
2890 const char* _formatString =
2891 "%s: Sequence file %s not found.";
2895 (void) _logString.
format(
2898 this->m_objName.toChar(),
2925 this->timeCaller_out(0, _logTime);
2935 #if FW_AMPCS_COMPATIBLE 2940 static_cast<FwAssertArgType>(_status)
2950 static_cast<FwAssertArgType>(_status)
2953 #if FW_AMPCS_COMPATIBLE 2956 static_cast<U8>(
sizeof(U32))
2960 static_cast<FwAssertArgType>(_status)
2966 static_cast<FwAssertArgType>(_status)
2969 #if FW_AMPCS_COMPATIBLE 2972 static_cast<U8>(
sizeof(U32))
2976 static_cast<FwAssertArgType>(_status)
2982 static_cast<FwAssertArgType>(_status)
2995 #if FW_ENABLE_TEXT_LOGGING 2996 if (this->isConnected_LogText_OutputPort(0)) {
2997 #if FW_OBJECT_NAMES == 1 2998 const char* _formatString =
2999 "(%s) %s: Sequence file %s had invalid CRC. Stored 0x%" PRIx32
", Computed 0x%" PRIx32
".";
3001 const char* _formatString =
3002 "%s: Sequence file %s had invalid CRC. Stored 0x%" PRIx32
", Computed 0x%" PRIx32
".";
3006 (void) _logString.
format(
3009 this->m_objName.toChar(),
3011 "CS_FileCrcFailure ",
3038 this->timeCaller_out(0, _logTime);
3048 #if FW_AMPCS_COMPATIBLE 3053 static_cast<FwAssertArgType>(_status)
3063 static_cast<FwAssertArgType>(_status)
3066 #if FW_AMPCS_COMPATIBLE 3069 static_cast<U8>(
sizeof(U32))
3073 static_cast<FwAssertArgType>(_status)
3079 static_cast<FwAssertArgType>(_status)
3082 #if FW_AMPCS_COMPATIBLE 3089 static_cast<FwAssertArgType>(_status)
3095 static_cast<FwAssertArgType>(_status)
3108 #if FW_ENABLE_TEXT_LOGGING 3109 if (this->isConnected_LogText_OutputPort(0)) {
3110 #if FW_OBJECT_NAMES == 1 3111 const char* _formatString =
3112 "(%s) %s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") complete";
3114 const char* _formatString =
3115 "%s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") complete";
3119 (void) _logString.
format(
3122 this->m_objName.toChar(),
3124 "CS_CommandComplete ",
3147 this->timeCaller_out(0, _logTime);
3157 #if FW_AMPCS_COMPATIBLE 3162 static_cast<FwAssertArgType>(_status)
3172 static_cast<FwAssertArgType>(_status)
3185 #if FW_ENABLE_TEXT_LOGGING 3186 if (this->isConnected_LogText_OutputPort(0)) {
3187 #if FW_OBJECT_NAMES == 1 3188 const char* _formatString =
3189 "(%s) %s: Sequence file %s complete";
3191 const char* _formatString =
3192 "%s: Sequence file %s complete";
3196 (void) _logString.
format(
3199 this->m_objName.toChar(),
3201 "CS_SequenceComplete ",
3227 this->timeCaller_out(0, _logTime);
3237 #if FW_AMPCS_COMPATIBLE 3242 static_cast<FwAssertArgType>(_status)
3252 static_cast<FwAssertArgType>(_status)
3255 #if FW_AMPCS_COMPATIBLE 3258 static_cast<U8>(
sizeof(U32))
3262 static_cast<FwAssertArgType>(_status)
3268 static_cast<FwAssertArgType>(_status)
3271 #if FW_AMPCS_COMPATIBLE 3278 static_cast<FwAssertArgType>(_status)
3284 static_cast<FwAssertArgType>(_status)
3287 #if FW_AMPCS_COMPATIBLE 3290 static_cast<U8>(
sizeof(U32))
3294 static_cast<FwAssertArgType>(_status)
3300 static_cast<FwAssertArgType>(_status)
3313 #if FW_ENABLE_TEXT_LOGGING 3314 if (this->isConnected_LogText_OutputPort(0)) {
3315 #if FW_OBJECT_NAMES == 1 3316 const char* _formatString =
3317 "(%s) %s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") completed with error %" PRIu32
"";
3319 const char* _formatString =
3320 "%s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") completed with error %" PRIu32
"";
3324 (void) _logString.
format(
3327 this->m_objName.toChar(),
3353 this->timeCaller_out(0, _logTime);
3362 #if FW_AMPCS_COMPATIBLE 3368 static_cast<FwAssertArgType>(_status)
3382 #if FW_ENABLE_TEXT_LOGGING 3383 if (this->isConnected_LogText_OutputPort(0)) {
3384 #if FW_OBJECT_NAMES == 1 3385 const char* _formatString =
3386 "(%s) %s: Invalid mode";
3388 const char* _formatString =
3393 (void) _logString.
format(
3396 this->m_objName.toChar(),
3422 this->timeCaller_out(0, _logTime);
3432 #if FW_AMPCS_COMPATIBLE 3437 static_cast<FwAssertArgType>(_status)
3447 static_cast<FwAssertArgType>(_status)
3450 #if FW_AMPCS_COMPATIBLE 3453 static_cast<U8>(
sizeof(U32))
3457 static_cast<FwAssertArgType>(_status)
3463 static_cast<FwAssertArgType>(_status)
3466 #if FW_AMPCS_COMPATIBLE 3469 static_cast<U8>(
sizeof(U32))
3473 static_cast<FwAssertArgType>(_status)
3479 static_cast<FwAssertArgType>(_status)
3492 #if FW_ENABLE_TEXT_LOGGING 3493 if (this->isConnected_LogText_OutputPort(0)) {
3494 #if FW_OBJECT_NAMES == 1 3495 const char* _formatString =
3496 "(%s) %s: Sequence file %s header records mismatch: %" PRIu32
" in header, found %" PRIu32
" extra bytes.";
3498 const char* _formatString =
3499 "%s: Sequence file %s header records mismatch: %" PRIu32
" in header, found %" PRIu32
" extra bytes.";
3503 (void) _logString.
format(
3506 this->m_objName.toChar(),
3508 "CS_RecordMismatch ",
3535 this->timeCaller_out(0, _logTime);
3545 #if FW_AMPCS_COMPATIBLE 3550 static_cast<FwAssertArgType>(_status)
3560 static_cast<FwAssertArgType>(_status)
3563 #if FW_AMPCS_COMPATIBLE 3566 static_cast<U8>(
sizeof(U16))
3570 static_cast<FwAssertArgType>(_status)
3576 static_cast<FwAssertArgType>(_status)
3579 #if FW_AMPCS_COMPATIBLE 3582 static_cast<U8>(
sizeof(U16))
3586 static_cast<FwAssertArgType>(_status)
3592 static_cast<FwAssertArgType>(_status)
3605 #if FW_ENABLE_TEXT_LOGGING 3606 if (this->isConnected_LogText_OutputPort(0)) {
3607 #if FW_OBJECT_NAMES == 1 3608 const char* _formatString =
3609 "(%s) %s: Sequence file %s: Current time base doesn't match sequence time: base: %" PRIu16
" seq: %" PRIu16
"";
3611 const char* _formatString =
3612 "%s: Sequence file %s: Current time base doesn't match sequence time: base: %" PRIu16
" seq: %" PRIu16
"";
3616 (void) _logString.
format(
3619 this->m_objName.toChar(),
3621 "CS_TimeBaseMismatch ",
3648 this->timeCaller_out(0, _logTime);
3658 #if FW_AMPCS_COMPATIBLE 3663 static_cast<FwAssertArgType>(_status)
3673 static_cast<FwAssertArgType>(_status)
3676 #if FW_AMPCS_COMPATIBLE 3679 static_cast<U8>(
sizeof(
U8))
3683 static_cast<FwAssertArgType>(_status)
3689 static_cast<FwAssertArgType>(_status)
3692 #if FW_AMPCS_COMPATIBLE 3695 static_cast<U8>(
sizeof(
U8))
3699 static_cast<FwAssertArgType>(_status)
3705 static_cast<FwAssertArgType>(_status)
3718 #if FW_ENABLE_TEXT_LOGGING 3719 if (this->isConnected_LogText_OutputPort(0)) {
3720 #if FW_OBJECT_NAMES == 1 3721 const char* _formatString =
3722 "(%s) %s: Sequence file %s: Current time context doesn't match sequence context: base: %" PRIu8
" seq: %" PRIu8
"";
3724 const char* _formatString =
3725 "%s: Sequence file %s: Current time context doesn't match sequence context: base: %" PRIu8
" seq: %" PRIu8
"";
3729 (void) _logString.
format(
3732 this->m_objName.toChar(),
3734 "CS_TimeContextMismatch ",
3757 this->timeCaller_out(0, _logTime);
3767 #if FW_AMPCS_COMPATIBLE 3772 static_cast<FwAssertArgType>(_status)
3782 static_cast<FwAssertArgType>(_status)
3795 #if FW_ENABLE_TEXT_LOGGING 3796 if (this->isConnected_LogText_OutputPort(0)) {
3797 #if FW_OBJECT_NAMES == 1 3798 const char* _formatString =
3799 "(%s) %s: Local request for sequence %s started.";
3801 const char* _formatString =
3802 "%s: Local request for sequence %s started.";
3806 (void) _logString.
format(
3809 this->m_objName.toChar(),
3811 "CS_PortSequenceStarted ",
3832 this->timeCaller_out(0, _logTime);
3842 #if FW_AMPCS_COMPATIBLE 3847 static_cast<FwAssertArgType>(_status)
3851 #if FW_AMPCS_COMPATIBLE 3858 static_cast<FwAssertArgType>(_status)
3864 static_cast<FwAssertArgType>(_status)
3877 #if FW_ENABLE_TEXT_LOGGING 3878 if (this->isConnected_LogText_OutputPort(0)) {
3879 #if FW_OBJECT_NAMES == 1 3880 const char* _formatString =
3881 "(%s) %s: Command complete status received while no sequences active. Opcode: %" PRIu32
"";
3883 const char* _formatString =
3884 "%s: Command complete status received while no sequences active. Opcode: %" PRIu32
"";
3888 (void) _logString.
format(
3891 this->m_objName.toChar(),
3893 "CS_UnexpectedCompletion ",
3914 this->timeCaller_out(0, _logTime);
3924 #if FW_AMPCS_COMPATIBLE 3929 static_cast<FwAssertArgType>(_status)
3933 #if FW_AMPCS_COMPATIBLE 3940 static_cast<FwAssertArgType>(_status)
3946 static_cast<FwAssertArgType>(_status)
3959 #if FW_ENABLE_TEXT_LOGGING 3960 if (this->isConnected_LogText_OutputPort(0)) {
3961 #if FW_OBJECT_NAMES == 1 3962 const char* _formatString =
3963 "(%s) %s: Sequencer switched to %s step mode";
3965 const char* _formatString =
3966 "%s: Sequencer switched to %s step mode";
3970 mode.toString(modeStr);
3973 (void) _logString.
format(
3976 this->m_objName.toChar(),
3999 this->timeCaller_out(0, _logTime);
4008 #if FW_AMPCS_COMPATIBLE 4014 static_cast<FwAssertArgType>(_status)
4028 #if FW_ENABLE_TEXT_LOGGING 4029 if (this->isConnected_LogText_OutputPort(0)) {
4030 #if FW_OBJECT_NAMES == 1 4031 const char* _formatString =
4032 "(%s) %s: No sequence active.";
4034 const char* _formatString =
4035 "%s: No sequence active.";
4039 (void) _logString.
format(
4042 this->m_objName.toChar(),
4044 "CS_NoSequenceActive " 4064 this->timeCaller_out(0, _logTime);
4074 #if FW_AMPCS_COMPATIBLE 4079 static_cast<FwAssertArgType>(_status)
4089 static_cast<FwAssertArgType>(_status)
4102 #if FW_ENABLE_TEXT_LOGGING 4103 if (this->isConnected_LogText_OutputPort(0)) {
4104 #if FW_OBJECT_NAMES == 1 4105 const char* _formatString =
4106 "(%s) %s: Sequence %s is valid.";
4108 const char* _formatString =
4109 "%s: Sequence %s is valid.";
4113 (void) _logString.
format(
4116 this->m_objName.toChar(),
4118 "CS_SequenceValid ",
4142 this->timeCaller_out(0, _logTime);
4152 #if FW_AMPCS_COMPATIBLE 4157 static_cast<FwAssertArgType>(_status)
4167 static_cast<FwAssertArgType>(_status)
4170 #if FW_AMPCS_COMPATIBLE 4173 static_cast<U8>(
sizeof(U32))
4177 static_cast<FwAssertArgType>(_status)
4183 static_cast<FwAssertArgType>(_status)
4196 #if FW_ENABLE_TEXT_LOGGING 4197 if (this->isConnected_LogText_OutputPort(0)) {
4198 #if FW_OBJECT_NAMES == 1 4199 const char* _formatString =
4200 "(%s) %s: Sequence %s timed out on command %" PRIu32
"";
4202 const char* _formatString =
4203 "%s: Sequence %s timed out on command %" PRIu32
"";
4207 (void) _logString.
format(
4210 this->m_objName.toChar(),
4212 "CS_SequenceTimeout ",
4237 this->timeCaller_out(0, _logTime);
4247 #if FW_AMPCS_COMPATIBLE 4252 static_cast<FwAssertArgType>(_status)
4262 static_cast<FwAssertArgType>(_status)
4265 #if FW_AMPCS_COMPATIBLE 4268 static_cast<U8>(
sizeof(U32))
4272 static_cast<FwAssertArgType>(_status)
4278 static_cast<FwAssertArgType>(_status)
4291 #if FW_ENABLE_TEXT_LOGGING 4292 if (this->isConnected_LogText_OutputPort(0)) {
4293 #if FW_OBJECT_NAMES == 1 4294 const char* _formatString =
4295 "(%s) %s: Sequence %s command %" PRIu32
" stepped";
4297 const char* _formatString =
4298 "%s: Sequence %s command %" PRIu32
" stepped";
4302 (void) _logString.
format(
4305 this->m_objName.toChar(),
4329 this->timeCaller_out(0, _logTime);
4339 #if FW_AMPCS_COMPATIBLE 4344 static_cast<FwAssertArgType>(_status)
4354 static_cast<FwAssertArgType>(_status)
4367 #if FW_ENABLE_TEXT_LOGGING 4368 if (this->isConnected_LogText_OutputPort(0)) {
4369 #if FW_OBJECT_NAMES == 1 4370 const char* _formatString =
4371 "(%s) %s: Sequence %s started";
4373 const char* _formatString =
4374 "%s: Sequence %s started";
4378 (void) _logString.
format(
4381 this->m_objName.toChar(),
4408 this->timeCaller_out(0, _logTime);
4418 #if FW_AMPCS_COMPATIBLE 4423 static_cast<FwAssertArgType>(_status)
4433 static_cast<FwAssertArgType>(_status)
4436 #if FW_AMPCS_COMPATIBLE 4439 static_cast<U8>(
sizeof(U32))
4443 static_cast<FwAssertArgType>(_status)
4449 static_cast<FwAssertArgType>(_status)
4452 #if FW_AMPCS_COMPATIBLE 4459 static_cast<FwAssertArgType>(_status)
4465 static_cast<FwAssertArgType>(_status)
4478 #if FW_ENABLE_TEXT_LOGGING 4479 if (this->isConnected_LogText_OutputPort(0)) {
4480 #if FW_OBJECT_NAMES == 1 4481 const char* _formatString =
4482 "(%s) %s: Start waiting for sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") to complete";
4484 const char* _formatString =
4485 "%s: Start waiting for sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") to complete";
4489 (void) _logString.
format(
4492 this->m_objName.toChar(),
4517 this->timeCaller_out(0, _logTime);
4526 #if FW_AMPCS_COMPATIBLE 4532 static_cast<FwAssertArgType>(_status)
4546 #if FW_ENABLE_TEXT_LOGGING 4547 if (this->isConnected_LogText_OutputPort(0)) {
4548 #if FW_OBJECT_NAMES == 1 4549 const char* _formatString =
4550 "(%s) %s: Still waiting for sequence file to complete";
4552 const char* _formatString =
4553 "%s: Still waiting for sequence file to complete";
4557 (void) _logString.
format(
4560 this->m_objName.toChar(),
4562 "CS_JoinWaitingNotComplete " 4582 this->timeCaller_out(0, _logTime);
4592 #if FW_AMPCS_COMPATIBLE 4597 static_cast<FwAssertArgType>(_status)
4607 static_cast<FwAssertArgType>(_status)
4620 #if FW_ENABLE_TEXT_LOGGING 4621 if (this->isConnected_LogText_OutputPort(0)) {
4622 #if FW_OBJECT_NAMES == 1 4623 const char* _formatString =
4624 "(%s) %s: Sequence file %s has no records. Ignoring.";
4626 const char* _formatString =
4627 "%s: Sequence file %s has no records. Ignoring.";
4631 (void) _logString.
format(
4634 this->m_objName.toChar(),
4661 this->timeCaller_out(0, _logTime);
4671 #if FW_AMPCS_COMPATIBLE 4676 static_cast<FwAssertArgType>(_status)
4686 static_cast<FwAssertArgType>(_status)
4689 #if FW_AMPCS_COMPATIBLE 4692 static_cast<U8>(
sizeof(U32))
4696 static_cast<FwAssertArgType>(_status)
4702 static_cast<FwAssertArgType>(_status)
4705 #if FW_AMPCS_COMPATIBLE 4708 static_cast<U8>(
sizeof(U32))
4712 static_cast<FwAssertArgType>(_status)
4718 static_cast<FwAssertArgType>(_status)
4731 #if FW_ENABLE_TEXT_LOGGING 4732 if (this->isConnected_LogText_OutputPort(0)) {
4733 #if FW_OBJECT_NAMES == 1 4734 const char* _formatString =
4735 "(%s) %s: Sequence %s: step rejected, previous command pending until %" PRIu32
" s %" PRIu32
" us";
4737 const char* _formatString =
4738 "%s: Sequence %s: step rejected, previous command pending until %" PRIu32
" s %" PRIu32
" us";
4742 (void) _logString.
format(
4745 this->m_objName.toChar(),
4747 "CS_StepRecordPending ",
4773 this->timeCaller_out(0, _logTime);
4783 #if FW_AMPCS_COMPATIBLE 4788 static_cast<FwAssertArgType>(_status)
4798 static_cast<FwAssertArgType>(_status)
4807 static_cast<FwAssertArgType>(_status)
4820 #if FW_ENABLE_TEXT_LOGGING 4821 if (this->isConnected_LogText_OutputPort(0)) {
4822 #if FW_OBJECT_NAMES == 1 4823 const char* _formatString =
4824 "(%s) %s: Sequence file %s is outside the configured sandbox directory %s";
4826 const char* _formatString =
4827 "%s: Sequence file %s is outside the configured sandbox directory %s";
4831 (void) _logString.
format(
4834 this->m_objName.toChar(),
4836 "CS_FileOutsideSandbox ",
4868 this->timeCaller_out(0, _tlmTime);
4898 static_cast<FwAssertArgType>(_stat)
4920 static_cast<FwAssertArgType>(_stat)
4942 static_cast<FwAssertArgType>(_stat)
4964 static_cast<FwAssertArgType>(_stat)
4986 static_cast<FwAssertArgType>(_stat)
5004 if (not this->m_first_update_CS_CurrentSequence) {
5006 if (arg == this->m_last_CS_CurrentSequence) {
5010 this->m_last_CS_CurrentSequence = arg;
5014 this->m_first_update_CS_CurrentSequence =
false;
5015 this->m_last_CS_CurrentSequence = arg;
5026 static_cast<FwAssertArgType>(_stat)
5046 this->timeCaller_out(0, _time);
5061 ComponentIpcSerializableBuffer _msg;
5071 static_cast<FwAssertArgType>(_msgStatus)
5081 static_cast<FwAssertArgType>(_deserStatus)
5084 MsgTypeEnum _msgType =
static_cast<MsgTypeEnum
>(_desMsg);
5086 if (_msgType == CMDSEQUENCER_COMPONENT_EXIT) {
5091 _deserStatus = _msg.deserializeTo(portNum);
5094 static_cast<FwAssertArgType>(_deserStatus)
5099 case CMDRESPONSEIN_CMDRESPONSE: {
5102 _deserStatus = _msg.deserializeTo(opCode);
5105 static_cast<FwAssertArgType>(_deserStatus)
5110 _deserStatus = _msg.deserializeTo(cmdSeq);
5113 static_cast<FwAssertArgType>(_deserStatus)
5118 _deserStatus = _msg.deserializeTo(response);
5121 static_cast<FwAssertArgType>(_deserStatus)
5138 _deserStatus = _msg.deserializeTo(key);
5141 static_cast<FwAssertArgType>(_deserStatus)
5153 case SCHEDIN_SCHED: {
5156 _deserStatus = _msg.deserializeTo(context);
5159 static_cast<FwAssertArgType>(_deserStatus)
5171 case SEQCANCELIN_CMDSEQCANCEL: {
5179 case SEQDISPATCHIN_FILEDISPATCH: {
5182 Fw::ExternalString file_name(__fprime_ac_file_name_buffer,
sizeof __fprime_ac_file_name_buffer);
5183 _deserStatus = _msg.deserializeTo(file_name);
5186 static_cast<FwAssertArgType>(_deserStatus)
5198 case SEQRUNIN_CMDSEQIN: {
5201 Fw::ExternalString filename(__fprime_ac_filename_buffer,
sizeof __fprime_ac_filename_buffer);
5202 _deserStatus = _msg.deserializeTo(filename);
5205 static_cast<FwAssertArgType>(_deserStatus)
5210 _deserStatus = _msg.deserializeTo(args);
5213 static_cast<FwAssertArgType>(_deserStatus)
5229 _deserStatus = _msg.deserializeTo(_opCode);
5232 static_cast<FwAssertArgType>(_deserStatus)
5237 _deserStatus = _msg.deserializeTo(_cmdSeq);
5240 static_cast<FwAssertArgType>(_deserStatus)
5245 _deserStatus = _msg.deserializeTo(args);
5248 static_cast<FwAssertArgType>(_deserStatus)
5286 #if FW_CMD_CHECK_RESIDUAL 5307 case CMD_CS_VALIDATE: {
5310 _deserStatus = _msg.deserializeTo(_opCode);
5313 static_cast<FwAssertArgType>(_deserStatus)
5318 _deserStatus = _msg.deserializeTo(_cmdSeq);
5321 static_cast<FwAssertArgType>(_deserStatus)
5326 _deserStatus = _msg.deserializeTo(args);
5329 static_cast<FwAssertArgType>(_deserStatus)
5352 #if FW_CMD_CHECK_RESIDUAL 5372 case CMD_CS_CANCEL: {
5375 _deserStatus = _msg.deserializeTo(_opCode);
5378 static_cast<FwAssertArgType>(_deserStatus)
5383 _deserStatus = _msg.deserializeTo(_cmdSeq);
5386 static_cast<FwAssertArgType>(_deserStatus)
5391 _deserStatus = _msg.deserializeTo(args);
5394 static_cast<FwAssertArgType>(_deserStatus)
5402 #if FW_CMD_CHECK_RESIDUAL 5419 case CMD_CS_START: {
5422 _deserStatus = _msg.deserializeTo(_opCode);
5425 static_cast<FwAssertArgType>(_deserStatus)
5430 _deserStatus = _msg.deserializeTo(_cmdSeq);
5433 static_cast<FwAssertArgType>(_deserStatus)
5438 _deserStatus = _msg.deserializeTo(args);
5441 static_cast<FwAssertArgType>(_deserStatus)
5449 #if FW_CMD_CHECK_RESIDUAL 5469 _deserStatus = _msg.deserializeTo(_opCode);
5472 static_cast<FwAssertArgType>(_deserStatus)
5477 _deserStatus = _msg.deserializeTo(_cmdSeq);
5480 static_cast<FwAssertArgType>(_deserStatus)
5485 _deserStatus = _msg.deserializeTo(args);
5488 static_cast<FwAssertArgType>(_deserStatus)
5496 #if FW_CMD_CHECK_RESIDUAL 5516 _deserStatus = _msg.deserializeTo(_opCode);
5519 static_cast<FwAssertArgType>(_deserStatus)
5524 _deserStatus = _msg.deserializeTo(_cmdSeq);
5527 static_cast<FwAssertArgType>(_deserStatus)
5532 _deserStatus = _msg.deserializeTo(args);
5535 static_cast<FwAssertArgType>(_deserStatus)
5543 #if FW_CMD_CHECK_RESIDUAL 5560 case CMD_CS_MANUAL: {
5563 _deserStatus = _msg.deserializeTo(_opCode);
5566 static_cast<FwAssertArgType>(_deserStatus)
5571 _deserStatus = _msg.deserializeTo(_cmdSeq);
5574 static_cast<FwAssertArgType>(_deserStatus)
5579 _deserStatus = _msg.deserializeTo(args);
5582 static_cast<FwAssertArgType>(_deserStatus)
5590 #if FW_CMD_CHECK_RESIDUAL 5607 case CMD_CS_JOIN_WAIT: {
5610 _deserStatus = _msg.deserializeTo(_opCode);
5613 static_cast<FwAssertArgType>(_deserStatus)
5618 _deserStatus = _msg.deserializeTo(_cmdSeq);
5621 static_cast<FwAssertArgType>(_deserStatus)
5626 _deserStatus = _msg.deserializeTo(args);
5629 static_cast<FwAssertArgType>(_deserStatus)
5637 #if FW_CMD_CHECK_RESIDUAL 5664 void CmdSequencerComponentBase ::
5675 compPtr->cmdIn_handlerBase(
5687 void CmdSequencerComponentBase ::
5688 m_p_cmdResponseIn_in(
5698 compPtr->cmdResponseIn_handlerBase(
5706 void CmdSequencerComponentBase ::
5715 compPtr->pingIn_handlerBase(
5721 void CmdSequencerComponentBase ::
5730 compPtr->schedIn_handlerBase(
5736 void CmdSequencerComponentBase ::
5744 compPtr->seqCancelIn_handlerBase(portNum);
5747 void CmdSequencerComponentBase ::
5748 m_p_seqDispatchIn_in(
5756 compPtr->seqDispatchIn_handlerBase(
5762 void CmdSequencerComponentBase ::
5772 compPtr->seqRunIn_handlerBase(
5779 #if !FW_DIRECT_PORT_CALLS 5785 #if FW_ENABLE_TEXT_LOGGING 5787 void CmdSequencerComponentBase ::
5797 (0 <= portNum) && (portNum < this->getNum_LogText_OutputPorts()),
5798 static_cast<FwAssertArgType>(portNum)
5802 this->m_LogText_OutputPort[portNum].isConnected(),
5803 static_cast<FwAssertArgType>(portNum)
5805 this->m_LogText_OutputPort[portNum].invoke(
5815 void CmdSequencerComponentBase ::
5823 static_cast<FwAssertArgType>(portNum)
5827 this->m_cmdRegOut_OutputPort[portNum].isConnected(),
5828 static_cast<FwAssertArgType>(portNum)
5830 this->m_cmdRegOut_OutputPort[portNum].
invoke(
5835 void CmdSequencerComponentBase ::
5845 static_cast<FwAssertArgType>(portNum)
5849 this->m_cmdResponseOut_OutputPort[portNum].isConnected(),
5850 static_cast<FwAssertArgType>(portNum)
5852 this->m_cmdResponseOut_OutputPort[portNum].
invoke(
5859 void CmdSequencerComponentBase ::
5870 static_cast<FwAssertArgType>(portNum)
5874 this->m_logOut_OutputPort[portNum].isConnected(),
5875 static_cast<FwAssertArgType>(portNum)
5877 this->m_logOut_OutputPort[portNum].
invoke(
5885 void CmdSequencerComponentBase ::
5893 static_cast<FwAssertArgType>(portNum)
5897 this->m_timeCaller_OutputPort[portNum].isConnected(),
5898 static_cast<FwAssertArgType>(portNum)
5900 this->m_timeCaller_OutputPort[portNum].
invoke(
5905 void CmdSequencerComponentBase ::
5915 static_cast<FwAssertArgType>(portNum)
5919 this->m_tlmOut_OutputPort[portNum].isConnected(),
5920 static_cast<FwAssertArgType>(portNum)
5922 this->m_tlmOut_OutputPort[portNum].
invoke(
void set_timeCaller_OutputPort(FwIndexType portNum, Fw::InputTimePort *port)
Connect port to timeCaller[portNum].
static constexpr FwIndexType getNum_cmdIn_InputPorts()
Serialization/Deserialization operation was successful.
void log_WARNING_HI_CS_TimeContextMismatch(const Fw::StringBase &fileName, U8 currTimeBase, U8 seqTimeBase) const
The Command Sequencer received a command that was invalid for its current mode.
static constexpr FwIndexType getNum_tlmOut_OutputPorts()
void set_tlmOut_OutputPort(FwIndexType portNum, Fw::InputTlmPort *port)
Connect port to tlmOut[portNum].
void addCallPort(InputTimePort *callPort)
Register an input port.
Channel ID for CS_Errors.
void tlmWrite_CS_LoadCommands(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
void invoke(Fw::ComBuffer &data, U32 context) const
Invoke a port connection.
void log_WARNING_HI_CS_InvalidMode() const
void init()
Initialization function.
static constexpr FwSizeType CAPACITY
void invoke(const Fw::StringBase &filename, const Svc::SeqArgs &args) const
Invoke a port connection.
static constexpr FwIndexType getNum_cmdResponseIn_InputPorts()
virtual void seqRunIn_handler(FwIndexType portNum, const Fw::StringBase &filename, const Svc::SeqArgs &args)=0
Handler for input port seqRunIn.
static constexpr FwIndexType getNum_timeCaller_OutputPorts()
static constexpr FwIndexType getNum_cmdResponseOut_OutputPorts()
FwIdType FwOpcodeType
The type of a command opcode.
static constexpr FwIndexType getNum_logOut_OutputPorts()
virtual void seqDispatchIn_handler(FwIndexType portNum, Fw::StringBase &file_name)=0
Handler for input port seqDispatchIn.
void log_WARNING_HI_CS_FileSizeError(const Fw::StringBase &fileName, U32 size) const
void log_WARNING_HI_CS_FileInvalid(const Fw::StringBase &fileName, const Svc::CmdSequencer_FileReadStage &stage, I32 error) const
bool isConnected_cmdResponseOut_OutputPort(FwIndexType portNum) const
static constexpr FwSizeType CAPACITY
void cmdResponseIn_handlerBase(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Handler base-class function for input port cmdResponseIn.
Validate a command sequence file.
FwIdType getIdBase() const
Cannot run new sequence when current sequence file is still running.
PlatformSizeType FwSizeType
Status receive(U8 *destination, FwSizeType capacity, BlockingType blockType, FwSizeType &actualSize, FwQueuePriorityType &priority) override
receive a message from the queue through delegate
void tlmWrite_CS_Errors(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
void log_WARNING_HI_CS_FileNotFound(const Fw::StringBase &fileName) const
void CS_VALIDATE_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
static constexpr FwIndexType getNum_seqDispatchIn_InputPorts()
void log_ACTIVITY_HI_CS_JoinWaiting(const Fw::StringBase &filename, U32 recordNumber, FwOpcodeType opCode) const
Status
status returned from the queue send function
void log_WARNING_HI_CS_JoinWaitingNotComplete() const
A sequence passed validation.
void CS_MANUAL_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Svc::InputPingPort * get_pingIn_InputPort(FwIndexType portNum)
void regCommands()
Register commands with the Command Dispatcher.
BYTE pingInPortSize[Svc::PingPortBuffer::CAPACITY]
void init()
Initialization function.
Start running a command sequence.
SerializeStatus deserializeTo(U8 &val, Endianness mode=Endianness::BIG) override
Deserialize an 8-bit unsigned integer value.
The Command Sequencer issued a command and received a success status in return.
virtual void schedIn_preMsgHook(FwIndexType portNum, U32 context)
Pre-message hook for async input port schedIn.
void log_WARNING_HI_CS_UnexpectedCompletion(FwOpcodeType opcode) const
virtual void CS_AUTO_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_AUTO.
Channel ID for CS_SequencesCompleted.
The stage of the file read operation.
void log_ACTIVITY_LO_CS_SequenceLoaded(const Fw::StringBase &fileName) const
The Command Sequencer issued a command and received an error status in return.
void CS_STEP_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
void invoke(U32 key) const
Invoke a port connection.
Run a command sequence file.
static constexpr FwIndexType getNum_seqRunIn_InputPorts()
virtual const CHAR * toChar() const =0
Convert to a C-style char*.
static constexpr FwIndexType getNum_schedIn_InputPorts()
void tlmWrite_CS_CurrentSequence(const Fw::StringBase &arg, Fw::Time _tlmTime=Fw::Time())
void log_ACTIVITY_HI_CS_CmdStarted(const Fw::StringBase &filename) const
virtual void CS_VALIDATE_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &fileName)=0
Fw::InputCmdResponsePort * get_cmdResponseIn_InputPort(FwIndexType portNum)
static constexpr FwIndexType getNum_seqDone_OutputPorts()
virtual void seqCancelIn_handler(FwIndexType portNum)=0
Handler for input port seqCancelIn.
void set_pingOut_OutputPort(FwIndexType portNum, Svc::InputPingPort *port)
Connect port to pingOut[portNum].
void pingIn_handlerBase(FwIndexType portNum, U32 key)
Handler base-class function for input port pingIn.
void init()
Initialization function.
Enum representing a command response.
The sequence file was not found.
void schedIn_handlerBase(FwIndexType portNum, U32 context)
Handler base-class function for input port schedIn.
No time base has been established (Required)
A command sequence was successfully canceled.
SerializeStatus serializeFrom(U8 val, Endianness mode=Endianness::BIG) override
Serialize an 8-bit unsigned integer value.
void addCallPort(InputCmdRegPort *callPort)
Register an input port.
bool isConnected_seqDone_OutputPort(FwIndexType portNum) const
The sequence file format was invalid.
void log_WARNING_LO_CS_NoSequenceActive() const
void CS_START_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
void log_WARNING_HI_CS_SequenceTimeout(const Fw::StringBase &filename, U32 command) const
bool isConnected_seqStartOut_OutputPort(FwIndexType portNum) const
virtual void CS_CANCEL_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_CANCEL.
Os::Queue m_queue
queue object for active component
Channel ID for CS_LoadCommands.
void addCallPort(InputTlmPort *callPort)
Register an input port.
void init()
Object initializer.
void cmdIn_handlerBase(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Handler base-class function for input port cmdIn.
message to exit active component task
SerializeStatus
forward declaration for string
void set_seqDone_OutputPort(FwIndexType portNum, Fw::InputCmdResponsePort *port)
Connect port to seqDone[portNum].
Message will block until space is available.
Number of records in header doesn't match number in file.
virtual void CS_RUN_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_RUN.
void tlmWrite_CS_CancelCommands(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
FwIdType FwEventIdType
The type of an event identifier.
virtual ~CmdSequencerComponentBase()
Destroy CmdSequencerComponentBase object.
void tlmWrite_CS_CommandsExecuted(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
A sequence file name resolved outside the directory set with configureSandbox.
A sequence passed validation.
void invoke(FwOpcodeType opCode) const
Invoke a port connection.
static constexpr FwIndexType getNum_pingOut_OutputPorts()
static constexpr FwSizeType CAPACITY
void log_ACTIVITY_HI_CS_PortSequenceStarted(const Fw::StringBase &filename) const
A sequence related command came with no active sequence.
void seqStartOut_out(FwIndexType portNum, const Fw::StringBase &filename, const Svc::SeqArgs &args) const
Invoke output port seqStartOut.
A manual sequence was started.
void log_WARNING_HI_CS_RecordInvalid(const Fw::StringBase &fileName, U32 recordNumber, I32 error) const
void log_ACTIVITY_HI_CS_SequenceCanceled(const Fw::StringBase &fileName) const
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects) ...
Channel ID for CS_CurrentSequence.
void init()
Initialization function.
bool isConnected_logOut_OutputPort(FwIndexType portNum) const
Set the run mode to AUTO.
Less important informational events.
Os::Queue::Status createQueue(FwSizeType depth, FwSizeType msgSize)
void log_WARNING_HI_CS_RecordMismatch(const Fw::StringBase &fileName, U32 header_records, U32 extra_bytes) const
bool isConnected_cmdRegOut_OutputPort(FwIndexType portNum) const
#define FW_MIN(a, b)
MIN macro (deprecated in C++, use std::min)
A less serious but recoverable event.
virtual void CS_RUN_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &fileName, const Svc::BlockState &block)=0
void init()
Initialization function.
virtual void cmdResponseIn_preMsgHook(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Pre-message hook for async input port cmdResponseIn.
void invoke(Fw::Time &time) const
Invoke a port connection.
void CS_JOIN_WAIT_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Svc::InputCmdSeqInPort * get_seqRunIn_InputPort(FwIndexType portNum)
void seqRunIn_handlerBase(FwIndexType portNum, const Fw::StringBase &filename, const Svc::SeqArgs &args)
Handler base-class function for input port seqRunIn.
Serializable::SizeType getDeserializeSizeLeft() const override
Get remaining deserialization buffer size.
void invoke(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response) const
Invoke a port connection.
void set_cmdResponseOut_OutputPort(FwIndexType portNum, Fw::InputCmdResponsePort *port)
Connect port to cmdResponseOut[portNum].
FwIdType FwChanIdType
The type of a telemetry channel identifier.
void set_cmdRegOut_OutputPort(FwIndexType portNum, Fw::InputCmdRegPort *port)
Connect port to cmdRegOut[portNum].
virtual void CS_START_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
void addCallPort(InputPingPort *callPort)
Register an input port.
Status send(const U8 *buffer, FwSizeType size, FwQueuePriorityType priority, BlockingType blockType) override
send a message into the queue through delegate
Sequencer blocking state.
void resetDeser() override
Reset deserialization pointer to beginning of buffer.
static constexpr FwIndexType getNum_cmdRegOut_OutputPorts()
The format of a command record was invalid.
A string backed by an external buffer.
void log_ACTIVITY_HI_CS_ModeSwitched(const Svc::CmdSequencer_SeqMode &mode) const
A serious but recoverable event.
Errors dispatching messages.
A command in a sequence was stepped through.
Set the run mode to MANUAL.
void invoke(FwChanIdType id, Fw::Time &timeTag, Fw::TlmBuffer &val) const
Invoke a port connection.
const char * toChar() const
Convert to a C-style char*.
Enum representing event severity.
void CS_AUTO_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
virtual void CS_START_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_START.
FormatStatus format(const CHAR *formatString,...)
write formatted string to buffer
void init()
Initialization function.
uint8_t U8
8-bit unsigned integer
void set_comCmdOut_OutputPort(FwIndexType portNum, Fw::InputComPort *port)
Connect port to comCmdOut[portNum].
static constexpr FwIndexType getNum_seqStartOut_OutputPorts()
static constexpr FwSizeType CAPACITY
virtual void pingIn_preMsgHook(FwIndexType portNum, U32 key)
Pre-message hook for async input port pingIn.
Svc::InputSchedPort * get_schedIn_InputPort(FwIndexType portNum)
virtual void CS_AUTO_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
Wait for the current running sequence file complete.
Command failed to deserialize.
The running time base doesn't match the time base in the sequence files.
PlatformQueuePriorityType FwQueuePriorityType
The type of queue priorities used.
void log_WARNING_HI_CS_FileCrcFailure(const Fw::StringBase &fileName, U32 storedCRC, U32 computedCRC) const
Important informational events.
A command sequence successfully completed.
void invoke(FwEventIdType id, Fw::Time &timeTag, const Fw::LogSeverity &severity, Fw::LogBuffer &args) const
Invoke a port connection.
void log_WARNING_HI_CS_FileOutsideSandbox(const Fw::StringBase &fileName, const Fw::StringBase &sandboxDir) const
bool isConnected_timeCaller_OutputPort(FwIndexType portNum) const
virtual void CS_MANUAL_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_MANUAL.
bool isConnected_pingOut_OutputPort(FwIndexType portNum) const
void CS_CANCEL_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
void set_seqStartOut_OutputPort(FwIndexType portNum, Svc::InputCmdSeqInPort *port)
Connect port to seqStartOut[portNum].
void log_WARNING_HI_CS_TimeBaseMismatch(const Fw::StringBase &fileName, U16 time_base, U16 seq_time_base) const
A message was sent requesting an exit of the loop.
void tlmWrite(FwChanIdType id, Fw::TlmBuffer &_tlmBuff, Fw::Time _tlmTime=Fw::Time()) const
Channel ID for CS_CancelCommands.
virtual void CS_STEP_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_STEP.
PlatformIndexType FwIndexType
Fw::InputCmdPort * get_cmdIn_InputPort(FwIndexType portNum)
The sequence file contains no command records.
virtual void seqRunIn_preMsgHook(FwIndexType portNum, const Fw::StringBase &filename, const Svc::SeqArgs &args)
Pre-message hook for async input port seqRunIn.
Wait for sequences that are running to finish. Allow user to run multiple seq files in SEQ_NO_BLOCK m...
Perform one step in a command sequence. Valid only if CmdSequencer is in MANUAL run mode...
void seqCancelIn_handlerBase(FwIndexType portNum)
Handler base-class function for input port seqCancelIn.
void addCallPort(InputLogPort *callPort)
Register an input port.
void addCallPort(InputCmdSeqInPort *callPort)
Register an input port.
Cancel a command sequence.
void init()
Initialization function.
A local port request to run a sequence was started.
void incNumMsgDropped()
increment the number of messages dropped
void CS_RUN_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
The Sequence File Loader could not read the sequence file.
Svc::InputFileDispatchPort * get_seqDispatchIn_InputPort(FwIndexType portNum)
void comCmdOut_out(FwIndexType portNum, Fw::ComBuffer &data, U32 context) const
Invoke output port comCmdOut.
static constexpr FwIndexType getNum_seqCancelIn_InputPorts()
virtual void pingIn_handler(FwIndexType portNum, U32 key)=0
Handler for input port pingIn.
RateGroupDivider component implementation.
virtual void CS_VALIDATE_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_VALIDATE.
void log_ACTIVITY_HI_CS_SequenceComplete(const Fw::StringBase &fileName) const
virtual void CS_STEP_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
void seqDone_out(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response) const
Invoke output port seqDone.
void log_WARNING_LO_CS_StepRecordPending(const Fw::StringBase &fileName, U32 seconds, U32 useconds) const
void log_ACTIVITY_LO_CS_CommandComplete(const Fw::StringBase &fileName, U32 recordNumber, FwOpcodeType opCode) const
message sent/received okay
The sequence file was too large.
The sequence file validation failed.
void addCallPort(InputComPort *callPort)
Register an input port.
virtual void CS_MANUAL_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
CmdSequencerComponentBase(const char *compName="")
Construct CmdSequencerComponentBase object.
A command status came back when no sequence was running.
void seqDispatchIn_handlerBase(FwIndexType portNum, Fw::StringBase &file_name)
Handler base-class function for input port seqDispatchIn.
Sequence file was successfully loaded.
Channel ID for CS_CommandsExecuted.
Message will return with status when space is unavailable.
Implementation of malloc based allocator.
static constexpr FwSizeType CAPACITY
static constexpr FwIndexType getNum_pingIn_InputPorts()
virtual void cmdResponseIn_handler(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)=0
Handler for input port cmdResponseIn.
void log_WARNING_LO_CS_NoRecords(const Fw::StringBase &fileName) const
virtual void CS_JOIN_WAIT_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
virtual void seqCancelIn_preMsgHook(FwIndexType portNum)
Pre-message hook for async input port seqCancelIn.
virtual void schedIn_handler(FwIndexType portNum, U32 context)=0
Handler for input port schedIn.
static constexpr SizeType BUFFER_SIZE(SizeType maxLength)
Get the size of a null-terminated string buffer.
void log_WARNING_HI_CS_CommandError(const Fw::StringBase &fileName, U32 recordNumber, FwOpcodeType opCode, U32 errorStatus) const
void init()
Initialization function.
virtual void CS_CANCEL_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
void set_logOut_OutputPort(FwIndexType portNum, Fw::InputLogPort *port)
Connect port to logOut[portNum].
static constexpr FwIndexType getNum_comCmdOut_OutputPorts()
Svc::InputCmdSeqCancelPort * get_seqCancelIn_InputPort(FwIndexType portNum)
bool isConnected_tlmOut_OutputPort(FwIndexType portNum) const
void pingOut_out(FwIndexType portNum, U32 key) const
Invoke output port pingOut.
static constexpr FwSizeType CAPACITY
virtual void seqDispatchIn_preMsgHook(FwIndexType portNum, Fw::StringBase &file_name)
Pre-message hook for async input port seqDispatchIn.
bool isConnected_comCmdOut_OutputPort(FwIndexType portNum) const
void log_ACTIVITY_HI_CS_SequenceValid(const Fw::StringBase &filename) const
The size of the serial representation.
void log_WARNING_HI_CS_FileReadError(const Fw::StringBase &fileName) const
void cmdResponse_out(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdResponse response)
Emit command response.
void addCallPort(InputCmdResponsePort *callPort)
Register an input port.
void tlmWrite_CS_SequencesCompleted(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
The size of the serial representation.
void log_ACTIVITY_HI_CS_CmdStepped(const Fw::StringBase &filename, U32 command) const
SerializeStatus serializeTo(SerialBufferBase &buffer, Endianness mode=Endianness::BIG) const override
Serialize the contents of this object to a buffer.
The running time base doesn't match the time base in the sequence files.
BYTE cmdPortSize[Fw::CmdPortBuffer::CAPACITY]
virtual void CS_JOIN_WAIT_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_JOIN_WAIT.