10 #if FW_ENABLE_TEXT_LOGGING 19 SEQDONEIN_CMDRESPONSE,
37 class ComponentIpcSerializableBuffer :
47 MAX_DATA_SIZE =
sizeof(BuffUnion),
49 SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE
53 return sizeof(m_buff);
60 const U8* getBuffAddr()
const {
66 U8 m_buff[SERIALIZATION_SIZE];
90 this->m_cmdIn_InputPort[port].
init();
95 this->m_cmdIn_InputPort[port].
setPortNum(port);
97 #if FW_OBJECT_NAMES == 1 100 "%s_cmdIn_InputPort[%" PRI_PlatformIntType
"]",
101 this->m_objName.toChar(),
104 this->m_cmdIn_InputPort[port].setObjName(portName.
toChar());
114 this->m_seqDoneIn_InputPort[port].
init();
119 this->m_seqDoneIn_InputPort[port].
setPortNum(port);
121 #if FW_OBJECT_NAMES == 1 124 "%s_seqDoneIn_InputPort[%" PRI_PlatformIntType
"]",
125 this->m_objName.toChar(),
128 this->m_seqDoneIn_InputPort[port].setObjName(portName.
toChar());
138 this->m_seqRunIn_InputPort[port].
init();
143 this->m_seqRunIn_InputPort[port].
setPortNum(port);
145 #if FW_OBJECT_NAMES == 1 148 "%s_seqRunIn_InputPort[%" PRI_PlatformIntType
"]",
149 this->m_objName.toChar(),
152 this->m_seqRunIn_InputPort[port].setObjName(portName.
toChar());
162 this->m_seqStartIn_InputPort[port].
init();
167 this->m_seqStartIn_InputPort[port].
setPortNum(port);
169 #if FW_OBJECT_NAMES == 1 172 "%s_seqStartIn_InputPort[%" PRI_PlatformIntType
"]",
173 this->m_objName.toChar(),
176 this->m_seqStartIn_InputPort[port].setObjName(portName.
toChar());
186 this->m_cmdRegOut_OutputPort[port].
init();
188 #if FW_OBJECT_NAMES == 1 191 "%s_cmdRegOut_OutputPort[%" PRI_PlatformIntType
"]",
192 this->m_objName.toChar(),
195 this->m_cmdRegOut_OutputPort[port].setObjName(portName.
toChar());
205 this->m_cmdResponseOut_OutputPort[port].
init();
207 #if FW_OBJECT_NAMES == 1 210 "%s_cmdResponseOut_OutputPort[%" PRI_PlatformIntType
"]",
211 this->m_objName.toChar(),
214 this->m_cmdResponseOut_OutputPort[port].setObjName(portName.
toChar());
224 this->m_logOut_OutputPort[port].
init();
226 #if FW_OBJECT_NAMES == 1 229 "%s_logOut_OutputPort[%" PRI_PlatformIntType
"]",
230 this->m_objName.toChar(),
233 this->m_logOut_OutputPort[port].setObjName(portName.
toChar());
237 #if FW_ENABLE_TEXT_LOGGING == 1 241 port < static_cast<FwIndexType>(this->getNum_logTextOut_OutputPorts());
244 this->m_logTextOut_OutputPort[port].
init();
246 #if FW_OBJECT_NAMES == 1 249 "%s_logTextOut_OutputPort[%" PRI_PlatformIntType
"]",
250 this->m_objName.toChar(),
253 this->m_logTextOut_OutputPort[port].setObjName(portName.
toChar());
264 this->m_timeCaller_OutputPort[port].
init();
266 #if FW_OBJECT_NAMES == 1 269 "%s_timeCaller_OutputPort[%" PRI_PlatformIntType
"]",
270 this->m_objName.toChar(),
273 this->m_timeCaller_OutputPort[port].setObjName(portName.
toChar());
283 this->m_tlmOut_OutputPort[port].
init();
285 #if FW_OBJECT_NAMES == 1 288 "%s_tlmOut_OutputPort[%" PRI_PlatformIntType
"]",
289 this->m_objName.toChar(),
292 this->m_tlmOut_OutputPort[port].setObjName(portName.
toChar());
302 this->m_seqRunOut_OutputPort[port].
init();
304 #if FW_OBJECT_NAMES == 1 307 "%s_seqRunOut_OutputPort[%" PRI_PlatformIntType
"]",
308 this->m_objName.toChar(),
311 this->m_seqRunOut_OutputPort[port].setObjName(portName.
toChar());
318 static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
322 static_cast<FwAssertArgType>(qStat)
335 static_cast<FwAssertArgType>(portNum)
338 return &this->m_cmdIn_InputPort[portNum];
350 static_cast<FwAssertArgType>(portNum)
353 return &this->m_seqDoneIn_InputPort[portNum];
361 static_cast<FwAssertArgType>(portNum)
364 return &this->m_seqRunIn_InputPort[portNum];
372 static_cast<FwAssertArgType>(portNum)
375 return &this->m_seqStartIn_InputPort[portNum];
390 static_cast<FwAssertArgType>(portNum)
393 this->m_cmdRegOut_OutputPort[portNum].
addCallPort(port);
404 static_cast<FwAssertArgType>(portNum)
407 this->m_cmdResponseOut_OutputPort[portNum].
addCallPort(port);
418 static_cast<FwAssertArgType>(portNum)
421 this->m_logOut_OutputPort[portNum].
addCallPort(port);
424 #if FW_ENABLE_TEXT_LOGGING == 1 426 void SeqDispatcherComponentBase ::
427 set_logTextOut_OutputPort(
433 portNum < this->getNum_logTextOut_OutputPorts(),
434 static_cast<FwAssertArgType>(portNum)
437 this->m_logTextOut_OutputPort[portNum].addCallPort(port);
450 static_cast<FwAssertArgType>(portNum)
453 this->m_timeCaller_OutputPort[portNum].
addCallPort(port);
464 static_cast<FwAssertArgType>(portNum)
467 this->m_tlmOut_OutputPort[portNum].
addCallPort(port);
482 static_cast<FwAssertArgType>(portNum)
485 this->m_seqRunOut_OutputPort[portNum].
addCallPort(port);
488 #if FW_PORT_SERIALIZATION 497 Fw::InputSerializePort* port
502 static_cast<FwAssertArgType>(portNum)
505 this->m_cmdRegOut_OutputPort[portNum].registerSerialPort(port);
511 Fw::InputSerializePort* port
516 static_cast<FwAssertArgType>(portNum)
519 this->m_cmdResponseOut_OutputPort[portNum].registerSerialPort(port);
525 Fw::InputSerializePort* port
530 static_cast<FwAssertArgType>(portNum)
533 this->m_logOut_OutputPort[portNum].registerSerialPort(port);
536 #if FW_ENABLE_TEXT_LOGGING == 1 538 void SeqDispatcherComponentBase ::
539 set_logTextOut_OutputPort(
541 Fw::InputSerializePort* port
545 portNum < this->getNum_logTextOut_OutputPorts(),
546 static_cast<FwAssertArgType>(portNum)
549 this->m_logTextOut_OutputPort[portNum].registerSerialPort(port);
557 Fw::InputSerializePort* port
562 static_cast<FwAssertArgType>(portNum)
565 this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
571 Fw::InputSerializePort* port
576 static_cast<FwAssertArgType>(portNum)
579 this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
584 #if FW_PORT_SERIALIZATION 593 Fw::InputSerializePort* port
598 static_cast<FwAssertArgType>(portNum)
601 this->m_seqRunOut_OutputPort[portNum].registerSerialPort(port);
613 FW_ASSERT(this->m_cmdRegOut_OutputPort[0].isConnected());
615 this->m_cmdRegOut_OutputPort[0].
invoke(
619 this->m_cmdRegOut_OutputPort[0].
invoke(
630 Fw::ActiveComponentBase(compName)
695 #if FW_ENABLE_TEXT_LOGGING == 1 698 getNum_logTextOut_OutputPorts()
const 736 static_cast<FwAssertArgType>(portNum)
739 return this->m_cmdRegOut_OutputPort[portNum].
isConnected();
747 static_cast<FwAssertArgType>(portNum)
750 return this->m_cmdResponseOut_OutputPort[portNum].
isConnected();
758 static_cast<FwAssertArgType>(portNum)
761 return this->m_logOut_OutputPort[portNum].
isConnected();
764 #if FW_ENABLE_TEXT_LOGGING == 1 766 bool SeqDispatcherComponentBase ::
767 isConnected_logTextOut_OutputPort(
FwIndexType portNum)
770 portNum < this->getNum_logTextOut_OutputPorts(),
771 static_cast<FwAssertArgType>(portNum)
774 return this->m_logTextOut_OutputPort[portNum].isConnected();
784 static_cast<FwAssertArgType>(portNum)
787 return this->m_timeCaller_OutputPort[portNum].
isConnected();
795 static_cast<FwAssertArgType>(portNum)
798 return this->m_tlmOut_OutputPort[portNum].
isConnected();
810 static_cast<FwAssertArgType>(portNum)
813 return this->m_seqRunOut_OutputPort[portNum].
isConnected();
833 static_cast<FwAssertArgType>(portNum)
843 ComponentIpcSerializableBuffer msg;
847 _status = msg.serialize(
848 static_cast<FwEnumStoreType>(SEQDONEIN_CMDRESPONSE)
852 static_cast<FwAssertArgType>(_status)
856 _status = msg.serialize(portNum);
859 static_cast<FwAssertArgType>(_status)
863 _status = msg.serialize(opCode);
866 static_cast<FwAssertArgType>(_status)
870 _status = msg.serialize(cmdSeq);
873 static_cast<FwAssertArgType>(_status)
877 _status = msg.serialize(response);
880 static_cast<FwAssertArgType>(_status)
889 static_cast<FwAssertArgType>(qStatus)
902 static_cast<FwAssertArgType>(portNum)
910 ComponentIpcSerializableBuffer msg;
914 _status = msg.serialize(
915 static_cast<FwEnumStoreType>(SEQRUNIN_CMDSEQIN)
919 static_cast<FwAssertArgType>(_status)
923 _status = msg.serialize(portNum);
926 static_cast<FwAssertArgType>(_status)
933 static_cast<FwAssertArgType>(_status)
942 static_cast<FwAssertArgType>(qStatus)
955 static_cast<FwAssertArgType>(portNum)
963 ComponentIpcSerializableBuffer msg;
967 _status = msg.serialize(
968 static_cast<FwEnumStoreType>(SEQSTARTIN_CMDSEQIN)
972 static_cast<FwAssertArgType>(_status)
976 _status = msg.serialize(portNum);
979 static_cast<FwAssertArgType>(_status)
986 static_cast<FwAssertArgType>(_status)
995 static_cast<FwAssertArgType>(qStatus)
1048 static_cast<FwAssertArgType>(portNum)
1052 this->m_seqRunOut_OutputPort[portNum].isConnected(),
1053 static_cast<FwAssertArgType>(portNum)
1055 this->m_seqRunOut_OutputPort[portNum].
invoke(
1071 FW_ASSERT(this->m_cmdResponseOut_OutputPort[0].isConnected());
1072 this->m_cmdResponseOut_OutputPort[0].
invoke(opCode, cmdSeq, response);
1093 ComponentIpcSerializableBuffer msg;
1097 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_RUN));
1100 static_cast<FwAssertArgType>(_status)
1106 _status = msg.serialize(port);
1109 static_cast<FwAssertArgType>(_status)
1112 _status = msg.serialize(opCode);
1115 static_cast<FwAssertArgType>(_status)
1118 _status = msg.serialize(cmdSeq);
1121 static_cast<FwAssertArgType>(_status)
1124 _status = msg.serialize(args);
1127 static_cast<FwAssertArgType>(_status)
1136 static_cast<FwAssertArgType>(qStatus)
1152 ComponentIpcSerializableBuffer msg;
1156 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_LOG_STATUS));
1159 static_cast<FwAssertArgType>(_status)
1165 _status = msg.serialize(port);
1168 static_cast<FwAssertArgType>(_status)
1171 _status = msg.serialize(opCode);
1174 static_cast<FwAssertArgType>(_status)
1177 _status = msg.serialize(cmdSeq);
1180 static_cast<FwAssertArgType>(_status)
1183 _status = msg.serialize(args);
1186 static_cast<FwAssertArgType>(_status)
1195 static_cast<FwAssertArgType>(qStatus)
1238 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1239 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1247 if (this->m_logOut_OutputPort[0].isConnected()) {
1251 #if FW_AMPCS_COMPATIBLE 1253 _status = _logBuff.
serialize(static_cast<U8>(1));
1256 static_cast<FwAssertArgType>(_status)
1260 #if FW_AMPCS_COMPATIBLE 1263 static_cast<U8>(
sizeof(U16))
1267 static_cast<FwAssertArgType>(_status)
1273 static_cast<FwAssertArgType>(_status)
1276 this->m_logOut_OutputPort[0].
invoke(
1285 #if FW_ENABLE_TEXT_LOGGING 1286 if (this->m_logTextOut_OutputPort[0].isConnected()) {
1287 #if FW_OBJECT_NAMES == 1 1288 const char* _formatString =
1289 "(%s) %s: Invalid sequence index %" PRIu16
"";
1291 const char* _formatString =
1292 "%s: Invalid sequence index %" PRIu16
"";
1299 this->m_objName.toChar(),
1301 "InvalidSequencer ",
1305 this->m_logTextOut_OutputPort[0].invoke(
1320 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1321 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1329 if (this->m_logOut_OutputPort[0].isConnected()) {
1332 #if FW_AMPCS_COMPATIBLE 1335 _status = _logBuff.
serialize(static_cast<U8>(0));
1338 static_cast<FwAssertArgType>(_status)
1342 this->m_logOut_OutputPort[0].
invoke(
1351 #if FW_ENABLE_TEXT_LOGGING 1352 if (this->m_logTextOut_OutputPort[0].isConnected()) {
1353 #if FW_OBJECT_NAMES == 1 1354 const char* _formatString =
1355 "(%s) %s: No available cmd sequencers to dispatch a sequence to";
1357 const char* _formatString =
1358 "%s: No available cmd sequencers to dispatch a sequence to";
1365 this->m_objName.toChar(),
1367 "NoAvailableSequencers " 1370 this->m_logTextOut_OutputPort[0].invoke(
1385 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1386 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1394 if (this->m_logOut_OutputPort[0].isConnected()) {
1398 #if FW_AMPCS_COMPATIBLE 1400 _status = _logBuff.
serialize(static_cast<U8>(1));
1403 static_cast<FwAssertArgType>(_status)
1407 #if FW_AMPCS_COMPATIBLE 1410 static_cast<U8>(
sizeof(U16))
1414 static_cast<FwAssertArgType>(_status)
1420 static_cast<FwAssertArgType>(_status)
1423 this->m_logOut_OutputPort[0].
invoke(
1432 #if FW_ENABLE_TEXT_LOGGING 1433 if (this->m_logTextOut_OutputPort[0].isConnected()) {
1434 #if FW_OBJECT_NAMES == 1 1435 const char* _formatString =
1436 "(%s) %s: Sequencer %" PRIu16
" completed a sequence with no matching start notification";
1438 const char* _formatString =
1439 "%s: Sequencer %" PRIu16
" completed a sequence with no matching start notification";
1446 this->m_objName.toChar(),
1448 "UnknownSequenceFinished ",
1452 this->m_logTextOut_OutputPort[0].invoke(
1471 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1472 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1480 if (this->m_logOut_OutputPort[0].isConnected()) {
1484 #if FW_AMPCS_COMPATIBLE 1486 _status = _logBuff.
serialize(static_cast<U8>(3));
1489 static_cast<FwAssertArgType>(_status)
1493 #if FW_AMPCS_COMPATIBLE 1496 static_cast<U8>(
sizeof(U16))
1500 static_cast<FwAssertArgType>(_status)
1506 static_cast<FwAssertArgType>(_status)
1512 static_cast<FwAssertArgType>(_status)
1518 static_cast<FwAssertArgType>(_status)
1521 this->m_logOut_OutputPort[0].
invoke(
1530 #if FW_ENABLE_TEXT_LOGGING 1531 if (this->m_logTextOut_OutputPort[0].isConnected()) {
1532 #if FW_OBJECT_NAMES == 1 1533 const char* _formatString =
1534 "(%s) %s: Sequencer %" PRIu16
" started a sequence %s while still running %s";
1536 const char* _formatString =
1537 "%s: Sequencer %" PRIu16
" started a sequence %s while still running %s";
1544 this->m_objName.toChar(),
1546 "ConflictingSequenceStarted ",
1549 sequenceInInternalState.
toChar()
1552 this->m_logTextOut_OutputPort[0].invoke(
1570 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1571 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1579 if (this->m_logOut_OutputPort[0].isConnected()) {
1583 #if FW_AMPCS_COMPATIBLE 1585 _status = _logBuff.
serialize(static_cast<U8>(2));
1588 static_cast<FwAssertArgType>(_status)
1592 #if FW_AMPCS_COMPATIBLE 1595 static_cast<U8>(
sizeof(U16))
1599 static_cast<FwAssertArgType>(_status)
1605 static_cast<FwAssertArgType>(_status)
1611 static_cast<FwAssertArgType>(_status)
1614 this->m_logOut_OutputPort[0].
invoke(
1623 #if FW_ENABLE_TEXT_LOGGING 1624 if (this->m_logTextOut_OutputPort[0].isConnected()) {
1625 #if FW_OBJECT_NAMES == 1 1626 const char* _formatString =
1627 "(%s) %s: Sequencer %" PRIu16
" was externally commanded to start a sequence %s";
1629 const char* _formatString =
1630 "%s: Sequencer %" PRIu16
" was externally commanded to start a sequence %s";
1637 this->m_objName.toChar(),
1639 "UnexpectedSequenceStarted ",
1644 this->m_logTextOut_OutputPort[0].invoke(
1663 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1664 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1672 if (this->m_logOut_OutputPort[0].isConnected()) {
1676 #if FW_AMPCS_COMPATIBLE 1678 _status = _logBuff.
serialize(static_cast<U8>(3));
1681 static_cast<FwAssertArgType>(_status)
1685 #if FW_AMPCS_COMPATIBLE 1688 static_cast<U8>(
sizeof(U16))
1692 static_cast<FwAssertArgType>(_status)
1698 static_cast<FwAssertArgType>(_status)
1701 #if FW_AMPCS_COMPATIBLE 1708 static_cast<FwAssertArgType>(_status)
1714 static_cast<FwAssertArgType>(_status)
1720 static_cast<FwAssertArgType>(_status)
1723 this->m_logOut_OutputPort[0].
invoke(
1732 #if FW_ENABLE_TEXT_LOGGING 1733 if (this->m_logTextOut_OutputPort[0].isConnected()) {
1734 #if FW_OBJECT_NAMES == 1 1735 const char* _formatString =
1736 "(%s) %s: Sequencer %" PRIu16
" with state %s is running file %s";
1738 const char* _formatString =
1739 "%s: Sequencer %" PRIu16
" with state %s is running file %s";
1743 state.toString(stateStr);
1749 this->m_objName.toChar(),
1751 "LogSequencerStatus ",
1757 this->m_logTextOut_OutputPort[0].invoke(
1777 if (this->m_tlmOut_OutputPort[0].isConnected()) {
1779 this->m_timeCaller_OutputPort[0].isConnected() &&
1782 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
1789 static_cast<FwAssertArgType>(_stat)
1796 this->m_tlmOut_OutputPort[0].
invoke(
1810 if (this->m_tlmOut_OutputPort[0].isConnected()) {
1812 this->m_timeCaller_OutputPort[0].isConnected() &&
1815 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
1822 static_cast<FwAssertArgType>(_stat)
1829 this->m_tlmOut_OutputPort[0].
invoke(
1843 if (this->m_tlmOut_OutputPort[0].isConnected()) {
1845 this->m_timeCaller_OutputPort[0].isConnected() &&
1848 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
1855 static_cast<FwAssertArgType>(_stat)
1862 this->m_tlmOut_OutputPort[0].
invoke(
1877 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1879 this->m_timeCaller_OutputPort[0].
invoke(_time);
1894 ComponentIpcSerializableBuffer _msg;
1904 static_cast<FwAssertArgType>(_msgStatus)
1914 static_cast<FwAssertArgType>(_deserStatus)
1917 MsgTypeEnum _msgType =
static_cast<MsgTypeEnum
>(_desMsg);
1919 if (_msgType == SEQDISPATCHER_COMPONENT_EXIT) {
1924 _deserStatus = _msg.deserialize(portNum);
1927 static_cast<FwAssertArgType>(_deserStatus)
1932 case SEQDONEIN_CMDRESPONSE: {
1935 _deserStatus = _msg.deserialize(opCode);
1938 static_cast<FwAssertArgType>(_deserStatus)
1943 _deserStatus = _msg.deserialize(cmdSeq);
1946 static_cast<FwAssertArgType>(_deserStatus)
1951 _deserStatus = _msg.deserialize(response);
1954 static_cast<FwAssertArgType>(_deserStatus)
1968 case SEQRUNIN_CMDSEQIN: {
1971 Fw::ExternalString filename(__fprime_ac_filename_buffer,
sizeof __fprime_ac_filename_buffer);
1972 _deserStatus = _msg.deserialize(filename);
1975 static_cast<FwAssertArgType>(_deserStatus)
1987 case SEQSTARTIN_CMDSEQIN: {
1990 Fw::ExternalString filename(__fprime_ac_filename_buffer,
sizeof __fprime_ac_filename_buffer);
1991 _deserStatus = _msg.deserialize(filename);
1994 static_cast<FwAssertArgType>(_deserStatus)
2009 _deserStatus = _msg.deserialize(_opCode);
2012 static_cast<FwAssertArgType>(_deserStatus)
2017 _deserStatus = _msg.deserialize(_cmdSeq);
2020 static_cast<FwAssertArgType>(_deserStatus)
2025 _deserStatus = _msg.deserialize(args);
2028 static_cast<FwAssertArgType>(_deserStatus)
2038 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2053 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2066 #if FW_CMD_CHECK_RESIDUAL 2068 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2087 case CMD_LOG_STATUS: {
2090 _deserStatus = _msg.deserialize(_opCode);
2093 static_cast<FwAssertArgType>(_deserStatus)
2098 _deserStatus = _msg.deserialize(_cmdSeq);
2101 static_cast<FwAssertArgType>(_deserStatus)
2106 _deserStatus = _msg.deserialize(args);
2109 static_cast<FwAssertArgType>(_deserStatus)
2117 #if FW_CMD_CHECK_RESIDUAL 2119 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2144 void SeqDispatcherComponentBase ::
2156 const U32 idBase = callComp->
getIdBase();
2157 FW_ASSERT(opCode >= idBase, static_cast<FwAssertArgType>(opCode), static_cast<FwAssertArgType>(idBase));
2160 switch (opCode - idBase) {
2162 compPtr->RUN_cmdHandlerBase(
2171 compPtr->LOG_STATUS_cmdHandlerBase(
2185 void SeqDispatcherComponentBase ::
2196 compPtr->seqDoneIn_handlerBase(
2204 void SeqDispatcherComponentBase ::
2213 compPtr->seqRunIn_handlerBase(
2219 void SeqDispatcherComponentBase ::
2228 compPtr->seqStartIn_handlerBase(
Serialization/Deserialization operation was successful.
Fw::InputCmdResponsePort * get_seqDoneIn_InputPort(FwIndexType portNum)
virtual void seqDoneIn_preMsgHook(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Pre-message hook for async input port seqDoneIn.
void addCallPort(InputTimePort *callPort)
Register an input port.
void tlmWrite_sequencersAvailable(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
FwIndexType getNum_seqRunIn_InputPorts() const
virtual void LOG_STATUS_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command LOG_STATUS.
void tlmWrite_errorCount(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
void seqRunIn_handlerBase(FwIndexType portNum, const Fw::StringBase &filename)
Handler base-class function for input port seqRunIn.
Svc::InputCmdSeqInPort * get_seqRunIn_InputPort(FwIndexType portNum)
Wait or don't wait for something.
virtual void RUN_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command RUN.
Status
status returned from the queue send function
Svc::InputCmdSeqInPort * get_seqStartIn_InputPort(FwIndexType portNum)
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
const char * toChar() const
void init()
Initialization function.
Channel ID for sequencersAvailable.
bool isConnected_cmdRegOut_OutputPort(FwIndexType portNum)
PlatformSizeType FwSizeType
FwIndexType getNum_logOut_OutputPorts() const
bool isConnected_timeCaller_OutputPort(FwIndexType portNum)
void init()
Initialization function.
Enum representing a command response.
void set_tlmOut_OutputPort(FwIndexType portNum, Fw::InputTlmPort *port)
Connect port to tlmOut[portNum].
void regCommands()
Register commands with the Command Dispatcher.
void addCallPort(InputCmdRegPort *callPort)
Register an input port.
PlatformIndexType FwIndexType
virtual void seqRunIn_preMsgHook(FwIndexType portNum, const Fw::StringBase &filename)
Pre-message hook for async input port seqRunIn.
void seqDoneIn_handlerBase(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Handler base-class function for input port seqDoneIn.
void set_logOut_OutputPort(FwIndexType portNum, Fw::InputLogPort *port)
Connect port to logOut[portNum].
void set_cmdResponseOut_OutputPort(FwIndexType portNum, Fw::InputCmdResponsePort *port)
Connect port to cmdResponseOut[portNum].
Os::Queue m_queue
queue object for active component
void addCallPort(InputTlmPort *callPort)
Register an input port.
void RUN_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
void init()
Object initializer.
SerializeStatus
forward declaration for string
virtual void seqRunIn_handler(FwIndexType portNum, const Fw::StringBase &filename)=0
Handler for input port seqRunIn.
virtual void seqStartIn_handler(FwIndexType portNum, const Fw::StringBase &filename)=0
Handler for input port seqStartIn.
virtual void LOG_STATUS_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
Message will block until space is available.
Channel ID for errorCount.
FwIndexType getNum_seqStartIn_InputPorts() const
void log_WARNING_LO_UnknownSequenceFinished(U16 idx) const
Log event UnknownSequenceFinished.
virtual ~SeqDispatcherComponentBase()
Destroy SeqDispatcherComponentBase object.
void invoke(FwOpcodeType opCode) const
Invoke a port interface.
void log_ACTIVITY_LO_LogSequencerStatus(U16 idx, Svc::SeqDispatcher_CmdSequencerState state, const Fw::StringBase &filename) const
Log event LogSequencerStatus.
Fw::InputCmdPort * get_cmdIn_InputPort(FwIndexType portNum)
Serializable::SizeType getBuffLeft() const
returns how much deserialization buffer is left
void init()
Initialization function.
message to exit active component task
Less important informational events.
Os::Queue::Status createQueue(FwSizeType depth, FwSizeType msgSize)
#define FW_MIN(a, b)
MIN macro.
A less serious but recoverable event.
void set_seqRunOut_OutputPort(FwIndexType portNum, Svc::InputCmdSeqInPort *port)
Connect port to seqRunOut[portNum].
FwIndexType getNum_timeCaller_OutputPorts() const
void invoke(Fw::Time &time) const
Invoke a port interface.
Logs via Events the state of each connected command sequencer.
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.
SeqDispatcherComponentBase(const char *compName="")
Construct SeqDispatcherComponentBase object.
virtual void RUN_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &fileName, Fw::Wait block)=0
Status send(const U8 *buffer, FwSizeType size, FwQueuePriorityType priority, BlockingType blockType) override
send a message into the queue through delegate
FwIndexType getNum_cmdRegOut_OutputPorts() const
void resetDeser()
reset deserialization to beginning
A string backed by an external buffer.
A serious but recoverable event.
Errors dispatching messages.
void log_WARNING_LO_UnexpectedSequenceStarted(U16 idx, const Fw::StringBase &newSequence) const
Log event UnexpectedSequenceStarted.
void invoke(FwChanIdType id, Fw::Time &timeTag, Fw::TlmBuffer &val) const
Invoke a port interface.
Channel ID for dispatchedCount.
void invoke(const Fw::StringBase &filename) const
Invoke a port interface.
FwIndexType getNum_cmdResponseOut_OutputPorts() const
FormatStatus format(const CHAR *formatString,...)
write formatted string to buffer
void init()
Initialization function.
FwIndexType getNum_cmdIn_InputPorts() const
bool isConnected_logOut_OutputPort(FwIndexType portNum)
uint8_t U8
8-bit unsigned integer
Command failed to deserialize.
void log_WARNING_HI_NoAvailableSequencers() const
Log event NoAvailableSequencers.
void seqStartIn_handlerBase(FwIndexType portNum, const Fw::StringBase &filename)
Handler base-class function for input port seqStartIn.
void seqRunOut_out(FwIndexType portNum, const Fw::StringBase &filename)
Invoke output port seqRunOut.
void invoke(FwEventIdType id, Fw::Time &timeTag, const Fw::LogSeverity &severity, Fw::LogBuffer &args) const
Invoke a port interface.
PlatformQueuePriorityType FwQueuePriorityType
static constexpr SizeType BUFFER_SIZE(SizeType maxLength)
Get the size of a null-terminated string buffer.
bool isConnected_seqRunOut_OutputPort(FwIndexType portNum)
A message was sent requesting an exit of the loop.
bool isConnected_cmdResponseOut_OutputPort(FwIndexType portNum)
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
FwIndexType getNum_seqDoneIn_InputPorts() const
bool isConnected_tlmOut_OutputPort(FwIndexType portNum)
#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.
virtual void seqDoneIn_handler(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)=0
Handler for input port seqDoneIn.
void LOG_STATUS_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
message sent/received okay
Dispatches a sequence to the first available sequencer.
void log_WARNING_HI_InvalidSequencer(U16 idx) const
Log event InvalidSequencer.
void set_cmdRegOut_OutputPort(FwIndexType portNum, Fw::InputCmdRegPort *port)
Connect port to cmdRegOut[portNum].
virtual SerializeStatus serialize(SerializeBufferBase &buffer) const
serialization function
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
void init()
Initialization function.
void cmdResponse_out(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdResponse response)
Emit command response.
virtual void seqStartIn_preMsgHook(FwIndexType portNum, const Fw::StringBase &filename)
Pre-message hook for async input port seqStartIn.
FwIndexType getNum_seqRunOut_OutputPorts() const
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects) ...
void log_WARNING_HI_ConflictingSequenceStarted(U16 idx, const Fw::StringBase &newSequence, const Fw::StringBase &sequenceInInternalState) const
Log event ConflictingSequenceStarted.
FwIndexType getNum_tlmOut_OutputPorts() const
void tlmWrite_dispatchedCount(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
#define FW_LOG_STRING_MAX_SIZE
Max size of log string parameter type.
virtual const CHAR * toChar() const =0
void set_timeCaller_OutputPort(FwIndexType portNum, Fw::InputTimePort *port)
Connect port to timeCaller[portNum].
void addCallPort(InputCmdResponsePort *callPort)
Register an input port.
The size of the serial representation.