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 109 "%s_cmdIn_InputPort[%" PRI_PlatformIntType
"]",
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 133 "%s_cmdResponseIn_InputPort[%" PRI_PlatformIntType
"]",
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 157 "%s_pingIn_InputPort[%" PRI_PlatformIntType
"]",
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 181 "%s_schedIn_InputPort[%" PRI_PlatformIntType
"]",
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 205 "%s_seqCancelIn_InputPort[%" PRI_PlatformIntType
"]",
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 229 "%s_seqRunIn_InputPort[%" PRI_PlatformIntType
"]",
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 249 "%s_LogText_OutputPort[%" PRI_PlatformIntType
"]",
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 269 "%s_cmdRegOut_OutputPort[%" PRI_PlatformIntType
"]",
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 288 "%s_cmdResponseOut_OutputPort[%" PRI_PlatformIntType
"]",
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 307 "%s_logOut_OutputPort[%" PRI_PlatformIntType
"]",
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 326 "%s_timeCaller_OutputPort[%" PRI_PlatformIntType
"]",
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 345 "%s_tlmOut_OutputPort[%" PRI_PlatformIntType
"]",
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 364 "%s_comCmdOut_OutputPort[%" PRI_PlatformIntType
"]",
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 383 "%s_pingOut_OutputPort[%" PRI_PlatformIntType
"]",
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 402 "%s_seqDone_OutputPort[%" PRI_PlatformIntType
"]",
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 421 "%s_seqStartOut_OutputPort[%" PRI_PlatformIntType
"]",
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)
1468 this->m_comCmdOut_OutputPort[portNum].isConnected(),
1469 static_cast<FwAssertArgType>(portNum)
1471 this->m_comCmdOut_OutputPort[portNum].
invoke(
1485 static_cast<FwAssertArgType>(portNum)
1489 this->m_pingOut_OutputPort[portNum].isConnected(),
1490 static_cast<FwAssertArgType>(portNum)
1492 this->m_pingOut_OutputPort[portNum].
invoke(
1507 static_cast<FwAssertArgType>(portNum)
1511 this->m_seqDone_OutputPort[portNum].isConnected(),
1512 static_cast<FwAssertArgType>(portNum)
1514 this->m_seqDone_OutputPort[portNum].
invoke(
1529 static_cast<FwAssertArgType>(portNum)
1533 this->m_seqStartOut_OutputPort[portNum].isConnected(),
1534 static_cast<FwAssertArgType>(portNum)
1536 this->m_seqStartOut_OutputPort[portNum].
invoke(
1552 FW_ASSERT(this->m_cmdResponseOut_OutputPort[0].isConnected());
1553 this->m_cmdResponseOut_OutputPort[0].
invoke(opCode, cmdSeq, response);
1574 ComponentIpcSerializableBuffer msg;
1578 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_RUN));
1581 static_cast<FwAssertArgType>(_status)
1587 _status = msg.serialize(port);
1590 static_cast<FwAssertArgType>(_status)
1593 _status = msg.serialize(opCode);
1596 static_cast<FwAssertArgType>(_status)
1599 _status = msg.serialize(cmdSeq);
1602 static_cast<FwAssertArgType>(_status)
1605 _status = msg.serialize(args);
1608 static_cast<FwAssertArgType>(_status)
1617 static_cast<FwAssertArgType>(qStatus)
1633 ComponentIpcSerializableBuffer msg;
1637 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_VALIDATE));
1640 static_cast<FwAssertArgType>(_status)
1646 _status = msg.serialize(port);
1649 static_cast<FwAssertArgType>(_status)
1652 _status = msg.serialize(opCode);
1655 static_cast<FwAssertArgType>(_status)
1658 _status = msg.serialize(cmdSeq);
1661 static_cast<FwAssertArgType>(_status)
1664 _status = msg.serialize(args);
1667 static_cast<FwAssertArgType>(_status)
1676 static_cast<FwAssertArgType>(qStatus)
1692 ComponentIpcSerializableBuffer msg;
1696 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_CANCEL));
1699 static_cast<FwAssertArgType>(_status)
1705 _status = msg.serialize(port);
1708 static_cast<FwAssertArgType>(_status)
1711 _status = msg.serialize(opCode);
1714 static_cast<FwAssertArgType>(_status)
1717 _status = msg.serialize(cmdSeq);
1720 static_cast<FwAssertArgType>(_status)
1723 _status = msg.serialize(args);
1726 static_cast<FwAssertArgType>(_status)
1735 static_cast<FwAssertArgType>(qStatus)
1751 ComponentIpcSerializableBuffer msg;
1755 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_START));
1758 static_cast<FwAssertArgType>(_status)
1764 _status = msg.serialize(port);
1767 static_cast<FwAssertArgType>(_status)
1770 _status = msg.serialize(opCode);
1773 static_cast<FwAssertArgType>(_status)
1776 _status = msg.serialize(cmdSeq);
1779 static_cast<FwAssertArgType>(_status)
1782 _status = msg.serialize(args);
1785 static_cast<FwAssertArgType>(_status)
1794 static_cast<FwAssertArgType>(qStatus)
1810 ComponentIpcSerializableBuffer msg;
1814 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_STEP));
1817 static_cast<FwAssertArgType>(_status)
1823 _status = msg.serialize(port);
1826 static_cast<FwAssertArgType>(_status)
1829 _status = msg.serialize(opCode);
1832 static_cast<FwAssertArgType>(_status)
1835 _status = msg.serialize(cmdSeq);
1838 static_cast<FwAssertArgType>(_status)
1841 _status = msg.serialize(args);
1844 static_cast<FwAssertArgType>(_status)
1853 static_cast<FwAssertArgType>(qStatus)
1869 ComponentIpcSerializableBuffer msg;
1873 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_AUTO));
1876 static_cast<FwAssertArgType>(_status)
1882 _status = msg.serialize(port);
1885 static_cast<FwAssertArgType>(_status)
1888 _status = msg.serialize(opCode);
1891 static_cast<FwAssertArgType>(_status)
1894 _status = msg.serialize(cmdSeq);
1897 static_cast<FwAssertArgType>(_status)
1900 _status = msg.serialize(args);
1903 static_cast<FwAssertArgType>(_status)
1912 static_cast<FwAssertArgType>(qStatus)
1928 ComponentIpcSerializableBuffer msg;
1932 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_MANUAL));
1935 static_cast<FwAssertArgType>(_status)
1941 _status = msg.serialize(port);
1944 static_cast<FwAssertArgType>(_status)
1947 _status = msg.serialize(opCode);
1950 static_cast<FwAssertArgType>(_status)
1953 _status = msg.serialize(cmdSeq);
1956 static_cast<FwAssertArgType>(_status)
1959 _status = msg.serialize(args);
1962 static_cast<FwAssertArgType>(_status)
1971 static_cast<FwAssertArgType>(qStatus)
1987 ComponentIpcSerializableBuffer msg;
1991 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_CS_JOIN_WAIT));
1994 static_cast<FwAssertArgType>(_status)
2000 _status = msg.serialize(port);
2003 static_cast<FwAssertArgType>(_status)
2006 _status = msg.serialize(opCode);
2009 static_cast<FwAssertArgType>(_status)
2012 _status = msg.serialize(cmdSeq);
2015 static_cast<FwAssertArgType>(_status)
2018 _status = msg.serialize(args);
2021 static_cast<FwAssertArgType>(_status)
2030 static_cast<FwAssertArgType>(qStatus)
2139 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2140 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2148 if (this->m_logOut_OutputPort[0].isConnected()) {
2152 #if FW_AMPCS_COMPATIBLE 2154 _status = _logBuff.
serialize(static_cast<U8>(1));
2157 static_cast<FwAssertArgType>(_status)
2164 static_cast<FwAssertArgType>(_status)
2167 this->m_logOut_OutputPort[0].
invoke(
2176 #if FW_ENABLE_TEXT_LOGGING 2177 if (this->m_LogText_OutputPort[0].isConnected()) {
2178 #if FW_OBJECT_NAMES == 1 2179 const char* _formatString =
2180 "(%s) %s: Loaded sequence %s";
2182 const char* _formatString =
2183 "%s: Loaded sequence %s";
2190 this->m_objName.toChar(),
2192 "CS_SequenceLoaded ",
2196 this->m_LogText_OutputPort[0].invoke(
2211 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2212 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2220 if (this->m_logOut_OutputPort[0].isConnected()) {
2224 #if FW_AMPCS_COMPATIBLE 2226 _status = _logBuff.
serialize(static_cast<U8>(1));
2229 static_cast<FwAssertArgType>(_status)
2236 static_cast<FwAssertArgType>(_status)
2239 this->m_logOut_OutputPort[0].
invoke(
2248 #if FW_ENABLE_TEXT_LOGGING 2249 if (this->m_LogText_OutputPort[0].isConnected()) {
2250 #if FW_OBJECT_NAMES == 1 2251 const char* _formatString =
2252 "(%s) %s: Sequence file %s canceled";
2254 const char* _formatString =
2255 "%s: Sequence file %s canceled";
2262 this->m_objName.toChar(),
2264 "CS_SequenceCanceled ",
2268 this->m_LogText_OutputPort[0].invoke(
2283 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2284 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2292 if (this->m_logOut_OutputPort[0].isConnected()) {
2296 #if FW_AMPCS_COMPATIBLE 2298 _status = _logBuff.
serialize(static_cast<U8>(1));
2301 static_cast<FwAssertArgType>(_status)
2308 static_cast<FwAssertArgType>(_status)
2311 this->m_logOut_OutputPort[0].
invoke(
2320 #if FW_ENABLE_TEXT_LOGGING 2321 if (this->m_LogText_OutputPort[0].isConnected()) {
2322 #if FW_OBJECT_NAMES == 1 2323 const char* _formatString =
2324 "(%s) %s: Error reading sequence file %s";
2326 const char* _formatString =
2327 "%s: Error reading sequence file %s";
2334 this->m_objName.toChar(),
2336 "CS_FileReadError ",
2340 this->m_LogText_OutputPort[0].invoke(
2359 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2360 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2368 if (this->m_logOut_OutputPort[0].isConnected()) {
2372 #if FW_AMPCS_COMPATIBLE 2374 _status = _logBuff.
serialize(static_cast<U8>(3));
2377 static_cast<FwAssertArgType>(_status)
2384 static_cast<FwAssertArgType>(_status)
2387 #if FW_AMPCS_COMPATIBLE 2394 static_cast<FwAssertArgType>(_status)
2400 static_cast<FwAssertArgType>(_status)
2403 #if FW_AMPCS_COMPATIBLE 2406 static_cast<U8>(
sizeof(I32))
2410 static_cast<FwAssertArgType>(_status)
2416 static_cast<FwAssertArgType>(_status)
2419 this->m_logOut_OutputPort[0].
invoke(
2428 #if FW_ENABLE_TEXT_LOGGING 2429 if (this->m_LogText_OutputPort[0].isConnected()) {
2430 #if FW_OBJECT_NAMES == 1 2431 const char* _formatString =
2432 "(%s) %s: Sequence file %s invalid. Stage: %s Error: %" PRIi32
"";
2434 const char* _formatString =
2435 "%s: Sequence file %s invalid. Stage: %s Error: %" PRIi32
"";
2439 stage.toString(stageStr);
2445 this->m_objName.toChar(),
2453 this->m_LogText_OutputPort[0].invoke(
2472 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2473 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2481 if (this->m_logOut_OutputPort[0].isConnected()) {
2485 #if FW_AMPCS_COMPATIBLE 2487 _status = _logBuff.
serialize(static_cast<U8>(3));
2490 static_cast<FwAssertArgType>(_status)
2497 static_cast<FwAssertArgType>(_status)
2500 #if FW_AMPCS_COMPATIBLE 2503 static_cast<U8>(
sizeof(U32))
2507 static_cast<FwAssertArgType>(_status)
2510 _status = _logBuff.
serialize(recordNumber);
2513 static_cast<FwAssertArgType>(_status)
2516 #if FW_AMPCS_COMPATIBLE 2519 static_cast<U8>(
sizeof(I32))
2523 static_cast<FwAssertArgType>(_status)
2529 static_cast<FwAssertArgType>(_status)
2532 this->m_logOut_OutputPort[0].
invoke(
2541 #if FW_ENABLE_TEXT_LOGGING 2542 if (this->m_LogText_OutputPort[0].isConnected()) {
2543 #if FW_OBJECT_NAMES == 1 2544 const char* _formatString =
2545 "(%s) %s: Sequence file %s: Record %" PRIu32
" invalid. Err: %" PRIi32
"";
2547 const char* _formatString =
2548 "%s: Sequence file %s: Record %" PRIu32
" invalid. Err: %" PRIi32
"";
2555 this->m_objName.toChar(),
2557 "CS_RecordInvalid ",
2563 this->m_LogText_OutputPort[0].invoke(
2581 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2582 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2590 if (this->m_logOut_OutputPort[0].isConnected()) {
2594 #if FW_AMPCS_COMPATIBLE 2596 _status = _logBuff.
serialize(static_cast<U8>(2));
2599 static_cast<FwAssertArgType>(_status)
2606 static_cast<FwAssertArgType>(_status)
2609 #if FW_AMPCS_COMPATIBLE 2612 static_cast<U8>(
sizeof(U32))
2616 static_cast<FwAssertArgType>(_status)
2622 static_cast<FwAssertArgType>(_status)
2625 this->m_logOut_OutputPort[0].
invoke(
2634 #if FW_ENABLE_TEXT_LOGGING 2635 if (this->m_LogText_OutputPort[0].isConnected()) {
2636 #if FW_OBJECT_NAMES == 1 2637 const char* _formatString =
2638 "(%s) %s: Sequence file %s too large. Size: %" PRIu32
"";
2640 const char* _formatString =
2641 "%s: Sequence file %s too large. Size: %" PRIu32
"";
2648 this->m_objName.toChar(),
2650 "CS_FileSizeError ",
2655 this->m_LogText_OutputPort[0].invoke(
2670 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2671 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2679 if (this->m_logOut_OutputPort[0].isConnected()) {
2683 #if FW_AMPCS_COMPATIBLE 2685 _status = _logBuff.
serialize(static_cast<U8>(1));
2688 static_cast<FwAssertArgType>(_status)
2695 static_cast<FwAssertArgType>(_status)
2698 this->m_logOut_OutputPort[0].
invoke(
2707 #if FW_ENABLE_TEXT_LOGGING 2708 if (this->m_LogText_OutputPort[0].isConnected()) {
2709 #if FW_OBJECT_NAMES == 1 2710 const char* _formatString =
2711 "(%s) %s: Sequence file %s not found.";
2713 const char* _formatString =
2714 "%s: Sequence file %s not found.";
2721 this->m_objName.toChar(),
2727 this->m_LogText_OutputPort[0].invoke(
2746 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2747 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2755 if (this->m_logOut_OutputPort[0].isConnected()) {
2759 #if FW_AMPCS_COMPATIBLE 2761 _status = _logBuff.
serialize(static_cast<U8>(3));
2764 static_cast<FwAssertArgType>(_status)
2771 static_cast<FwAssertArgType>(_status)
2774 #if FW_AMPCS_COMPATIBLE 2777 static_cast<U8>(
sizeof(U32))
2781 static_cast<FwAssertArgType>(_status)
2784 _status = _logBuff.
serialize(storedCRC);
2787 static_cast<FwAssertArgType>(_status)
2790 #if FW_AMPCS_COMPATIBLE 2793 static_cast<U8>(
sizeof(U32))
2797 static_cast<FwAssertArgType>(_status)
2800 _status = _logBuff.
serialize(computedCRC);
2803 static_cast<FwAssertArgType>(_status)
2806 this->m_logOut_OutputPort[0].
invoke(
2815 #if FW_ENABLE_TEXT_LOGGING 2816 if (this->m_LogText_OutputPort[0].isConnected()) {
2817 #if FW_OBJECT_NAMES == 1 2818 const char* _formatString =
2819 "(%s) %s: Sequence file %s had invalid CRC. Stored 0x%" PRIx32
", Computed 0x%" PRIx32
".";
2821 const char* _formatString =
2822 "%s: Sequence file %s had invalid CRC. Stored 0x%" PRIx32
", Computed 0x%" PRIx32
".";
2829 this->m_objName.toChar(),
2831 "CS_FileCrcFailure ",
2837 this->m_LogText_OutputPort[0].invoke(
2856 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2857 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2865 if (this->m_logOut_OutputPort[0].isConnected()) {
2869 #if FW_AMPCS_COMPATIBLE 2871 _status = _logBuff.
serialize(static_cast<U8>(3));
2874 static_cast<FwAssertArgType>(_status)
2881 static_cast<FwAssertArgType>(_status)
2884 #if FW_AMPCS_COMPATIBLE 2887 static_cast<U8>(
sizeof(U32))
2891 static_cast<FwAssertArgType>(_status)
2894 _status = _logBuff.
serialize(recordNumber);
2897 static_cast<FwAssertArgType>(_status)
2900 #if FW_AMPCS_COMPATIBLE 2903 static_cast<U8>(
sizeof(U32))
2907 static_cast<FwAssertArgType>(_status)
2913 static_cast<FwAssertArgType>(_status)
2916 this->m_logOut_OutputPort[0].
invoke(
2925 #if FW_ENABLE_TEXT_LOGGING 2926 if (this->m_LogText_OutputPort[0].isConnected()) {
2927 #if FW_OBJECT_NAMES == 1 2928 const char* _formatString =
2929 "(%s) %s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") complete";
2931 const char* _formatString =
2932 "%s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") complete";
2939 this->m_objName.toChar(),
2941 "CS_CommandComplete ",
2947 this->m_LogText_OutputPort[0].invoke(
2962 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2963 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2971 if (this->m_logOut_OutputPort[0].isConnected()) {
2975 #if FW_AMPCS_COMPATIBLE 2977 _status = _logBuff.
serialize(static_cast<U8>(1));
2980 static_cast<FwAssertArgType>(_status)
2987 static_cast<FwAssertArgType>(_status)
2990 this->m_logOut_OutputPort[0].
invoke(
2999 #if FW_ENABLE_TEXT_LOGGING 3000 if (this->m_LogText_OutputPort[0].isConnected()) {
3001 #if FW_OBJECT_NAMES == 1 3002 const char* _formatString =
3003 "(%s) %s: Sequence file %s complete";
3005 const char* _formatString =
3006 "%s: Sequence file %s complete";
3013 this->m_objName.toChar(),
3015 "CS_SequenceComplete ",
3019 this->m_LogText_OutputPort[0].invoke(
3039 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3040 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3048 if (this->m_logOut_OutputPort[0].isConnected()) {
3052 #if FW_AMPCS_COMPATIBLE 3054 _status = _logBuff.
serialize(static_cast<U8>(4));
3057 static_cast<FwAssertArgType>(_status)
3064 static_cast<FwAssertArgType>(_status)
3067 #if FW_AMPCS_COMPATIBLE 3070 static_cast<U8>(
sizeof(U32))
3074 static_cast<FwAssertArgType>(_status)
3077 _status = _logBuff.
serialize(recordNumber);
3080 static_cast<FwAssertArgType>(_status)
3083 #if FW_AMPCS_COMPATIBLE 3086 static_cast<U8>(
sizeof(U32))
3090 static_cast<FwAssertArgType>(_status)
3096 static_cast<FwAssertArgType>(_status)
3099 #if FW_AMPCS_COMPATIBLE 3102 static_cast<U8>(
sizeof(U32))
3106 static_cast<FwAssertArgType>(_status)
3109 _status = _logBuff.
serialize(errorStatus);
3112 static_cast<FwAssertArgType>(_status)
3115 this->m_logOut_OutputPort[0].
invoke(
3124 #if FW_ENABLE_TEXT_LOGGING 3125 if (this->m_LogText_OutputPort[0].isConnected()) {
3126 #if FW_OBJECT_NAMES == 1 3127 const char* _formatString =
3128 "(%s) %s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") completed with error %" PRIu32
"";
3130 const char* _formatString =
3131 "%s: Sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") completed with error %" PRIu32
"";
3138 this->m_objName.toChar(),
3147 this->m_LogText_OutputPort[0].invoke(
3162 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3163 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3171 if (this->m_logOut_OutputPort[0].isConnected()) {
3174 #if FW_AMPCS_COMPATIBLE 3177 _status = _logBuff.
serialize(static_cast<U8>(0));
3180 static_cast<FwAssertArgType>(_status)
3184 this->m_logOut_OutputPort[0].
invoke(
3193 #if FW_ENABLE_TEXT_LOGGING 3194 if (this->m_LogText_OutputPort[0].isConnected()) {
3195 #if FW_OBJECT_NAMES == 1 3196 const char* _formatString =
3197 "(%s) %s: Invalid mode";
3199 const char* _formatString =
3207 this->m_objName.toChar(),
3212 this->m_LogText_OutputPort[0].invoke(
3231 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3232 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3240 if (this->m_logOut_OutputPort[0].isConnected()) {
3244 #if FW_AMPCS_COMPATIBLE 3246 _status = _logBuff.
serialize(static_cast<U8>(3));
3249 static_cast<FwAssertArgType>(_status)
3256 static_cast<FwAssertArgType>(_status)
3259 #if FW_AMPCS_COMPATIBLE 3262 static_cast<U8>(
sizeof(U32))
3266 static_cast<FwAssertArgType>(_status)
3269 _status = _logBuff.
serialize(header_records);
3272 static_cast<FwAssertArgType>(_status)
3275 #if FW_AMPCS_COMPATIBLE 3278 static_cast<U8>(
sizeof(U32))
3282 static_cast<FwAssertArgType>(_status)
3285 _status = _logBuff.
serialize(extra_bytes);
3288 static_cast<FwAssertArgType>(_status)
3291 this->m_logOut_OutputPort[0].
invoke(
3300 #if FW_ENABLE_TEXT_LOGGING 3301 if (this->m_LogText_OutputPort[0].isConnected()) {
3302 #if FW_OBJECT_NAMES == 1 3303 const char* _formatString =
3304 "(%s) %s: Sequence file %s header records mismatch: %" PRIu32
" in header, found %" PRIu32
" extra bytes.";
3306 const char* _formatString =
3307 "%s: Sequence file %s header records mismatch: %" PRIu32
" in header, found %" PRIu32
" extra bytes.";
3314 this->m_objName.toChar(),
3316 "CS_RecordMismatch ",
3322 this->m_LogText_OutputPort[0].invoke(
3341 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3342 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3350 if (this->m_logOut_OutputPort[0].isConnected()) {
3354 #if FW_AMPCS_COMPATIBLE 3356 _status = _logBuff.
serialize(static_cast<U8>(3));
3359 static_cast<FwAssertArgType>(_status)
3366 static_cast<FwAssertArgType>(_status)
3369 #if FW_AMPCS_COMPATIBLE 3372 static_cast<U8>(
sizeof(U16))
3376 static_cast<FwAssertArgType>(_status)
3379 _status = _logBuff.
serialize(time_base);
3382 static_cast<FwAssertArgType>(_status)
3385 #if FW_AMPCS_COMPATIBLE 3388 static_cast<U8>(
sizeof(U16))
3392 static_cast<FwAssertArgType>(_status)
3395 _status = _logBuff.
serialize(seq_time_base);
3398 static_cast<FwAssertArgType>(_status)
3401 this->m_logOut_OutputPort[0].
invoke(
3410 #if FW_ENABLE_TEXT_LOGGING 3411 if (this->m_LogText_OutputPort[0].isConnected()) {
3412 #if FW_OBJECT_NAMES == 1 3413 const char* _formatString =
3414 "(%s) %s: Sequence file %s: Current time base doesn't match sequence time: base: %" PRIu16
" seq: %" PRIu16
"";
3416 const char* _formatString =
3417 "%s: Sequence file %s: Current time base doesn't match sequence time: base: %" PRIu16
" seq: %" PRIu16
"";
3424 this->m_objName.toChar(),
3426 "CS_TimeBaseMismatch ",
3432 this->m_LogText_OutputPort[0].invoke(
3451 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3452 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3460 if (this->m_logOut_OutputPort[0].isConnected()) {
3464 #if FW_AMPCS_COMPATIBLE 3466 _status = _logBuff.
serialize(static_cast<U8>(3));
3469 static_cast<FwAssertArgType>(_status)
3476 static_cast<FwAssertArgType>(_status)
3479 #if FW_AMPCS_COMPATIBLE 3482 static_cast<U8>(
sizeof(
U8))
3486 static_cast<FwAssertArgType>(_status)
3489 _status = _logBuff.
serialize(currTimeBase);
3492 static_cast<FwAssertArgType>(_status)
3495 #if FW_AMPCS_COMPATIBLE 3498 static_cast<U8>(
sizeof(
U8))
3502 static_cast<FwAssertArgType>(_status)
3505 _status = _logBuff.
serialize(seqTimeBase);
3508 static_cast<FwAssertArgType>(_status)
3511 this->m_logOut_OutputPort[0].
invoke(
3520 #if FW_ENABLE_TEXT_LOGGING 3521 if (this->m_LogText_OutputPort[0].isConnected()) {
3522 #if FW_OBJECT_NAMES == 1 3523 const char* _formatString =
3524 "(%s) %s: Sequence file %s: Current time context doesn't match sequence context: base: %" PRIu8
" seq: %" PRIu8
"";
3526 const char* _formatString =
3527 "%s: Sequence file %s: Current time context doesn't match sequence context: base: %" PRIu8
" seq: %" PRIu8
"";
3534 this->m_objName.toChar(),
3536 "CS_TimeContextMismatch ",
3542 this->m_LogText_OutputPort[0].invoke(
3557 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3558 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3566 if (this->m_logOut_OutputPort[0].isConnected()) {
3570 #if FW_AMPCS_COMPATIBLE 3572 _status = _logBuff.
serialize(static_cast<U8>(1));
3575 static_cast<FwAssertArgType>(_status)
3582 static_cast<FwAssertArgType>(_status)
3585 this->m_logOut_OutputPort[0].
invoke(
3594 #if FW_ENABLE_TEXT_LOGGING 3595 if (this->m_LogText_OutputPort[0].isConnected()) {
3596 #if FW_OBJECT_NAMES == 1 3597 const char* _formatString =
3598 "(%s) %s: Local request for sequence %s started.";
3600 const char* _formatString =
3601 "%s: Local request for sequence %s started.";
3608 this->m_objName.toChar(),
3610 "CS_PortSequenceStarted ",
3614 this->m_LogText_OutputPort[0].invoke(
3629 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3630 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3638 if (this->m_logOut_OutputPort[0].isConnected()) {
3642 #if FW_AMPCS_COMPATIBLE 3644 _status = _logBuff.
serialize(static_cast<U8>(1));
3647 static_cast<FwAssertArgType>(_status)
3651 #if FW_AMPCS_COMPATIBLE 3654 static_cast<U8>(
sizeof(U32))
3658 static_cast<FwAssertArgType>(_status)
3664 static_cast<FwAssertArgType>(_status)
3667 this->m_logOut_OutputPort[0].
invoke(
3676 #if FW_ENABLE_TEXT_LOGGING 3677 if (this->m_LogText_OutputPort[0].isConnected()) {
3678 #if FW_OBJECT_NAMES == 1 3679 const char* _formatString =
3680 "(%s) %s: Command complete status received while no sequences active. Opcode: %" PRIu32
"";
3682 const char* _formatString =
3683 "%s: Command complete status received while no sequences active. Opcode: %" PRIu32
"";
3690 this->m_objName.toChar(),
3692 "CS_UnexpectedCompletion ",
3696 this->m_LogText_OutputPort[0].invoke(
3711 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3712 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3720 if (this->m_logOut_OutputPort[0].isConnected()) {
3724 #if FW_AMPCS_COMPATIBLE 3726 _status = _logBuff.
serialize(static_cast<U8>(1));
3729 static_cast<FwAssertArgType>(_status)
3733 #if FW_AMPCS_COMPATIBLE 3740 static_cast<FwAssertArgType>(_status)
3746 static_cast<FwAssertArgType>(_status)
3749 this->m_logOut_OutputPort[0].
invoke(
3758 #if FW_ENABLE_TEXT_LOGGING 3759 if (this->m_LogText_OutputPort[0].isConnected()) {
3760 #if FW_OBJECT_NAMES == 1 3761 const char* _formatString =
3762 "(%s) %s: Sequencer switched to %s step mode";
3764 const char* _formatString =
3765 "%s: Sequencer switched to %s step mode";
3769 mode.toString(modeStr);
3775 this->m_objName.toChar(),
3781 this->m_LogText_OutputPort[0].invoke(
3796 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3797 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3805 if (this->m_logOut_OutputPort[0].isConnected()) {
3808 #if FW_AMPCS_COMPATIBLE 3811 _status = _logBuff.
serialize(static_cast<U8>(0));
3814 static_cast<FwAssertArgType>(_status)
3818 this->m_logOut_OutputPort[0].
invoke(
3827 #if FW_ENABLE_TEXT_LOGGING 3828 if (this->m_LogText_OutputPort[0].isConnected()) {
3829 #if FW_OBJECT_NAMES == 1 3830 const char* _formatString =
3831 "(%s) %s: No sequence active.";
3833 const char* _formatString =
3834 "%s: No sequence active.";
3841 this->m_objName.toChar(),
3843 "CS_NoSequenceActive " 3846 this->m_LogText_OutputPort[0].invoke(
3861 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3862 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3870 if (this->m_logOut_OutputPort[0].isConnected()) {
3874 #if FW_AMPCS_COMPATIBLE 3876 _status = _logBuff.
serialize(static_cast<U8>(1));
3879 static_cast<FwAssertArgType>(_status)
3886 static_cast<FwAssertArgType>(_status)
3889 this->m_logOut_OutputPort[0].
invoke(
3898 #if FW_ENABLE_TEXT_LOGGING 3899 if (this->m_LogText_OutputPort[0].isConnected()) {
3900 #if FW_OBJECT_NAMES == 1 3901 const char* _formatString =
3902 "(%s) %s: Sequence %s is valid.";
3904 const char* _formatString =
3905 "%s: Sequence %s is valid.";
3912 this->m_objName.toChar(),
3914 "CS_SequenceValid ",
3918 this->m_LogText_OutputPort[0].invoke(
3936 if (this->m_timeCaller_OutputPort[0].isConnected()) {
3937 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
3945 if (this->m_logOut_OutputPort[0].isConnected()) {
3949 #if FW_AMPCS_COMPATIBLE 3951 _status = _logBuff.
serialize(static_cast<U8>(2));
3954 static_cast<FwAssertArgType>(_status)
3961 static_cast<FwAssertArgType>(_status)
3964 #if FW_AMPCS_COMPATIBLE 3967 static_cast<U8>(
sizeof(U32))
3971 static_cast<FwAssertArgType>(_status)
3977 static_cast<FwAssertArgType>(_status)
3980 this->m_logOut_OutputPort[0].
invoke(
3989 #if FW_ENABLE_TEXT_LOGGING 3990 if (this->m_LogText_OutputPort[0].isConnected()) {
3991 #if FW_OBJECT_NAMES == 1 3992 const char* _formatString =
3993 "(%s) %s: Sequence %s timed out on command %" PRIu32
"";
3995 const char* _formatString =
3996 "%s: Sequence %s timed out on command %" PRIu32
"";
4003 this->m_objName.toChar(),
4005 "CS_SequenceTimeout ",
4010 this->m_LogText_OutputPort[0].invoke(
4028 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4029 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4037 if (this->m_logOut_OutputPort[0].isConnected()) {
4041 #if FW_AMPCS_COMPATIBLE 4043 _status = _logBuff.
serialize(static_cast<U8>(2));
4046 static_cast<FwAssertArgType>(_status)
4053 static_cast<FwAssertArgType>(_status)
4056 #if FW_AMPCS_COMPATIBLE 4059 static_cast<U8>(
sizeof(U32))
4063 static_cast<FwAssertArgType>(_status)
4069 static_cast<FwAssertArgType>(_status)
4072 this->m_logOut_OutputPort[0].
invoke(
4081 #if FW_ENABLE_TEXT_LOGGING 4082 if (this->m_LogText_OutputPort[0].isConnected()) {
4083 #if FW_OBJECT_NAMES == 1 4084 const char* _formatString =
4085 "(%s) %s: Sequence %s command %" PRIu32
" stepped";
4087 const char* _formatString =
4088 "%s: Sequence %s command %" PRIu32
" stepped";
4095 this->m_objName.toChar(),
4102 this->m_LogText_OutputPort[0].invoke(
4117 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4118 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4126 if (this->m_logOut_OutputPort[0].isConnected()) {
4130 #if FW_AMPCS_COMPATIBLE 4132 _status = _logBuff.
serialize(static_cast<U8>(1));
4135 static_cast<FwAssertArgType>(_status)
4142 static_cast<FwAssertArgType>(_status)
4145 this->m_logOut_OutputPort[0].
invoke(
4154 #if FW_ENABLE_TEXT_LOGGING 4155 if (this->m_LogText_OutputPort[0].isConnected()) {
4156 #if FW_OBJECT_NAMES == 1 4157 const char* _formatString =
4158 "(%s) %s: Sequence %s started";
4160 const char* _formatString =
4161 "%s: Sequence %s started";
4168 this->m_objName.toChar(),
4174 this->m_LogText_OutputPort[0].invoke(
4193 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4194 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4202 if (this->m_logOut_OutputPort[0].isConnected()) {
4206 #if FW_AMPCS_COMPATIBLE 4208 _status = _logBuff.
serialize(static_cast<U8>(3));
4211 static_cast<FwAssertArgType>(_status)
4218 static_cast<FwAssertArgType>(_status)
4221 #if FW_AMPCS_COMPATIBLE 4224 static_cast<U8>(
sizeof(U32))
4228 static_cast<FwAssertArgType>(_status)
4231 _status = _logBuff.
serialize(recordNumber);
4234 static_cast<FwAssertArgType>(_status)
4237 #if FW_AMPCS_COMPATIBLE 4240 static_cast<U8>(
sizeof(U32))
4244 static_cast<FwAssertArgType>(_status)
4250 static_cast<FwAssertArgType>(_status)
4253 this->m_logOut_OutputPort[0].
invoke(
4262 #if FW_ENABLE_TEXT_LOGGING 4263 if (this->m_LogText_OutputPort[0].isConnected()) {
4264 #if FW_OBJECT_NAMES == 1 4265 const char* _formatString =
4266 "(%s) %s: Start waiting for sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") to complete";
4268 const char* _formatString =
4269 "%s: Start waiting for sequence file %s: Command %" PRIu32
" (opcode %" PRIu32
") to complete";
4276 this->m_objName.toChar(),
4284 this->m_LogText_OutputPort[0].invoke(
4299 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4300 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4308 if (this->m_logOut_OutputPort[0].isConnected()) {
4311 #if FW_AMPCS_COMPATIBLE 4314 _status = _logBuff.
serialize(static_cast<U8>(0));
4317 static_cast<FwAssertArgType>(_status)
4321 this->m_logOut_OutputPort[0].
invoke(
4330 #if FW_ENABLE_TEXT_LOGGING 4331 if (this->m_LogText_OutputPort[0].isConnected()) {
4332 #if FW_OBJECT_NAMES == 1 4333 const char* _formatString =
4334 "(%s) %s: Still waiting for sequence file to complete";
4336 const char* _formatString =
4337 "%s: Still waiting for sequence file to complete";
4344 this->m_objName.toChar(),
4346 "CS_JoinWaitingNotComplete " 4349 this->m_LogText_OutputPort[0].invoke(
4364 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4365 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
4373 if (this->m_logOut_OutputPort[0].isConnected()) {
4377 #if FW_AMPCS_COMPATIBLE 4379 _status = _logBuff.
serialize(static_cast<U8>(1));
4382 static_cast<FwAssertArgType>(_status)
4389 static_cast<FwAssertArgType>(_status)
4392 this->m_logOut_OutputPort[0].
invoke(
4401 #if FW_ENABLE_TEXT_LOGGING 4402 if (this->m_LogText_OutputPort[0].isConnected()) {
4403 #if FW_OBJECT_NAMES == 1 4404 const char* _formatString =
4405 "(%s) %s: Sequence file %s has no records. Ignoring.";
4407 const char* _formatString =
4408 "%s: Sequence file %s has no records. Ignoring.";
4415 this->m_objName.toChar(),
4421 this->m_LogText_OutputPort[0].invoke(
4441 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4443 this->m_timeCaller_OutputPort[0].isConnected() &&
4446 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4453 static_cast<FwAssertArgType>(_stat)
4460 this->m_tlmOut_OutputPort[0].
invoke(
4474 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4476 this->m_timeCaller_OutputPort[0].isConnected() &&
4479 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4486 static_cast<FwAssertArgType>(_stat)
4493 this->m_tlmOut_OutputPort[0].
invoke(
4507 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4509 this->m_timeCaller_OutputPort[0].isConnected() &&
4512 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4519 static_cast<FwAssertArgType>(_stat)
4526 this->m_tlmOut_OutputPort[0].
invoke(
4540 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4542 this->m_timeCaller_OutputPort[0].isConnected() &&
4545 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4552 static_cast<FwAssertArgType>(_stat)
4559 this->m_tlmOut_OutputPort[0].
invoke(
4573 if (this->m_tlmOut_OutputPort[0].isConnected()) {
4575 this->m_timeCaller_OutputPort[0].isConnected() &&
4578 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
4585 static_cast<FwAssertArgType>(_stat)
4592 this->m_tlmOut_OutputPort[0].
invoke(
4607 if (this->m_timeCaller_OutputPort[0].isConnected()) {
4609 this->m_timeCaller_OutputPort[0].
invoke(_time);
4624 ComponentIpcSerializableBuffer _msg;
4634 static_cast<FwAssertArgType>(_msgStatus)
4644 static_cast<FwAssertArgType>(_deserStatus)
4647 MsgTypeEnum _msgType =
static_cast<MsgTypeEnum
>(_desMsg);
4649 if (_msgType == CMDSEQUENCER_COMPONENT_EXIT) {
4654 _deserStatus = _msg.deserialize(portNum);
4657 static_cast<FwAssertArgType>(_deserStatus)
4662 case CMDRESPONSEIN_CMDRESPONSE: {
4665 _deserStatus = _msg.deserialize(opCode);
4668 static_cast<FwAssertArgType>(_deserStatus)
4673 _deserStatus = _msg.deserialize(cmdSeq);
4676 static_cast<FwAssertArgType>(_deserStatus)
4681 _deserStatus = _msg.deserialize(response);
4684 static_cast<FwAssertArgType>(_deserStatus)
4701 _deserStatus = _msg.deserialize(key);
4704 static_cast<FwAssertArgType>(_deserStatus)
4716 case SCHEDIN_SCHED: {
4719 _deserStatus = _msg.deserialize(context);
4722 static_cast<FwAssertArgType>(_deserStatus)
4734 case SEQCANCELIN_CMDSEQCANCEL: {
4742 case SEQRUNIN_CMDSEQIN: {
4745 Fw::ExternalString filename(__fprime_ac_filename_buffer,
sizeof __fprime_ac_filename_buffer);
4746 _deserStatus = _msg.deserialize(filename);
4749 static_cast<FwAssertArgType>(_deserStatus)
4764 _deserStatus = _msg.deserialize(_opCode);
4767 static_cast<FwAssertArgType>(_deserStatus)
4772 _deserStatus = _msg.deserialize(_cmdSeq);
4775 static_cast<FwAssertArgType>(_deserStatus)
4780 _deserStatus = _msg.deserialize(args);
4783 static_cast<FwAssertArgType>(_deserStatus)
4793 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4808 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4821 #if FW_CMD_CHECK_RESIDUAL 4823 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4842 case CMD_CS_VALIDATE: {
4845 _deserStatus = _msg.deserialize(_opCode);
4848 static_cast<FwAssertArgType>(_deserStatus)
4853 _deserStatus = _msg.deserialize(_cmdSeq);
4856 static_cast<FwAssertArgType>(_deserStatus)
4861 _deserStatus = _msg.deserialize(args);
4864 static_cast<FwAssertArgType>(_deserStatus)
4874 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4887 #if FW_CMD_CHECK_RESIDUAL 4889 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4907 case CMD_CS_CANCEL: {
4910 _deserStatus = _msg.deserialize(_opCode);
4913 static_cast<FwAssertArgType>(_deserStatus)
4918 _deserStatus = _msg.deserialize(_cmdSeq);
4921 static_cast<FwAssertArgType>(_deserStatus)
4926 _deserStatus = _msg.deserialize(args);
4929 static_cast<FwAssertArgType>(_deserStatus)
4937 #if FW_CMD_CHECK_RESIDUAL 4939 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
4954 case CMD_CS_START: {
4957 _deserStatus = _msg.deserialize(_opCode);
4960 static_cast<FwAssertArgType>(_deserStatus)
4965 _deserStatus = _msg.deserialize(_cmdSeq);
4968 static_cast<FwAssertArgType>(_deserStatus)
4973 _deserStatus = _msg.deserialize(args);
4976 static_cast<FwAssertArgType>(_deserStatus)
4984 #if FW_CMD_CHECK_RESIDUAL 4986 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5004 _deserStatus = _msg.deserialize(_opCode);
5007 static_cast<FwAssertArgType>(_deserStatus)
5012 _deserStatus = _msg.deserialize(_cmdSeq);
5015 static_cast<FwAssertArgType>(_deserStatus)
5020 _deserStatus = _msg.deserialize(args);
5023 static_cast<FwAssertArgType>(_deserStatus)
5031 #if FW_CMD_CHECK_RESIDUAL 5033 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5051 _deserStatus = _msg.deserialize(_opCode);
5054 static_cast<FwAssertArgType>(_deserStatus)
5059 _deserStatus = _msg.deserialize(_cmdSeq);
5062 static_cast<FwAssertArgType>(_deserStatus)
5067 _deserStatus = _msg.deserialize(args);
5070 static_cast<FwAssertArgType>(_deserStatus)
5078 #if FW_CMD_CHECK_RESIDUAL 5080 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5095 case CMD_CS_MANUAL: {
5098 _deserStatus = _msg.deserialize(_opCode);
5101 static_cast<FwAssertArgType>(_deserStatus)
5106 _deserStatus = _msg.deserialize(_cmdSeq);
5109 static_cast<FwAssertArgType>(_deserStatus)
5114 _deserStatus = _msg.deserialize(args);
5117 static_cast<FwAssertArgType>(_deserStatus)
5125 #if FW_CMD_CHECK_RESIDUAL 5127 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5142 case CMD_CS_JOIN_WAIT: {
5145 _deserStatus = _msg.deserialize(_opCode);
5148 static_cast<FwAssertArgType>(_deserStatus)
5153 _deserStatus = _msg.deserialize(_cmdSeq);
5156 static_cast<FwAssertArgType>(_deserStatus)
5161 _deserStatus = _msg.deserialize(args);
5164 static_cast<FwAssertArgType>(_deserStatus)
5172 #if FW_CMD_CHECK_RESIDUAL 5174 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
5199 void CmdSequencerComponentBase ::
5211 const U32 idBase = callComp->
getIdBase();
5212 FW_ASSERT(opCode >= idBase, static_cast<FwAssertArgType>(opCode), static_cast<FwAssertArgType>(idBase));
5215 switch (opCode - idBase) {
5217 compPtr->CS_RUN_cmdHandlerBase(
5226 compPtr->CS_VALIDATE_cmdHandlerBase(
5235 compPtr->CS_CANCEL_cmdHandlerBase(
5244 compPtr->CS_START_cmdHandlerBase(
5253 compPtr->CS_STEP_cmdHandlerBase(
5262 compPtr->CS_AUTO_cmdHandlerBase(
5271 compPtr->CS_MANUAL_cmdHandlerBase(
5280 compPtr->CS_JOIN_WAIT_cmdHandlerBase(
5294 void CmdSequencerComponentBase ::
5295 m_p_cmdResponseIn_in(
5305 compPtr->cmdResponseIn_handlerBase(
5313 void CmdSequencerComponentBase ::
5322 compPtr->pingIn_handlerBase(
5328 void CmdSequencerComponentBase ::
5337 compPtr->schedIn_handlerBase(
5343 void CmdSequencerComponentBase ::
5351 compPtr->seqCancelIn_handlerBase(portNum);
5354 void CmdSequencerComponentBase ::
5363 compPtr->seqRunIn_handlerBase(
The sequence file was too large.
void set_timeCaller_OutputPort(FwIndexType portNum, Fw::InputTimePort *port)
Connect port to timeCaller[portNum].
A command in a sequence was stepped through.
Serialization/Deserialization operation was successful.
void log_WARNING_HI_CS_TimeContextMismatch(const Fw::StringBase &fileName, U8 currTimeBase, U8 seqTimeBase) const
A command sequence successfully completed.
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.
The size of the serial representation.
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.
The running time base doesn't match the time base in the sequence files.
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
Wait for the current running sequence file complete.
void log_ACTIVITY_HI_CS_ModeSwitched(Svc::CmdSequencer_SeqMode mode) const
Channel ID for CS_CommandsExecuted.
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.
Channel ID for CS_SequencesCompleted.
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)
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.
FwIndexType getNum_cmdIn_InputPorts() const
Channel ID for CS_LoadCommands.
void init()
Initialization function.
virtual void schedIn_preMsgHook(FwIndexType portNum, U32 context)
Pre-message hook for async input port schedIn.
The Command Sequencer issued a command and received an error status in return.
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
void log_WARNING_HI_CS_UnexpectedCompletion(U32 opcode) const
PlatformSizeType FwSizeType
FwIndexType getNum_cmdResponseOut_OutputPorts() const
void CS_STEP_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
void invoke(U32 key) const
Invoke a port interface.
Set the run mode to MANUAL.
Sequence file was successfully loaded.
void pingOut_out(FwIndexType portNum, U32 key)
Invoke output port pingOut.
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.
Cancel a command sequence.
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.
A sequence passed validation.
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.
A sequence related command came with no active sequence.
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.
void addCallPort(InputCmdRegPort *callPort)
Register an input port.
Run a command sequence file.
A command status came back when no sequence was running.
The running time base doesn't match the time base in the sequence files.
PlatformIndexType FwIndexType
Validate a command sequence file.
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
FwIndexType getNum_schedIn_InputPorts() const
The Command Sequencer issued a command and received a success status in return.
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.
The sequence file validation failed.
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.
void tlmWrite_CS_CancelCommands(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
virtual ~CmdSequencerComponentBase()
Destroy CmdSequencerComponentBase object.
void tlmWrite_CS_CommandsExecuted(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
The format of a command record was invalid.
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.
message to exit active component task
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
#define FW_MIN(a, b)
MIN macro.
A less serious but recoverable event.
void init()
Initialization function.
bool isConnected_pingOut_OutputPort(FwIndexType portNum)
Start running a command sequence.
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.
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
Channel ID for CS_Errors.
virtual void seqRunIn_handler(FwIndexType portNum, const Fw::StringBase &filename)=0
Handler for input port seqRunIn.
void resetDeser()
reset deserialization to beginning
The Sequence File Loader could not read the sequence file.
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 Command Sequencer received a command that was invalid for its current mode.
Set the run mode to AUTO.
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
A manual sequence was started.
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
A local port request to run a sequence was started.
Channel ID for CS_CancelCommands.
virtual void CS_MANUAL_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command CS_MANUAL.
bool isConnected_cmdRegOut_OutputPort(FwIndexType portNum)
void CS_CANCEL_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
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)
Number of records in header doesn't match number in file.
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
Perform one step in a command sequence. Valid only if CmdSequencer is in MANUAL run mode...
FwIndexType getNum_seqStartOut_OutputPorts() const
Cannot run new sequence when current sequence file is still running.
void addCallPort(InputComPort *callPort)
Register an input port.
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.
The sequence file format was invalid.
Message will return with status when space is unavailable.
A sequence passed validation.
Status receive(U8 *destination, FwSizeType capacity, BlockingType blockType, FwSizeType &actualSize, FwQueuePriorityType &priority) override
receive a message from the queue through delegate
Wait for sequences that are running to finish. Allow user to run multiple seq files in SEQ_NO_BLOCK m...
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
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
The size of the serial representation.
void log_ACTIVITY_HI_CS_SequenceValid(const Fw::StringBase &filename) const
bool isConnected_logOut_OutputPort(FwIndexType portNum)
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)
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
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.
A command sequence was successfully canceled.
The sequence file was not found.