10 #if FW_ENABLE_TEXT_LOGGING 19 CMDRESPONSEIN_CMDRESPONSE,
22 SEQCANCELIN_CMDSEQCANCEL,
46 class ComponentIpcSerializableBuffer :
56 MAX_DATA_SIZE =
sizeof(BuffUnion),
58 SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE
62 return sizeof(m_buff);
69 const U8* getBuffAddr()
const {
75 U8 m_buff[SERIALIZATION_SIZE];
99 this->m_cmdIn_InputPort[port].
init();
104 this->m_cmdIn_InputPort[port].
setPortNum(port);
106 #if FW_OBJECT_NAMES == 1 110 this->m_objName.toChar(),
113 this->m_cmdIn_InputPort[port].setObjName(portName.
toChar());
123 this->m_cmdResponseIn_InputPort[port].
init();
128 this->m_cmdResponseIn_InputPort[port].
setPortNum(port);
130 #if FW_OBJECT_NAMES == 1 134 this->m_objName.toChar(),
137 this->m_cmdResponseIn_InputPort[port].setObjName(portName.
toChar());
147 this->m_pingIn_InputPort[port].
init();
152 this->m_pingIn_InputPort[port].
setPortNum(port);
154 #if FW_OBJECT_NAMES == 1 158 this->m_objName.toChar(),
161 this->m_pingIn_InputPort[port].setObjName(portName.
toChar());
171 this->m_schedIn_InputPort[port].
init();
176 this->m_schedIn_InputPort[port].
setPortNum(port);
178 #if FW_OBJECT_NAMES == 1 182 this->m_objName.toChar(),
185 this->m_schedIn_InputPort[port].setObjName(portName.
toChar());
195 this->m_seqCancelIn_InputPort[port].
init();
200 this->m_seqCancelIn_InputPort[port].
setPortNum(port);
202 #if FW_OBJECT_NAMES == 1 206 this->m_objName.toChar(),
209 this->m_seqCancelIn_InputPort[port].setObjName(portName.
toChar());
219 this->m_seqRunIn_InputPort[port].
init();
224 this->m_seqRunIn_InputPort[port].
setPortNum(port);
226 #if FW_OBJECT_NAMES == 1 230 this->m_objName.toChar(),
233 this->m_seqRunIn_InputPort[port].setObjName(portName.
toChar());
237 #if FW_ENABLE_TEXT_LOGGING == 1 241 port < static_cast<FwIndexType>(this->getNum_LogText_OutputPorts());
244 this->m_LogText_OutputPort[port].
init();
246 #if FW_OBJECT_NAMES == 1 250 this->m_objName.toChar(),
253 this->m_LogText_OutputPort[port].setObjName(portName.
toChar());
264 this->m_cmdRegOut_OutputPort[port].
init();
266 #if FW_OBJECT_NAMES == 1 270 this->m_objName.toChar(),
273 this->m_cmdRegOut_OutputPort[port].setObjName(portName.
toChar());
283 this->m_cmdResponseOut_OutputPort[port].
init();
285 #if FW_OBJECT_NAMES == 1 289 this->m_objName.toChar(),
292 this->m_cmdResponseOut_OutputPort[port].setObjName(portName.
toChar());
302 this->m_logOut_OutputPort[port].
init();
304 #if FW_OBJECT_NAMES == 1 308 this->m_objName.toChar(),
311 this->m_logOut_OutputPort[port].setObjName(portName.
toChar());
321 this->m_timeCaller_OutputPort[port].
init();
323 #if FW_OBJECT_NAMES == 1 327 this->m_objName.toChar(),
330 this->m_timeCaller_OutputPort[port].setObjName(portName.
toChar());
340 this->m_tlmOut_OutputPort[port].
init();
342 #if FW_OBJECT_NAMES == 1 346 this->m_objName.toChar(),
349 this->m_tlmOut_OutputPort[port].setObjName(portName.
toChar());
359 this->m_comCmdOut_OutputPort[port].
init();
361 #if FW_OBJECT_NAMES == 1 365 this->m_objName.toChar(),
368 this->m_comCmdOut_OutputPort[port].setObjName(portName.
toChar());
378 this->m_pingOut_OutputPort[port].
init();
380 #if FW_OBJECT_NAMES == 1 384 this->m_objName.toChar(),
387 this->m_pingOut_OutputPort[port].setObjName(portName.
toChar());
397 this->m_seqDone_OutputPort[port].
init();
399 #if FW_OBJECT_NAMES == 1 403 this->m_objName.toChar(),
406 this->m_seqDone_OutputPort[port].setObjName(portName.
toChar());
416 this->m_seqStartOut_OutputPort[port].
init();
418 #if FW_OBJECT_NAMES == 1 422 this->m_objName.toChar(),
425 this->m_seqStartOut_OutputPort[port].setObjName(portName.
toChar());
432 static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
436 static_cast<FwAssertArgType>(qStat)
449 static_cast<FwAssertArgType>(portNum)
452 return &this->m_cmdIn_InputPort[portNum];
464 static_cast<FwAssertArgType>(portNum)
467 return &this->m_cmdResponseIn_InputPort[portNum];
475 static_cast<FwAssertArgType>(portNum)
478 return &this->m_pingIn_InputPort[portNum];
486 static_cast<FwAssertArgType>(portNum)
489 return &this->m_schedIn_InputPort[portNum];
497 static_cast<FwAssertArgType>(portNum)
500 return &this->m_seqCancelIn_InputPort[portNum];
508 static_cast<FwAssertArgType>(portNum)
511 return &this->m_seqRunIn_InputPort[portNum];
518 #if FW_ENABLE_TEXT_LOGGING == 1 520 void CmdSequencerComponentBase ::
521 set_LogText_OutputPort(
527 portNum < this->getNum_LogText_OutputPorts(),
528 static_cast<FwAssertArgType>(portNum)
531 this->m_LogText_OutputPort[portNum].addCallPort(port);
544 static_cast<FwAssertArgType>(portNum)
547 this->m_cmdRegOut_OutputPort[portNum].
addCallPort(port);
558 static_cast<FwAssertArgType>(portNum)
561 this->m_cmdResponseOut_OutputPort[portNum].
addCallPort(port);
572 static_cast<FwAssertArgType>(portNum)
575 this->m_logOut_OutputPort[portNum].
addCallPort(port);
586 static_cast<FwAssertArgType>(portNum)
589 this->m_timeCaller_OutputPort[portNum].
addCallPort(port);
600 static_cast<FwAssertArgType>(portNum)
603 this->m_tlmOut_OutputPort[portNum].
addCallPort(port);
618 static_cast<FwAssertArgType>(portNum)
621 this->m_comCmdOut_OutputPort[portNum].
addCallPort(port);
632 static_cast<FwAssertArgType>(portNum)
635 this->m_pingOut_OutputPort[portNum].
addCallPort(port);
646 static_cast<FwAssertArgType>(portNum)
649 this->m_seqDone_OutputPort[portNum].
addCallPort(port);
660 static_cast<FwAssertArgType>(portNum)
663 this->m_seqStartOut_OutputPort[portNum].
addCallPort(port);
666 #if FW_PORT_SERIALIZATION 672 #if FW_ENABLE_TEXT_LOGGING == 1 674 void CmdSequencerComponentBase ::
675 set_LogText_OutputPort(
677 Fw::InputSerializePort* port
681 portNum < this->getNum_LogText_OutputPorts(),
682 static_cast<FwAssertArgType>(portNum)
685 this->m_LogText_OutputPort[portNum].registerSerialPort(port);
693 Fw::InputSerializePort* port
698 static_cast<FwAssertArgType>(portNum)
701 this->m_cmdRegOut_OutputPort[portNum].registerSerialPort(port);
707 Fw::InputSerializePort* port
712 static_cast<FwAssertArgType>(portNum)
715 this->m_cmdResponseOut_OutputPort[portNum].registerSerialPort(port);
721 Fw::InputSerializePort* port
726 static_cast<FwAssertArgType>(portNum)
729 this->m_logOut_OutputPort[portNum].registerSerialPort(port);
735 Fw::InputSerializePort* port
740 static_cast<FwAssertArgType>(portNum)
743 this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
749 Fw::InputSerializePort* port
754 static_cast<FwAssertArgType>(portNum)
757 this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
762 #if FW_PORT_SERIALIZATION 771 Fw::InputSerializePort* port
776 static_cast<FwAssertArgType>(portNum)
779 this->m_comCmdOut_OutputPort[portNum].registerSerialPort(port);
785 Fw::InputSerializePort* port
790 static_cast<FwAssertArgType>(portNum)
793 this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
799 Fw::InputSerializePort* port
804 static_cast<FwAssertArgType>(portNum)
807 this->m_seqDone_OutputPort[portNum].registerSerialPort(port);
813 Fw::InputSerializePort* port
818 static_cast<FwAssertArgType>(portNum)
821 this->m_seqStartOut_OutputPort[portNum].registerSerialPort(port);
833 FW_ASSERT(this->m_cmdRegOut_OutputPort[0].isConnected());
835 this->m_cmdRegOut_OutputPort[0].
invoke(
839 this->m_cmdRegOut_OutputPort[0].
invoke(
843 this->m_cmdRegOut_OutputPort[0].
invoke(
847 this->m_cmdRegOut_OutputPort[0].
invoke(
851 this->m_cmdRegOut_OutputPort[0].
invoke(
855 this->m_cmdRegOut_OutputPort[0].
invoke(
859 this->m_cmdRegOut_OutputPort[0].
invoke(
863 this->m_cmdRegOut_OutputPort[0].
invoke(
874 Fw::ActiveComponentBase(compName)
933 #if FW_ENABLE_TEXT_LOGGING == 1 936 getNum_LogText_OutputPorts()
const 1005 #if FW_ENABLE_TEXT_LOGGING == 1 1007 bool CmdSequencerComponentBase ::
1008 isConnected_LogText_OutputPort(
FwIndexType portNum)
1011 portNum < this->getNum_LogText_OutputPorts(),
1012 static_cast<FwAssertArgType>(portNum)
1015 return this->m_LogText_OutputPort[portNum].isConnected();
1025 static_cast<FwAssertArgType>(portNum)
1028 return this->m_cmdRegOut_OutputPort[portNum].
isConnected();
1036 static_cast<FwAssertArgType>(portNum)
1039 return this->m_cmdResponseOut_OutputPort[portNum].
isConnected();
1047 static_cast<FwAssertArgType>(portNum)
1050 return this->m_logOut_OutputPort[portNum].
isConnected();
1058 static_cast<FwAssertArgType>(portNum)
1061 return this->m_timeCaller_OutputPort[portNum].
isConnected();
1069 static_cast<FwAssertArgType>(portNum)
1072 return this->m_tlmOut_OutputPort[portNum].
isConnected();
1084 static_cast<FwAssertArgType>(portNum)
1087 return this->m_comCmdOut_OutputPort[portNum].
isConnected();
1095 static_cast<FwAssertArgType>(portNum)
1098 return this->m_pingOut_OutputPort[portNum].
isConnected();
1106 static_cast<FwAssertArgType>(portNum)
1109 return this->m_seqDone_OutputPort[portNum].
isConnected();
1117 static_cast<FwAssertArgType>(portNum)
1120 return this->m_seqStartOut_OutputPort[portNum].
isConnected();
1140 static_cast<FwAssertArgType>(portNum)
1150 ComponentIpcSerializableBuffer msg;
1154 _status = msg.serialize(
1155 static_cast<FwEnumStoreType>(CMDRESPONSEIN_CMDRESPONSE)
1159 static_cast<FwAssertArgType>(_status)
1163 _status = msg.serialize(portNum);
1166 static_cast<FwAssertArgType>(_status)
1170 _status = msg.serialize(opCode);
1173 static_cast<FwAssertArgType>(_status)
1177 _status = msg.serialize(cmdSeq);
1180 static_cast<FwAssertArgType>(_status)
1184 _status = msg.serialize(response);
1187 static_cast<FwAssertArgType>(_status)
1196 static_cast<FwAssertArgType>(qStatus)
1209 static_cast<FwAssertArgType>(portNum)
1217 ComponentIpcSerializableBuffer msg;
1221 _status = msg.serialize(
1222 static_cast<FwEnumStoreType>(PINGIN_PING)
1226 static_cast<FwAssertArgType>(_status)
1230 _status = msg.serialize(portNum);
1233 static_cast<FwAssertArgType>(_status)
1237 _status = msg.serialize(key);
1240 static_cast<FwAssertArgType>(_status)
1249 static_cast<FwAssertArgType>(qStatus)
1262 static_cast<FwAssertArgType>(portNum)
1270 ComponentIpcSerializableBuffer msg;
1274 _status = msg.serialize(
1275 static_cast<FwEnumStoreType>(SCHEDIN_SCHED)
1279 static_cast<FwAssertArgType>(_status)
1283 _status = msg.serialize(portNum);
1286 static_cast<FwAssertArgType>(_status)
1290 _status = msg.serialize(context);
1293 static_cast<FwAssertArgType>(_status)
1302 static_cast<FwAssertArgType>(qStatus)
1312 static_cast<FwAssertArgType>(portNum)
1317 ComponentIpcSerializableBuffer msg;
1321 _status = msg.serialize(
1322 static_cast<FwEnumStoreType>(SEQCANCELIN_CMDSEQCANCEL)
1326 static_cast<FwAssertArgType>(_status)
1330 _status = msg.serialize(portNum);
1333 static_cast<FwAssertArgType>(_status)
1342 static_cast<FwAssertArgType>(qStatus)
1355 static_cast<FwAssertArgType>(portNum)
1363 ComponentIpcSerializableBuffer msg;
1367 _status = msg.serialize(
1368 static_cast<FwEnumStoreType>(SEQRUNIN_CMDSEQIN)
1372 static_cast<FwAssertArgType>(_status)
1376 _status = msg.serialize(portNum);
1379 static_cast<FwAssertArgType>(_status)
1386 static_cast<FwAssertArgType>(_status)
1395 static_cast<FwAssertArgType>(qStatus)
1464 static_cast<FwAssertArgType>(portNum)
1466 this->m_comCmdOut_OutputPort[portNum].
invoke(
1480 static_cast<FwAssertArgType>(portNum)
1482 this->m_pingOut_OutputPort[portNum].
invoke(
1497 static_cast<FwAssertArgType>(portNum)
1499 this->m_seqDone_OutputPort[portNum].
invoke(
1514 static_cast<FwAssertArgType>(portNum)
1516 this->m_seqStartOut_OutputPort[portNum].
invoke(
1532 FW_ASSERT(this->m_cmdResponseOut_OutputPort[0].isConnected());
1533 this->m_cmdResponseOut_OutputPort[0].
invoke(opCode, cmdSeq, response);
1554 ComponentIpcSerializableBuffer msg;
1558 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_RUN));
1561 static_cast<FwAssertArgType>(_status)
1567 _status = msg.serialize(port);
1570 static_cast<FwAssertArgType>(_status)
1573 _status = msg.serialize(opCode);
1576 static_cast<FwAssertArgType>(_status)
1579 _status = msg.serialize(cmdSeq);
1582 static_cast<FwAssertArgType>(_status)
1585 _status = msg.serialize(args);
1588 static_cast<FwAssertArgType>(_status)
1597 static_cast<FwAssertArgType>(qStatus)
1613 ComponentIpcSerializableBuffer msg;
1617 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_VALIDATE));
1620 static_cast<FwAssertArgType>(_status)
1626 _status = msg.serialize(port);
1629 static_cast<FwAssertArgType>(_status)
1632 _status = msg.serialize(opCode);
1635 static_cast<FwAssertArgType>(_status)
1638 _status = msg.serialize(cmdSeq);
1641 static_cast<FwAssertArgType>(_status)
1644 _status = msg.serialize(args);
1647 static_cast<FwAssertArgType>(_status)
1656 static_cast<FwAssertArgType>(qStatus)
1672 ComponentIpcSerializableBuffer msg;
1676 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_CANCEL));
1679 static_cast<FwAssertArgType>(_status)
1685 _status = msg.serialize(port);
1688 static_cast<FwAssertArgType>(_status)
1691 _status = msg.serialize(opCode);
1694 static_cast<FwAssertArgType>(_status)
1697 _status = msg.serialize(cmdSeq);
1700 static_cast<FwAssertArgType>(_status)
1703 _status = msg.serialize(args);
1706 static_cast<FwAssertArgType>(_status)
1715 static_cast<FwAssertArgType>(qStatus)
1731 ComponentIpcSerializableBuffer msg;
1735 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_START));
1738 static_cast<FwAssertArgType>(_status)
1744 _status = msg.serialize(port);
1747 static_cast<FwAssertArgType>(_status)
1750 _status = msg.serialize(opCode);
1753 static_cast<FwAssertArgType>(_status)
1756 _status = msg.serialize(cmdSeq);
1759 static_cast<FwAssertArgType>(_status)
1762 _status = msg.serialize(args);
1765 static_cast<FwAssertArgType>(_status)
1774 static_cast<FwAssertArgType>(qStatus)
1790 ComponentIpcSerializableBuffer msg;
1794 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_STEP));
1797 static_cast<FwAssertArgType>(_status)
1803 _status = msg.serialize(port);
1806 static_cast<FwAssertArgType>(_status)
1809 _status = msg.serialize(opCode);
1812 static_cast<FwAssertArgType>(_status)
1815 _status = msg.serialize(cmdSeq);
1818 static_cast<FwAssertArgType>(_status)
1821 _status = msg.serialize(args);
1824 static_cast<FwAssertArgType>(_status)
1833 static_cast<FwAssertArgType>(qStatus)
1849 ComponentIpcSerializableBuffer msg;
1853 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_AUTO));
1856 static_cast<FwAssertArgType>(_status)
1862 _status = msg.serialize(port);
1865 static_cast<FwAssertArgType>(_status)
1868 _status = msg.serialize(opCode);
1871 static_cast<FwAssertArgType>(_status)
1874 _status = msg.serialize(cmdSeq);
1877 static_cast<FwAssertArgType>(_status)
1880 _status = msg.serialize(args);
1883 static_cast<FwAssertArgType>(_status)
1892 static_cast<FwAssertArgType>(qStatus)
1908 ComponentIpcSerializableBuffer msg;
1912 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_MANUAL));
1915 static_cast<FwAssertArgType>(_status)
1921 _status = msg.serialize(port);
1924 static_cast<FwAssertArgType>(_status)
1927 _status = msg.serialize(opCode);
1930 static_cast<FwAssertArgType>(_status)
1933 _status = msg.serialize(cmdSeq);
1936 static_cast<FwAssertArgType>(_status)
1939 _status = msg.serialize(args);
1942 static_cast<FwAssertArgType>(_status)
1951 static_cast<FwAssertArgType>(qStatus)
1967 ComponentIpcSerializableBuffer msg;
1971 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_JOIN_WAIT));
1974 static_cast<FwAssertArgType>(_status)
1980 _status = msg.serialize(port);
1983 static_cast<FwAssertArgType>(_status)
1986 _status = msg.serialize(opCode);
1989 static_cast<FwAssertArgType>(_status)
1992 _status = msg.serialize(cmdSeq);
1995 static_cast<FwAssertArgType>(_status)
1998 _status = msg.serialize(args);
2001 static_cast<FwAssertArgType>(_status)
2010 static_cast<FwAssertArgType>(qStatus)
2119 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2120 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2128 if (this->m_logOut_OutputPort[0].isConnected()) {
2132 #if FW_AMPCS_COMPATIBLE 2134 _status = _logBuff.
serialize(static_cast<U8>(1));
2137 static_cast<FwAssertArgType>(_status)
2144 static_cast<FwAssertArgType>(_status)
2147 this->m_logOut_OutputPort[0].
invoke(
2156 #if FW_ENABLE_TEXT_LOGGING 2157 if (this->m_LogText_OutputPort[0].isConnected()) {
2158 #if FW_OBJECT_NAMES == 1 2159 const char* _formatString =
2160 "(%s) %s: Loaded sequence %s";
2162 const char* _formatString =
2163 "%s: Loaded sequence %s";
2170 this->m_objName.toChar(),
2172 "CS_SequenceLoaded ",
2176 this->m_LogText_OutputPort[0].invoke(
2191 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2192 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2200 if (this->m_logOut_OutputPort[0].isConnected()) {
2204 #if FW_AMPCS_COMPATIBLE 2206 _status = _logBuff.
serialize(static_cast<U8>(1));
2209 static_cast<FwAssertArgType>(_status)
2216 static_cast<FwAssertArgType>(_status)
2219 this->m_logOut_OutputPort[0].
invoke(
2228 #if FW_ENABLE_TEXT_LOGGING 2229 if (this->m_LogText_OutputPort[0].isConnected()) {
2230 #if FW_OBJECT_NAMES == 1 2231 const char* _formatString =
2232 "(%s) %s: Sequence file %s canceled";
2234 const char* _formatString =
2235 "%s: Sequence file %s canceled";
2242 this->m_objName.toChar(),
2244 "CS_SequenceCanceled ",
2248 this->m_LogText_OutputPort[0].invoke(
2263 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2264 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2272 if (this->m_logOut_OutputPort[0].isConnected()) {
2276 #if FW_AMPCS_COMPATIBLE 2278 _status = _logBuff.
serialize(static_cast<U8>(1));
2281 static_cast<FwAssertArgType>(_status)
2288 static_cast<FwAssertArgType>(_status)
2291 this->m_logOut_OutputPort[0].
invoke(
2300 #if FW_ENABLE_TEXT_LOGGING 2301 if (this->m_LogText_OutputPort[0].isConnected()) {
2302 #if FW_OBJECT_NAMES == 1 2303 const char* _formatString =
2304 "(%s) %s: Error reading sequence file %s";
2306 const char* _formatString =
2307 "%s: Error reading sequence file %s";
2314 this->m_objName.toChar(),
2316 "CS_FileReadError ",
2320 this->m_LogText_OutputPort[0].invoke(
2339 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2340 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2348 if (this->m_logOut_OutputPort[0].isConnected()) {
2352 #if FW_AMPCS_COMPATIBLE 2354 _status = _logBuff.
serialize(static_cast<U8>(3));
2357 static_cast<FwAssertArgType>(_status)
2364 static_cast<FwAssertArgType>(_status)
2367 #if FW_AMPCS_COMPATIBLE 2374 static_cast<FwAssertArgType>(_status)
2380 static_cast<FwAssertArgType>(_status)
2383 #if FW_AMPCS_COMPATIBLE 2386 static_cast<U8>(
sizeof(I32))
2390 static_cast<FwAssertArgType>(_status)
2396 static_cast<FwAssertArgType>(_status)
2399 this->m_logOut_OutputPort[0].
invoke(
2408 #if FW_ENABLE_TEXT_LOGGING 2409 if (this->m_LogText_OutputPort[0].isConnected()) {
2410 #if FW_OBJECT_NAMES == 1 2411 const char* _formatString =
2412 "(%s) %s: Sequence file %s invalid. Stage: %s Error: %" PRIi32
"";
2414 const char* _formatString =
2415 "%s: Sequence file %s invalid. Stage: %s Error: %" PRIi32
"";
2419 stage.toString(stageStr);
2425 this->m_objName.toChar(),
2433 this->m_LogText_OutputPort[0].invoke(
2452 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2453 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2461 if (this->m_logOut_OutputPort[0].isConnected()) {
2465 #if FW_AMPCS_COMPATIBLE 2467 _status = _logBuff.
serialize(static_cast<U8>(3));
2470 static_cast<FwAssertArgType>(_status)
2477 static_cast<FwAssertArgType>(_status)
2480 #if FW_AMPCS_COMPATIBLE 2483 static_cast<U8>(
sizeof(U32))
2487 static_cast<FwAssertArgType>(_status)
2490 _status = _logBuff.
serialize(recordNumber);
2493 static_cast<FwAssertArgType>(_status)
2496 #if FW_AMPCS_COMPATIBLE 2499 static_cast<U8>(
sizeof(I32))
2503 static_cast<FwAssertArgType>(_status)
2509 static_cast<FwAssertArgType>(_status)
2512 this->m_logOut_OutputPort[0].
invoke(
2521 #if FW_ENABLE_TEXT_LOGGING 2522 if (this->m_LogText_OutputPort[0].isConnected()) {
2523 #if FW_OBJECT_NAMES == 1 2524 const char* _formatString =
2525 "(%s) %s: Sequence file %s: Record %" PRIu32
" invalid. Err: %" PRIi32
"";
2527 const char* _formatString =
2528 "%s: Sequence file %s: Record %" PRIu32
" invalid. Err: %" PRIi32
"";
2535 this->m_objName.toChar(),
2537 "CS_RecordInvalid ",
2543 this->m_LogText_OutputPort[0].invoke(
2561 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2562 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2570 if (this->m_logOut_OutputPort[0].isConnected()) {
2574 #if FW_AMPCS_COMPATIBLE 2576 _status = _logBuff.
serialize(static_cast<U8>(2));
2579 static_cast<FwAssertArgType>(_status)
2586 static_cast<FwAssertArgType>(_status)
2589 #if FW_AMPCS_COMPATIBLE 2592 static_cast<U8>(
sizeof(U32))
2596 static_cast<FwAssertArgType>(_status)
2602 static_cast<FwAssertArgType>(_status)
2605 this->m_logOut_OutputPort[0].
invoke(
2614 #if FW_ENABLE_TEXT_LOGGING 2615 if (this->m_LogText_OutputPort[0].isConnected()) {
2616 #if FW_OBJECT_NAMES == 1 2617 const char* _formatString =
2618 "(%s) %s: Sequence file %s too large. Size: %" PRIu32
"";
2620 const char* _formatString =
2621 "%s: Sequence file %s too large. Size: %" PRIu32
"";
2628 this->m_objName.toChar(),
2630 "CS_FileSizeError ",
2635 this->m_LogText_OutputPort[0].invoke(
2650 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2651 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2659 if (this->m_logOut_OutputPort[0].isConnected()) {
2663 #if FW_AMPCS_COMPATIBLE 2665 _status = _logBuff.
serialize(static_cast<U8>(1));
2668 static_cast<FwAssertArgType>(_status)
2675 static_cast<FwAssertArgType>(_status)
2678 this->m_logOut_OutputPort[0].
invoke(
2687 #if FW_ENABLE_TEXT_LOGGING 2688 if (this->m_LogText_OutputPort[0].isConnected()) {
2689 #if FW_OBJECT_NAMES == 1 2690 const char* _formatString =
2691 "(%s) %s: Sequence file %s not found.";
2693 const char* _formatString =
2694 "%s: Sequence file %s not found.";
2701 this->m_objName.toChar(),
2707 this->m_LogText_OutputPort[0].invoke(
2726 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2727 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2735 if (this->m_logOut_OutputPort[0].isConnected()) {
2739 #if FW_AMPCS_COMPATIBLE 2741 _status = _logBuff.
serialize(static_cast<U8>(3));
2744 static_cast<FwAssertArgType>(_status)
2751 static_cast<FwAssertArgType>(_status)
2754 #if FW_AMPCS_COMPATIBLE 2757 static_cast<U8>(
sizeof(U32))
2761 static_cast<FwAssertArgType>(_status)
2764 _status = _logBuff.
serialize(storedCRC);
2767 static_cast<FwAssertArgType>(_status)
2770 #if FW_AMPCS_COMPATIBLE 2773 static_cast<U8>(
sizeof(U32))
2777 static_cast<FwAssertArgType>(_status)
2780 _status = _logBuff.
serialize(computedCRC);
2783 static_cast<FwAssertArgType>(_status)
2786 this->m_logOut_OutputPort[0].
invoke(
2795 #if FW_ENABLE_TEXT_LOGGING 2796 if (this->m_LogText_OutputPort[0].isConnected()) {
2797 #if FW_OBJECT_NAMES == 1 2798 const char* _formatString =
2799 "(%s) %s: Sequence file %s had invalid CRC. Stored 0x%" PRIx32
", Computed 0x%" PRIx32
".";
2801 const char* _formatString =
2802 "%s: Sequence file %s had invalid CRC. Stored 0x%" PRIx32
", Computed 0x%" PRIx32
".";
2809 this->m_objName.toChar(),
2811 "CS_FileCrcFailure ",
2817 this->m_LogText_OutputPort[0].invoke(
2836 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2837 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2845 if (this->m_logOut_OutputPort[0].isConnected()) {
2849 #if FW_AMPCS_COMPATIBLE 2851 _status = _logBuff.
serialize(static_cast<U8>(3));
2854 static_cast<FwAssertArgType>(_status)
2861 static_cast<FwAssertArgType>(_status)
2864 #if FW_AMPCS_COMPATIBLE 2867 static_cast<U8>(
sizeof(U32))
2871 static_cast<FwAssertArgType>(_status)
2874 _status = _logBuff.
serialize(recordNumber);
2877 static_cast<FwAssertArgType>(_status)
2880 #if FW_AMPCS_COMPATIBLE 2883 static_cast<U8>(
sizeof(U32))
2887 static_cast<FwAssertArgType>(_status)
2893 static_cast<FwAssertArgType>(_status)
2896 this->m_logOut_OutputPort[0].
invoke(
2905 #if FW_ENABLE_TEXT_LOGGING 2906 if (this->m_LogText_OutputPort[0].isConnected()) {
2907 #if FW_OBJECT_NAMES == 1 2908 const char* _formatString =
2909 "(%s) %s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") complete";
2911 const char* _formatString =
2912 "%s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") complete";
2919 this->m_objName.toChar(),
2921 "CS_CommandComplete ",
2927 this->m_LogText_OutputPort[0].invoke(
2942 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2943 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2951 if (this->m_logOut_OutputPort[0].isConnected()) {
2955 #if FW_AMPCS_COMPATIBLE 2957 _status = _logBuff.
serialize(static_cast<U8>(1));
2960 static_cast<FwAssertArgType>(_status)
2967 static_cast<FwAssertArgType>(_status)
2970 this->m_logOut_OutputPort[0].
invoke(
2979 #if FW_ENABLE_TEXT_LOGGING 2980 if (this->m_LogText_OutputPort[0].isConnected()) {
2981 #if FW_OBJECT_NAMES == 1 2982 const char* _formatString =
2983 "(%s) %s: Sequence file %s complete";
2985 const char* _formatString =
2986 "%s: Sequence file %s complete";
2993 this->m_objName.toChar(),
2995 "CS_SequenceComplete ",
2999 this->m_LogText_OutputPort[0].invoke(
3019 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3020 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3028 if (this->m_logOut_OutputPort[0].isConnected()) {
3032 #if FW_AMPCS_COMPATIBLE 3034 _status = _logBuff.
serialize(static_cast<U8>(4));
3037 static_cast<FwAssertArgType>(_status)
3044 static_cast<FwAssertArgType>(_status)
3047 #if FW_AMPCS_COMPATIBLE 3050 static_cast<U8>(
sizeof(U32))
3054 static_cast<FwAssertArgType>(_status)
3057 _status = _logBuff.
serialize(recordNumber);
3060 static_cast<FwAssertArgType>(_status)
3063 #if FW_AMPCS_COMPATIBLE 3066 static_cast<U8>(
sizeof(U32))
3070 static_cast<FwAssertArgType>(_status)
3076 static_cast<FwAssertArgType>(_status)
3079 #if FW_AMPCS_COMPATIBLE 3082 static_cast<U8>(
sizeof(U32))
3086 static_cast<FwAssertArgType>(_status)
3089 _status = _logBuff.
serialize(errorStatus);
3092 static_cast<FwAssertArgType>(_status)
3095 this->m_logOut_OutputPort[0].
invoke(
3104 #if FW_ENABLE_TEXT_LOGGING 3105 if (this->m_LogText_OutputPort[0].isConnected()) {
3106 #if FW_OBJECT_NAMES == 1 3107 const char* _formatString =
3108 "(%s) %s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") completed with error %" PRIu32
"";
3110 const char* _formatString =
3111 "%s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") completed with error %" PRIu32
"";
3118 this->m_objName.toChar(),
3127 this->m_LogText_OutputPort[0].invoke(
3142 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3143 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3151 if (this->m_logOut_OutputPort[0].isConnected()) {
3154 #if FW_AMPCS_COMPATIBLE 3157 _status = _logBuff.
serialize(static_cast<U8>(0));
3160 static_cast<FwAssertArgType>(_status)
3164 this->m_logOut_OutputPort[0].
invoke(
3173 #if FW_ENABLE_TEXT_LOGGING 3174 if (this->m_LogText_OutputPort[0].isConnected()) {
3175 #if FW_OBJECT_NAMES == 1 3176 const char* _formatString =
3177 "(%s) %s: Invalid mode";
3179 const char* _formatString =
3187 this->m_objName.toChar(),
3192 this->m_LogText_OutputPort[0].invoke(
3211 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3212 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3220 if (this->m_logOut_OutputPort[0].isConnected()) {
3224 #if FW_AMPCS_COMPATIBLE 3226 _status = _logBuff.
serialize(static_cast<U8>(3));
3229 static_cast<FwAssertArgType>(_status)
3236 static_cast<FwAssertArgType>(_status)
3239 #if FW_AMPCS_COMPATIBLE 3242 static_cast<U8>(
sizeof(U32))
3246 static_cast<FwAssertArgType>(_status)
3249 _status = _logBuff.
serialize(header_records);
3252 static_cast<FwAssertArgType>(_status)
3255 #if FW_AMPCS_COMPATIBLE 3258 static_cast<U8>(
sizeof(U32))
3262 static_cast<FwAssertArgType>(_status)
3265 _status = _logBuff.
serialize(extra_bytes);
3268 static_cast<FwAssertArgType>(_status)
3271 this->m_logOut_OutputPort[0].
invoke(
3280 #if FW_ENABLE_TEXT_LOGGING 3281 if (this->m_LogText_OutputPort[0].isConnected()) {
3282 #if FW_OBJECT_NAMES == 1 3283 const char* _formatString =
3284 "(%s) %s: Sequence file %s header records mismatch: %" PRIu32
" in header, found %" PRIu32
" extra bytes.";
3286 const char* _formatString =
3287 "%s: Sequence file %s header records mismatch: %" PRIu32
" in header, found %" PRIu32
" extra bytes.";
3294 this->m_objName.toChar(),
3296 "CS_RecordMismatch ",
3302 this->m_LogText_OutputPort[0].invoke(
3321 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3322 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3330 if (this->m_logOut_OutputPort[0].isConnected()) {
3334 #if FW_AMPCS_COMPATIBLE 3336 _status = _logBuff.
serialize(static_cast<U8>(3));
3339 static_cast<FwAssertArgType>(_status)
3346 static_cast<FwAssertArgType>(_status)
3349 #if FW_AMPCS_COMPATIBLE 3352 static_cast<U8>(
sizeof(U16))
3356 static_cast<FwAssertArgType>(_status)
3359 _status = _logBuff.
serialize(time_base);
3362 static_cast<FwAssertArgType>(_status)
3365 #if FW_AMPCS_COMPATIBLE 3368 static_cast<U8>(
sizeof(U16))
3372 static_cast<FwAssertArgType>(_status)
3375 _status = _logBuff.
serialize(seq_time_base);
3378 static_cast<FwAssertArgType>(_status)
3381 this->m_logOut_OutputPort[0].
invoke(
3390 #if FW_ENABLE_TEXT_LOGGING 3391 if (this->m_LogText_OutputPort[0].isConnected()) {
3392 #if FW_OBJECT_NAMES == 1 3393 const char* _formatString =
3394 "(%s) %s: Sequence file %s: Current time base doesn't match sequence time: base: %" PRIu16
" seq: %" PRIu16
"";
3396 const char* _formatString =
3397 "%s: Sequence file %s: Current time base doesn't match sequence time: base: %" PRIu16
" seq: %" PRIu16
"";
3404 this->m_objName.toChar(),
3406 "CS_TimeBaseMismatch ",
3412 this->m_LogText_OutputPort[0].invoke(
3431 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3432 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3440 if (this->m_logOut_OutputPort[0].isConnected()) {
3444 #if FW_AMPCS_COMPATIBLE 3446 _status = _logBuff.
serialize(static_cast<U8>(3));
3449 static_cast<FwAssertArgType>(_status)
3456 static_cast<FwAssertArgType>(_status)
3459 #if FW_AMPCS_COMPATIBLE 3462 static_cast<U8>(
sizeof(
U8))
3466 static_cast<FwAssertArgType>(_status)
3469 _status = _logBuff.
serialize(currTimeBase);
3472 static_cast<FwAssertArgType>(_status)
3475 #if FW_AMPCS_COMPATIBLE 3478 static_cast<U8>(
sizeof(
U8))
3482 static_cast<FwAssertArgType>(_status)
3485 _status = _logBuff.
serialize(seqTimeBase);
3488 static_cast<FwAssertArgType>(_status)
3491 this->m_logOut_OutputPort[0].
invoke(
3500 #if FW_ENABLE_TEXT_LOGGING 3501 if (this->m_LogText_OutputPort[0].isConnected()) {
3502 #if FW_OBJECT_NAMES == 1 3503 const char* _formatString =
3504 "(%s) %s: Sequence file %s: Current time context doesn't match sequence context: base: %" PRIu8
" seq: %" PRIu8
"";
3506 const char* _formatString =
3507 "%s: Sequence file %s: Current time context doesn't match sequence context: base: %" PRIu8
" seq: %" PRIu8
"";
3514 this->m_objName.toChar(),
3516 "CS_TimeContextMismatch ",
3522 this->m_LogText_OutputPort[0].invoke(
3537 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3538 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3546 if (this->m_logOut_OutputPort[0].isConnected()) {
3550 #if FW_AMPCS_COMPATIBLE 3552 _status = _logBuff.
serialize(static_cast<U8>(1));
3555 static_cast<FwAssertArgType>(_status)
3562 static_cast<FwAssertArgType>(_status)
3565 this->m_logOut_OutputPort[0].
invoke(
3574 #if FW_ENABLE_TEXT_LOGGING 3575 if (this->m_LogText_OutputPort[0].isConnected()) {
3576 #if FW_OBJECT_NAMES == 1 3577 const char* _formatString =
3578 "(%s) %s: Local request for sequence %s started.";
3580 const char* _formatString =
3581 "%s: Local request for sequence %s started.";
3588 this->m_objName.toChar(),
3590 "CS_PortSequenceStarted ",
3594 this->m_LogText_OutputPort[0].invoke(
3609 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3610 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3618 if (this->m_logOut_OutputPort[0].isConnected()) {
3622 #if FW_AMPCS_COMPATIBLE 3624 _status = _logBuff.
serialize(static_cast<U8>(1));
3627 static_cast<FwAssertArgType>(_status)
3631 #if FW_AMPCS_COMPATIBLE 3634 static_cast<U8>(
sizeof(U32))
3638 static_cast<FwAssertArgType>(_status)
3644 static_cast<FwAssertArgType>(_status)
3647 this->m_logOut_OutputPort[0].
invoke(
3656 #if FW_ENABLE_TEXT_LOGGING 3657 if (this->m_LogText_OutputPort[0].isConnected()) {
3658 #if FW_OBJECT_NAMES == 1 3659 const char* _formatString =
3660 "(%s) %s: Command complete status received while no sequences active. Opcode: %" PRIu32
"";
3662 const char* _formatString =
3663 "%s: Command complete status received while no sequences active. Opcode: %" PRIu32
"";
3670 this->m_objName.toChar(),
3672 "CS_UnexpectedCompletion ",
3676 this->m_LogText_OutputPort[0].invoke(
3691 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3692 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3700 if (this->m_logOut_OutputPort[0].isConnected()) {
3704 #if FW_AMPCS_COMPATIBLE 3706 _status = _logBuff.
serialize(static_cast<U8>(1));
3709 static_cast<FwAssertArgType>(_status)
3713 #if FW_AMPCS_COMPATIBLE 3720 static_cast<FwAssertArgType>(_status)
3726 static_cast<FwAssertArgType>(_status)
3729 this->m_logOut_OutputPort[0].
invoke(
3738 #if FW_ENABLE_TEXT_LOGGING 3739 if (this->m_LogText_OutputPort[0].isConnected()) {
3740 #if FW_OBJECT_NAMES == 1 3741 const char* _formatString =
3742 "(%s) %s: Sequencer switched to %s step mode";
3744 const char* _formatString =
3745 "%s: Sequencer switched to %s step mode";
3749 mode.toString(modeStr);
3755 this->m_objName.toChar(),
3761 this->m_LogText_OutputPort[0].invoke(
3776 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3777 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3785 if (this->m_logOut_OutputPort[0].isConnected()) {
3788 #if FW_AMPCS_COMPATIBLE 3791 _status = _logBuff.
serialize(static_cast<U8>(0));
3794 static_cast<FwAssertArgType>(_status)
3798 this->m_logOut_OutputPort[0].
invoke(
3807 #if FW_ENABLE_TEXT_LOGGING 3808 if (this->m_LogText_OutputPort[0].isConnected()) {
3809 #if FW_OBJECT_NAMES == 1 3810 const char* _formatString =
3811 "(%s) %s: No sequence active.";
3813 const char* _formatString =
3814 "%s: No sequence active.";
3821 this->m_objName.toChar(),
3823 "CS_NoSequenceActive " 3826 this->m_LogText_OutputPort[0].invoke(
3841 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3842 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3850 if (this->m_logOut_OutputPort[0].isConnected()) {
3854 #if FW_AMPCS_COMPATIBLE 3856 _status = _logBuff.
serialize(static_cast<U8>(1));
3859 static_cast<FwAssertArgType>(_status)
3866 static_cast<FwAssertArgType>(_status)
3869 this->m_logOut_OutputPort[0].
invoke(
3878 #if FW_ENABLE_TEXT_LOGGING 3879 if (this->m_LogText_OutputPort[0].isConnected()) {
3880 #if FW_OBJECT_NAMES == 1 3881 const char* _formatString =
3882 "(%s) %s: Sequence %s is valid.";
3884 const char* _formatString =
3885 "%s: Sequence %s is valid.";
3892 this->m_objName.toChar(),
3894 "CS_SequenceValid ",
3898 this->m_LogText_OutputPort[0].invoke(
3916 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3917 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3925 if (this->m_logOut_OutputPort[0].isConnected()) {
3929 #if FW_AMPCS_COMPATIBLE 3931 _status = _logBuff.
serialize(static_cast<U8>(2));
3934 static_cast<FwAssertArgType>(_status)
3941 static_cast<FwAssertArgType>(_status)
3944 #if FW_AMPCS_COMPATIBLE 3947 static_cast<U8>(
sizeof(U32))
3951 static_cast<FwAssertArgType>(_status)
3957 static_cast<FwAssertArgType>(_status)
3960 this->m_logOut_OutputPort[0].
invoke(
3969 #if FW_ENABLE_TEXT_LOGGING 3970 if (this->m_LogText_OutputPort[0].isConnected()) {
3971 #if FW_OBJECT_NAMES == 1 3972 const char* _formatString =
3973 "(%s) %s: Sequence %s timed out on command %" PRIu32
"";
3975 const char* _formatString =
3976 "%s: Sequence %s timed out on command %" PRIu32
"";
3983 this->m_objName.toChar(),
3985 "CS_SequenceTimeout ",
3990 this->m_LogText_OutputPort[0].invoke(
4008 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4009 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4017 if (this->m_logOut_OutputPort[0].isConnected()) {
4021 #if FW_AMPCS_COMPATIBLE 4023 _status = _logBuff.
serialize(static_cast<U8>(2));
4026 static_cast<FwAssertArgType>(_status)
4033 static_cast<FwAssertArgType>(_status)
4036 #if FW_AMPCS_COMPATIBLE 4039 static_cast<U8>(
sizeof(U32))
4043 static_cast<FwAssertArgType>(_status)
4049 static_cast<FwAssertArgType>(_status)
4052 this->m_logOut_OutputPort[0].
invoke(
4061 #if FW_ENABLE_TEXT_LOGGING 4062 if (this->m_LogText_OutputPort[0].isConnected()) {
4063 #if FW_OBJECT_NAMES == 1 4064 const char* _formatString =
4065 "(%s) %s: Sequence %s command %" PRIu32
" stepped";
4067 const char* _formatString =
4068 "%s: Sequence %s command %" PRIu32
" stepped";
4075 this->m_objName.toChar(),
4082 this->m_LogText_OutputPort[0].invoke(
4097 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4098 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4106 if (this->m_logOut_OutputPort[0].isConnected()) {
4110 #if FW_AMPCS_COMPATIBLE 4112 _status = _logBuff.
serialize(static_cast<U8>(1));
4115 static_cast<FwAssertArgType>(_status)
4122 static_cast<FwAssertArgType>(_status)
4125 this->m_logOut_OutputPort[0].
invoke(
4134 #if FW_ENABLE_TEXT_LOGGING 4135 if (this->m_LogText_OutputPort[0].isConnected()) {
4136 #if FW_OBJECT_NAMES == 1 4137 const char* _formatString =
4138 "(%s) %s: Sequence %s started";
4140 const char* _formatString =
4141 "%s: Sequence %s started";
4148 this->m_objName.toChar(),
4154 this->m_LogText_OutputPort[0].invoke(
4173 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4174 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4182 if (this->m_logOut_OutputPort[0].isConnected()) {
4186 #if FW_AMPCS_COMPATIBLE 4188 _status = _logBuff.
serialize(static_cast<U8>(3));
4191 static_cast<FwAssertArgType>(_status)
4198 static_cast<FwAssertArgType>(_status)
4201 #if FW_AMPCS_COMPATIBLE 4204 static_cast<U8>(
sizeof(U32))
4208 static_cast<FwAssertArgType>(_status)
4211 _status = _logBuff.
serialize(recordNumber);
4214 static_cast<FwAssertArgType>(_status)
4217 #if FW_AMPCS_COMPATIBLE 4220 static_cast<U8>(
sizeof(U32))
4224 static_cast<FwAssertArgType>(_status)
4230 static_cast<FwAssertArgType>(_status)
4233 this->m_logOut_OutputPort[0].
invoke(
4242 #if FW_ENABLE_TEXT_LOGGING 4243 if (this->m_LogText_OutputPort[0].isConnected()) {
4244 #if FW_OBJECT_NAMES == 1 4245 const char* _formatString =
4246 "(%s) %s: Start waiting for sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") to complete";
4248 const char* _formatString =
4249 "%s: Start waiting for sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") to complete";
4256 this->m_objName.toChar(),
4264 this->m_LogText_OutputPort[0].invoke(
4279 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4280 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4288 if (this->m_logOut_OutputPort[0].isConnected()) {
4291 #if FW_AMPCS_COMPATIBLE 4294 _status = _logBuff.
serialize(static_cast<U8>(0));
4297 static_cast<FwAssertArgType>(_status)
4301 this->m_logOut_OutputPort[0].
invoke(
4310 #if FW_ENABLE_TEXT_LOGGING 4311 if (this->m_LogText_OutputPort[0].isConnected()) {
4312 #if FW_OBJECT_NAMES == 1 4313 const char* _formatString =
4314 "(%s) %s: Still waiting for sequence file to complete";
4316 const char* _formatString =
4317 "%s: Still waiting for sequence file to complete";
4324 this->m_objName.toChar(),
4326 "CS_JoinWaitingNotComplete " 4329 this->m_LogText_OutputPort[0].invoke(
4344 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4345 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4353 if (this->m_logOut_OutputPort[0].isConnected()) {
4357 #if FW_AMPCS_COMPATIBLE 4359 _status = _logBuff.
serialize(static_cast<U8>(1));
4362 static_cast<FwAssertArgType>(_status)
4369 static_cast<FwAssertArgType>(_status)
4372 this->m_logOut_OutputPort[0].
invoke(
4381 #if FW_ENABLE_TEXT_LOGGING 4382 if (this->m_LogText_OutputPort[0].isConnected()) {
4383 #if FW_OBJECT_NAMES == 1 4384 const char* _formatString =
4385 "(%s) %s: Sequence file %s has no records. Ignoring.";
4387 const char* _formatString =
4388 "%s: Sequence file %s has no records. Ignoring.";
4395 this->m_objName.toChar(),
4401 this->m_LogText_OutputPort[0].invoke(
4421 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4423 this->m_timeCaller_OutputPort[0].isConnected() &&
4426 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4433 static_cast<FwAssertArgType>(_stat)
4440 this->m_tlmOut_OutputPort[0].
invoke(
4454 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4456 this->m_timeCaller_OutputPort[0].isConnected() &&
4459 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4466 static_cast<FwAssertArgType>(_stat)
4473 this->m_tlmOut_OutputPort[0].
invoke(
4487 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4489 this->m_timeCaller_OutputPort[0].isConnected() &&
4492 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4499 static_cast<FwAssertArgType>(_stat)
4506 this->m_tlmOut_OutputPort[0].
invoke(
4520 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4522 this->m_timeCaller_OutputPort[0].isConnected() &&
4525 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4532 static_cast<FwAssertArgType>(_stat)
4539 this->m_tlmOut_OutputPort[0].
invoke(
4553 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4555 this->m_timeCaller_OutputPort[0].isConnected() &&
4558 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4565 static_cast<FwAssertArgType>(_stat)
4572 this->m_tlmOut_OutputPort[0].
invoke(
4587 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4589 this->m_timeCaller_OutputPort[0].
invoke(_time);
4604 ComponentIpcSerializableBuffer msg;
4614 static_cast<FwAssertArgType>(msgStatus)
4624 static_cast<FwAssertArgType>(deserStatus)
4627 MsgTypeEnum msgType =
static_cast<MsgTypeEnum
>(desMsg);
4629 if (msgType == CMDSEQUENCER_COMPONENT_EXIT) {
4634 deserStatus = msg.deserialize(portNum);
4637 static_cast<FwAssertArgType>(deserStatus)
4642 case CMDRESPONSEIN_CMDRESPONSE: {
4645 deserStatus = msg.deserialize(opCode);
4648 static_cast<FwAssertArgType>(deserStatus)
4653 deserStatus = msg.deserialize(cmdSeq);
4656 static_cast<FwAssertArgType>(deserStatus)
4661 deserStatus = msg.deserialize(response);
4664 static_cast<FwAssertArgType>(deserStatus)
4681 deserStatus = msg.deserialize(key);
4684 static_cast<FwAssertArgType>(deserStatus)
4696 case SCHEDIN_SCHED: {
4699 deserStatus = msg.deserialize(context);
4702 static_cast<FwAssertArgType>(deserStatus)
4714 case SEQCANCELIN_CMDSEQCANCEL: {
4722 case SEQRUNIN_CMDSEQIN: {
4725 Fw::ExternalString filename(__fprime_ac_filename_buffer,
sizeof __fprime_ac_filename_buffer);
4726 deserStatus = msg.deserialize(filename);
4729 static_cast<FwAssertArgType>(deserStatus)
4744 deserStatus = msg.deserialize(opCode);
4747 static_cast<FwAssertArgType>(deserStatus)
4752 deserStatus = msg.deserialize(cmdSeq);
4755 static_cast<FwAssertArgType>(deserStatus)
4760 deserStatus = msg.deserialize(args);
4763 static_cast<FwAssertArgType>(deserStatus)
4773 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4788 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4801 #if FW_CMD_CHECK_RESIDUAL 4803 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4822 case CMD_CS_VALIDATE: {
4825 deserStatus = msg.deserialize(opCode);
4828 static_cast<FwAssertArgType>(deserStatus)
4833 deserStatus = msg.deserialize(cmdSeq);
4836 static_cast<FwAssertArgType>(deserStatus)
4841 deserStatus = msg.deserialize(args);
4844 static_cast<FwAssertArgType>(deserStatus)
4854 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4867 #if FW_CMD_CHECK_RESIDUAL 4869 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4887 case CMD_CS_CANCEL: {
4890 deserStatus = msg.deserialize(opCode);
4893 static_cast<FwAssertArgType>(deserStatus)
4898 deserStatus = msg.deserialize(cmdSeq);
4901 static_cast<FwAssertArgType>(deserStatus)
4906 deserStatus = msg.deserialize(args);
4909 static_cast<FwAssertArgType>(deserStatus)
4917 #if FW_CMD_CHECK_RESIDUAL 4919 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4934 case CMD_CS_START: {
4937 deserStatus = msg.deserialize(opCode);
4940 static_cast<FwAssertArgType>(deserStatus)
4945 deserStatus = msg.deserialize(cmdSeq);
4948 static_cast<FwAssertArgType>(deserStatus)
4953 deserStatus = msg.deserialize(args);
4956 static_cast<FwAssertArgType>(deserStatus)
4964 #if FW_CMD_CHECK_RESIDUAL 4966 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4984 deserStatus = msg.deserialize(opCode);
4987 static_cast<FwAssertArgType>(deserStatus)
4992 deserStatus = msg.deserialize(cmdSeq);
4995 static_cast<FwAssertArgType>(deserStatus)
5000 deserStatus = msg.deserialize(args);
5003 static_cast<FwAssertArgType>(deserStatus)
5011 #if FW_CMD_CHECK_RESIDUAL 5013 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5031 deserStatus = msg.deserialize(opCode);
5034 static_cast<FwAssertArgType>(deserStatus)
5039 deserStatus = msg.deserialize(cmdSeq);
5042 static_cast<FwAssertArgType>(deserStatus)
5047 deserStatus = msg.deserialize(args);
5050 static_cast<FwAssertArgType>(deserStatus)
5058 #if FW_CMD_CHECK_RESIDUAL 5060 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5075 case CMD_CS_MANUAL: {
5078 deserStatus = msg.deserialize(opCode);
5081 static_cast<FwAssertArgType>(deserStatus)
5086 deserStatus = msg.deserialize(cmdSeq);
5089 static_cast<FwAssertArgType>(deserStatus)
5094 deserStatus = msg.deserialize(args);
5097 static_cast<FwAssertArgType>(deserStatus)
5105 #if FW_CMD_CHECK_RESIDUAL 5107 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5122 case CMD_CS_JOIN_WAIT: {
5125 deserStatus = msg.deserialize(opCode);
5128 static_cast<FwAssertArgType>(deserStatus)
5133 deserStatus = msg.deserialize(cmdSeq);
5136 static_cast<FwAssertArgType>(deserStatus)
5141 deserStatus = msg.deserialize(args);
5144 static_cast<FwAssertArgType>(deserStatus)
5152 #if FW_CMD_CHECK_RESIDUAL 5154 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5179 void CmdSequencerComponentBase ::
5191 const U32 idBase = callComp->
getIdBase();
5192 FW_ASSERT(opCode >= idBase, static_cast<FwAssertArgType>(opCode), static_cast<FwAssertArgType>(idBase));
5195 switch (opCode - idBase) {
5197 compPtr->CS_RUN_cmdHandlerBase(
5206 compPtr->CS_VALIDATE_cmdHandlerBase(
5215 compPtr->CS_CANCEL_cmdHandlerBase(
5224 compPtr->CS_START_cmdHandlerBase(
5233 compPtr->CS_STEP_cmdHandlerBase(
5242 compPtr->CS_AUTO_cmdHandlerBase(
5251 compPtr->CS_MANUAL_cmdHandlerBase(
5260 compPtr->CS_JOIN_WAIT_cmdHandlerBase(
5274 void CmdSequencerComponentBase ::
5275 m_p_cmdResponseIn_in(
5285 compPtr->cmdResponseIn_handlerBase(
5293 void CmdSequencerComponentBase ::
5302 compPtr->pingIn_handlerBase(
5308 void CmdSequencerComponentBase ::
5317 compPtr->schedIn_handlerBase(
5323 void CmdSequencerComponentBase ::
5331 compPtr->seqCancelIn_handlerBase(portNum);
5334 void CmdSequencerComponentBase ::
5343 compPtr->seqRunIn_handlerBase(
void set_timeCaller_OutputPort(FwIndexType portNum, Fw::InputTimePort *port)
Connect port to timeCaller[portNum].
Serialization/Deserialization operation was successful.
void log_WARNING_HI_CS_TimeContextMismatch(const Fw::StringBase &fileName, U8 currTimeBase, U8 seqTimeBase) const
A sequence passed validation.
Set the run mode to MANUAL.
void set_tlmOut_OutputPort(FwIndexType portNum, Fw::InputTlmPort *port)
Connect port to tlmOut[portNum].
void log_WARNING_HI_CS_FileInvalid(const Fw::StringBase &fileName, Svc::CmdSequencer_FileReadStage stage, I32 error) const
void addCallPort(InputTimePort *callPort)
Register an input port.
A sequence passed validation.
void tlmWrite_CS_LoadCommands(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
void invoke(Fw::ComBuffer &data, U32 context) const
Invoke a port interface.
void log_WARNING_HI_CS_InvalidMode() const
void init()
Initialization function.
FwIndexType getNum_timeCaller_OutputPorts() const
void log_WARNING_HI_CS_CommandError(const Fw::StringBase &fileName, U32 recordNumber, U32 opCode, U32 errorStatus) const
FwIndexType getNum_seqCancelIn_InputPorts() const
void log_WARNING_HI_CS_FileSizeError(const Fw::StringBase &fileName, U32 size) const
void log_ACTIVITY_HI_CS_ModeSwitched(Svc::CmdSequencer_SeqMode mode) const
A command sequence successfully completed.
bool isConnected_comCmdOut_OutputPort(FwIndexType portNum)
void cmdResponseIn_handlerBase(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Handler base-class function for input port cmdResponseIn.
The sequence file was not found.
The running time base doesn't match the time base in the sequence files.
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)
NATIVE_UINT_TYPE SizeType
Status
status returned from the queue send function
void log_WARNING_HI_CS_JoinWaitingNotComplete() const
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
void CS_MANUAL_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Svc::InputPingPort * get_pingIn_InputPort(FwIndexType portNum)
const char * toChar() const
void regCommands()
Register commands with the Command Dispatcher.
The sequence file format was invalid.
FwIndexType getNum_cmdIn_InputPorts() const
Cancel a command sequence.
void init()
Initialization function.
A command in a sequence was stepped through.
virtual void schedIn_preMsgHook(FwIndexType portNum, U32 context)
Pre-message hook for async input port schedIn.
virtual void CS_AUTO_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_AUTO.
The stage of the file read operation.
void log_ACTIVITY_LO_CS_SequenceLoaded(const Fw::StringBase &fileName) const
Channel ID for CS_CommandsExecuted.
void log_WARNING_HI_CS_UnexpectedCompletion(U32 opcode) const
PlatformSizeType FwSizeType
FwIndexType getNum_cmdResponseOut_OutputPorts() const
Sequence file was successfully loaded.
void CS_STEP_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
void invoke(U32 key) const
Invoke a port interface.
The Command Sequencer received a command that was invalid for its current mode.
void pingOut_out(FwIndexType portNum, U32 key)
Invoke output port pingOut.
A command status came back when no sequence was running.
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)
void comCmdOut_out(FwIndexType portNum, Fw::ComBuffer &data, U32 context)
Invoke output port comCmdOut.
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.
void seqDone_out(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Invoke output port seqDone.
Enum representing a command response.
void schedIn_handlerBase(FwIndexType portNum, U32 context)
Handler base-class function for input port schedIn.
void seqRunIn_handlerBase(FwIndexType portNum, const Fw::StringBase &filename)
Handler base-class function for input port seqRunIn.
A sequence related command came with no active sequence.
void addCallPort(InputCmdRegPort *callPort)
Register an input port.
PlatformIndexType FwIndexType
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
Channel ID for CS_SequencesCompleted.
FwIndexType getNum_schedIn_InputPorts() 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
void addCallPort(InputTlmPort *callPort)
Register an input port.
bool isConnected_cmdResponseOut_OutputPort(FwIndexType portNum)
FwIndexType getNum_pingIn_InputPorts() const
void init()
Object initializer.
void seqStartOut_out(FwIndexType portNum, const Fw::StringBase &filename)
Invoke output port seqStartOut.
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.
virtual void CS_RUN_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_RUN.
Run a command sequence file.
Start running a command sequence.
The Command Sequencer issued a command and received an error status in return.
void tlmWrite_CS_CancelCommands(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
Channel ID for CS_CancelCommands.
virtual ~CmdSequencerComponentBase()
Destroy CmdSequencerComponentBase object.
void tlmWrite_CS_CommandsExecuted(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
Set the run mode to AUTO.
Wait for sequences that are running to finish. Allow user to run multiple seq files in SEQ_NO_BLOCK m...
void invoke(FwOpcodeType opCode) const
Invoke a port interface.
virtual void seqRunIn_preMsgHook(FwIndexType portNum, const Fw::StringBase &filename)
Pre-message hook for async input port seqRunIn.
void log_ACTIVITY_HI_CS_PortSequenceStarted(const Fw::StringBase &filename) const
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
Serializable::SizeType getBuffLeft() const
returns how much deserialization buffer is left
virtual void CS_RUN_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &fileName, Svc::CmdSequencer_BlockState block)=0
void init()
Initialization function.
Number of records in header doesn't match number in file.
Less important informational events.
Os::Queue::Status createQueue(FwSizeType depth, FwSizeType msgSize)
Validate a command sequence file.
void log_WARNING_HI_CS_RecordMismatch(const Fw::StringBase &fileName, U32 header_records, U32 extra_bytes) const
#define FW_MIN(a, b)
MIN macro.
A less serious but recoverable event.
void init()
Initialization function.
Wait for the current running sequence file complete.
bool isConnected_pingOut_OutputPort(FwIndexType portNum)
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 interface.
bool isConnected_seqStartOut_OutputPort(FwIndexType portNum)
void CS_JOIN_WAIT_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Svc::InputCmdSeqInPort * get_seqRunIn_InputPort(FwIndexType portNum)
const char * toChar() const
void invoke(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response) const
Invoke a port interface.
No time base has been established.
void set_cmdResponseOut_OutputPort(FwIndexType portNum, Fw::InputCmdResponsePort *port)
Connect port to cmdResponseOut[portNum].
FwIndexType getNum_pingOut_OutputPorts() const
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.
The Command Sequencer issued a command and received a success status in return.
void log_ACTIVITY_HI_CS_JoinWaiting(const Fw::StringBase &filename, U32 recordNumber, U32 opCode) const
Status send(const U8 *buffer, FwSizeType size, FwQueuePriorityType priority, BlockingType blockType) override
send a message into the queue through delegate
A command sequence was successfully canceled.
virtual void seqRunIn_handler(FwIndexType portNum, const Fw::StringBase &filename)=0
Handler for input port seqRunIn.
Channel ID for CS_LoadCommands.
void resetDeser()
reset deserialization to beginning
Channel ID for CS_Errors.
A string backed by an external buffer.
A serious but recoverable event.
Errors dispatching messages.
void invoke(FwChanIdType id, Fw::Time &timeTag, Fw::TlmBuffer &val) const
Invoke a port interface.
bool isConnected_timeCaller_OutputPort(FwIndexType portNum)
void CS_AUTO_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
The format of a command record was invalid.
void invoke(const Fw::StringBase &filename) const
Invoke a port interface.
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.
FwIndexType getNum_seqDone_OutputPorts() const
bool isConnected_seqDone_OutputPort(FwIndexType portNum)
uint8_t U8
8-bit unsigned integer
void set_comCmdOut_OutputPort(FwIndexType portNum, Fw::InputComPort *port)
Connect port to comCmdOut[portNum].
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
#define PRI_PlatformIntType
Command failed to deserialize.
void log_WARNING_HI_CS_FileCrcFailure(const Fw::StringBase &fileName, U32 storedCRC, U32 computedCRC) const
Important informational events.
void invoke(FwEventIdType id, Fw::Time &timeTag, const Fw::LogSeverity &severity, Fw::LogBuffer &args) const
Invoke a port interface.
PlatformQueuePriorityType FwQueuePriorityType
virtual void CS_MANUAL_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_MANUAL.
bool isConnected_cmdRegOut_OutputPort(FwIndexType portNum)
The Sequence File Loader could not read the sequence file.
void CS_CANCEL_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
message to exit active component task
static constexpr SizeType BUFFER_SIZE(SizeType maxLength)
Get the size of a null-terminated string buffer.
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
FwIndexType getNum_comCmdOut_OutputPorts() const
A message was sent requesting an exit of the loop.
virtual void CS_STEP_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_STEP.
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
Fw::InputCmdPort * get_cmdIn_InputPort(FwIndexType portNum)
FwIndexType getNum_logOut_OutputPorts() const
void seqCancelIn_handlerBase(FwIndexType portNum)
Handler base-class function for input port seqCancelIn.
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
void addCallPort(InputLogPort *callPort)
Register an input port.
void addCallPort(InputCmdSeqInPort *callPort)
Register an input port.
void init()
Initialization function.
void CS_RUN_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
FwIndexType getNum_seqRunIn_InputPorts() const
virtual void pingIn_handler(FwIndexType portNum, U32 key)=0
Handler for input port pingIn.
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
message sent/received okay
The size of the serial representation.
FwIndexType getNum_seqStartOut_OutputPorts() const
void addCallPort(InputComPort *callPort)
Register an input port.
The size of the serial representation.
virtual SerializeStatus serialize(SerializeBufferBase &buffer) const
serialization function
virtual void CS_MANUAL_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
CmdSequencerComponentBase(const char *compName="")
Construct CmdSequencerComponentBase object.
Message will return with status when space is unavailable.
Status receive(U8 *destination, FwSizeType capacity, BlockingType blockType, FwSizeType &actualSize, FwQueuePriorityType &priority) override
receive a message from the queue through delegate
virtual void cmdResponseIn_handler(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)=0
Handler for input port cmdResponseIn.
Cannot run new sequence when current sequence file is still running.
void log_WARNING_LO_CS_NoRecords(const Fw::StringBase &fileName) const
Log event CS_NoRecords.
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.
void init()
Initialization function.
Sequencer blocking state.
virtual void CS_CANCEL_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects) ...
void set_logOut_OutputPort(FwIndexType portNum, Fw::InputLogPort *port)
Connect port to logOut[portNum].
Svc::InputCmdSeqCancelPort * get_seqCancelIn_InputPort(FwIndexType portNum)
void log_ACTIVITY_LO_CS_CommandComplete(const Fw::StringBase &fileName, U32 recordNumber, U32 opCode) const
A local port request to run a sequence was started.
void log_ACTIVITY_HI_CS_SequenceValid(const Fw::StringBase &filename) const
bool isConnected_logOut_OutputPort(FwIndexType portNum)
A manual sequence was started.
The sequence file was too large.
FwIndexType getNum_tlmOut_OutputPorts() const
#define FW_LOG_STRING_MAX_SIZE
Max size of log string parameter type.
virtual const CHAR * toChar() const =0
FwIndexType getNum_cmdRegOut_OutputPorts() const
void log_WARNING_HI_CS_FileReadError(const Fw::StringBase &fileName) const
bool isConnected_tlmOut_OutputPort(FwIndexType portNum)
The running time base doesn't match the time base in the sequence files.
void cmdResponse_out(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdResponse response)
Emit command response.
void addCallPort(InputCmdResponsePort *callPort)
Register an input port.
The sequence file validation failed.
void tlmWrite_CS_SequencesCompleted(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
Perform one step in a command sequence. Valid only if CmdSequencer is in MANUAL run mode...
void log_ACTIVITY_HI_CS_CmdStepped(const Fw::StringBase &filename, U32 command) const
FwIndexType getNum_cmdResponseIn_InputPorts() const
virtual void CS_JOIN_WAIT_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_JOIN_WAIT.