10 #if FW_ENABLE_TEXT_LOGGING 19 BUFFERSENDIN_BUFFERSEND,
41 class ComponentIpcSerializableBuffer :
51 MAX_DATA_SIZE =
sizeof(BuffUnion),
53 SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE
57 return sizeof(m_buff);
64 const U8* getBuffAddr()
const {
70 U8 m_buff[SERIALIZATION_SIZE];
94 this->m_cmdIn_InputPort[port].
init();
99 this->m_cmdIn_InputPort[port].
setPortNum(port);
101 #if FW_OBJECT_NAMES == 1 105 this->m_objName.toChar(),
108 this->m_cmdIn_InputPort[port].setObjName(portName.
toChar());
118 this->m_bufferSendIn_InputPort[port].
init();
123 this->m_bufferSendIn_InputPort[port].
setPortNum(port);
125 #if FW_OBJECT_NAMES == 1 129 this->m_objName.toChar(),
132 this->m_bufferSendIn_InputPort[port].setObjName(portName.
toChar());
142 this->m_comIn_InputPort[port].
init();
147 this->m_comIn_InputPort[port].
setPortNum(port);
149 #if FW_OBJECT_NAMES == 1 153 this->m_objName.toChar(),
156 this->m_comIn_InputPort[port].setObjName(portName.
toChar());
166 this->m_pingIn_InputPort[port].
init();
171 this->m_pingIn_InputPort[port].
setPortNum(port);
173 #if FW_OBJECT_NAMES == 1 177 this->m_objName.toChar(),
180 this->m_pingIn_InputPort[port].setObjName(portName.
toChar());
190 this->m_schedIn_InputPort[port].
init();
195 this->m_schedIn_InputPort[port].
setPortNum(port);
197 #if FW_OBJECT_NAMES == 1 201 this->m_objName.toChar(),
204 this->m_schedIn_InputPort[port].setObjName(portName.
toChar());
214 this->m_cmdRegOut_OutputPort[port].
init();
216 #if FW_OBJECT_NAMES == 1 220 this->m_objName.toChar(),
223 this->m_cmdRegOut_OutputPort[port].setObjName(portName.
toChar());
233 this->m_cmdResponseOut_OutputPort[port].
init();
235 #if FW_OBJECT_NAMES == 1 239 this->m_objName.toChar(),
242 this->m_cmdResponseOut_OutputPort[port].setObjName(portName.
toChar());
252 this->m_eventOut_OutputPort[port].
init();
254 #if FW_OBJECT_NAMES == 1 258 this->m_objName.toChar(),
261 this->m_eventOut_OutputPort[port].setObjName(portName.
toChar());
265 #if FW_ENABLE_TEXT_LOGGING == 1 269 port < static_cast<FwIndexType>(this->getNum_eventOutText_OutputPorts());
272 this->m_eventOutText_OutputPort[port].
init();
274 #if FW_OBJECT_NAMES == 1 278 this->m_objName.toChar(),
281 this->m_eventOutText_OutputPort[port].setObjName(portName.
toChar());
292 this->m_timeCaller_OutputPort[port].
init();
294 #if FW_OBJECT_NAMES == 1 298 this->m_objName.toChar(),
301 this->m_timeCaller_OutputPort[port].setObjName(portName.
toChar());
311 this->m_tlmOut_OutputPort[port].
init();
313 #if FW_OBJECT_NAMES == 1 317 this->m_objName.toChar(),
320 this->m_tlmOut_OutputPort[port].setObjName(portName.
toChar());
330 this->m_bufferSendOut_OutputPort[port].
init();
332 #if FW_OBJECT_NAMES == 1 336 this->m_objName.toChar(),
339 this->m_bufferSendOut_OutputPort[port].setObjName(portName.
toChar());
349 this->m_pingOut_OutputPort[port].
init();
351 #if FW_OBJECT_NAMES == 1 355 this->m_objName.toChar(),
358 this->m_pingOut_OutputPort[port].setObjName(portName.
toChar());
365 static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
369 static_cast<FwAssertArgType>(qStat)
382 static_cast<FwAssertArgType>(portNum)
385 return &this->m_cmdIn_InputPort[portNum];
397 static_cast<FwAssertArgType>(portNum)
400 return &this->m_bufferSendIn_InputPort[portNum];
408 static_cast<FwAssertArgType>(portNum)
411 return &this->m_comIn_InputPort[portNum];
419 static_cast<FwAssertArgType>(portNum)
422 return &this->m_pingIn_InputPort[portNum];
430 static_cast<FwAssertArgType>(portNum)
433 return &this->m_schedIn_InputPort[portNum];
448 static_cast<FwAssertArgType>(portNum)
451 this->m_cmdRegOut_OutputPort[portNum].
addCallPort(port);
462 static_cast<FwAssertArgType>(portNum)
465 this->m_cmdResponseOut_OutputPort[portNum].
addCallPort(port);
476 static_cast<FwAssertArgType>(portNum)
479 this->m_eventOut_OutputPort[portNum].
addCallPort(port);
482 #if FW_ENABLE_TEXT_LOGGING == 1 484 void BufferLoggerComponentBase ::
485 set_eventOutText_OutputPort(
491 portNum < this->getNum_eventOutText_OutputPorts(),
492 static_cast<FwAssertArgType>(portNum)
495 this->m_eventOutText_OutputPort[portNum].addCallPort(port);
508 static_cast<FwAssertArgType>(portNum)
511 this->m_timeCaller_OutputPort[portNum].
addCallPort(port);
522 static_cast<FwAssertArgType>(portNum)
525 this->m_tlmOut_OutputPort[portNum].
addCallPort(port);
540 static_cast<FwAssertArgType>(portNum)
543 this->m_bufferSendOut_OutputPort[portNum].
addCallPort(port);
554 static_cast<FwAssertArgType>(portNum)
557 this->m_pingOut_OutputPort[portNum].
addCallPort(port);
560 #if FW_PORT_SERIALIZATION 569 Fw::InputSerializePort* port
574 static_cast<FwAssertArgType>(portNum)
577 this->m_cmdRegOut_OutputPort[portNum].registerSerialPort(port);
583 Fw::InputSerializePort* port
588 static_cast<FwAssertArgType>(portNum)
591 this->m_cmdResponseOut_OutputPort[portNum].registerSerialPort(port);
597 Fw::InputSerializePort* port
602 static_cast<FwAssertArgType>(portNum)
605 this->m_eventOut_OutputPort[portNum].registerSerialPort(port);
608 #if FW_ENABLE_TEXT_LOGGING == 1 610 void BufferLoggerComponentBase ::
611 set_eventOutText_OutputPort(
613 Fw::InputSerializePort* port
617 portNum < this->getNum_eventOutText_OutputPorts(),
618 static_cast<FwAssertArgType>(portNum)
621 this->m_eventOutText_OutputPort[portNum].registerSerialPort(port);
629 Fw::InputSerializePort* port
634 static_cast<FwAssertArgType>(portNum)
637 this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
643 Fw::InputSerializePort* port
648 static_cast<FwAssertArgType>(portNum)
651 this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
656 #if FW_PORT_SERIALIZATION 665 Fw::InputSerializePort* port
670 static_cast<FwAssertArgType>(portNum)
673 this->m_bufferSendOut_OutputPort[portNum].registerSerialPort(port);
679 Fw::InputSerializePort* port
684 static_cast<FwAssertArgType>(portNum)
687 this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
699 FW_ASSERT(this->m_cmdRegOut_OutputPort[0].isConnected());
701 this->m_cmdRegOut_OutputPort[0].
invoke(
705 this->m_cmdRegOut_OutputPort[0].
invoke(
709 this->m_cmdRegOut_OutputPort[0].
invoke(
713 this->m_cmdRegOut_OutputPort[0].
invoke(
724 Fw::ActiveComponentBase(compName)
795 #if FW_ENABLE_TEXT_LOGGING == 1 798 getNum_eventOutText_OutputPorts()
const 842 static_cast<FwAssertArgType>(portNum)
845 return this->m_cmdRegOut_OutputPort[portNum].
isConnected();
853 static_cast<FwAssertArgType>(portNum)
856 return this->m_cmdResponseOut_OutputPort[portNum].
isConnected();
864 static_cast<FwAssertArgType>(portNum)
867 return this->m_eventOut_OutputPort[portNum].
isConnected();
870 #if FW_ENABLE_TEXT_LOGGING == 1 872 bool BufferLoggerComponentBase ::
873 isConnected_eventOutText_OutputPort(
FwIndexType portNum)
876 portNum < this->getNum_eventOutText_OutputPorts(),
877 static_cast<FwAssertArgType>(portNum)
880 return this->m_eventOutText_OutputPort[portNum].isConnected();
890 static_cast<FwAssertArgType>(portNum)
893 return this->m_timeCaller_OutputPort[portNum].
isConnected();
901 static_cast<FwAssertArgType>(portNum)
904 return this->m_tlmOut_OutputPort[portNum].
isConnected();
916 static_cast<FwAssertArgType>(portNum)
919 return this->m_bufferSendOut_OutputPort[portNum].
isConnected();
927 static_cast<FwAssertArgType>(portNum)
930 return this->m_pingOut_OutputPort[portNum].
isConnected();
948 static_cast<FwAssertArgType>(portNum)
956 ComponentIpcSerializableBuffer msg;
960 _status = msg.serialize(
961 static_cast<FwEnumStoreType>(BUFFERSENDIN_BUFFERSEND)
965 static_cast<FwAssertArgType>(_status)
969 _status = msg.serialize(portNum);
972 static_cast<FwAssertArgType>(_status)
976 _status = msg.serialize(fwBuffer);
979 static_cast<FwAssertArgType>(_status)
988 static_cast<FwAssertArgType>(qStatus)
1002 static_cast<FwAssertArgType>(portNum)
1011 ComponentIpcSerializableBuffer msg;
1015 _status = msg.serialize(
1016 static_cast<FwEnumStoreType>(COMIN_COM)
1020 static_cast<FwAssertArgType>(_status)
1024 _status = msg.serialize(portNum);
1027 static_cast<FwAssertArgType>(_status)
1031 _status = msg.serialize(data);
1034 static_cast<FwAssertArgType>(_status)
1038 _status = msg.serialize(context);
1041 static_cast<FwAssertArgType>(_status)
1050 static_cast<FwAssertArgType>(qStatus)
1063 static_cast<FwAssertArgType>(portNum)
1071 ComponentIpcSerializableBuffer msg;
1075 _status = msg.serialize(
1076 static_cast<FwEnumStoreType>(PINGIN_PING)
1080 static_cast<FwAssertArgType>(_status)
1084 _status = msg.serialize(portNum);
1087 static_cast<FwAssertArgType>(_status)
1091 _status = msg.serialize(key);
1094 static_cast<FwAssertArgType>(_status)
1103 static_cast<FwAssertArgType>(qStatus)
1116 static_cast<FwAssertArgType>(portNum)
1124 ComponentIpcSerializableBuffer msg;
1128 _status = msg.serialize(
1129 static_cast<FwEnumStoreType>(SCHEDIN_SCHED)
1133 static_cast<FwAssertArgType>(_status)
1137 _status = msg.serialize(portNum);
1140 static_cast<FwAssertArgType>(_status)
1144 _status = msg.serialize(context);
1147 static_cast<FwAssertArgType>(_status)
1156 static_cast<FwAssertArgType>(qStatus)
1217 static_cast<FwAssertArgType>(portNum)
1219 this->m_bufferSendOut_OutputPort[portNum].
invoke(
1232 static_cast<FwAssertArgType>(portNum)
1234 this->m_pingOut_OutputPort[portNum].
invoke(
1250 FW_ASSERT(this->m_cmdResponseOut_OutputPort[0].isConnected());
1251 this->m_cmdResponseOut_OutputPort[0].
invoke(opCode, cmdSeq, response);
1272 ComponentIpcSerializableBuffer msg;
1276 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_BL_OPENFILE));
1279 static_cast<FwAssertArgType>(_status)
1285 _status = msg.serialize(port);
1288 static_cast<FwAssertArgType>(_status)
1291 _status = msg.serialize(opCode);
1294 static_cast<FwAssertArgType>(_status)
1297 _status = msg.serialize(cmdSeq);
1300 static_cast<FwAssertArgType>(_status)
1303 _status = msg.serialize(args);
1306 static_cast<FwAssertArgType>(_status)
1315 static_cast<FwAssertArgType>(qStatus)
1331 ComponentIpcSerializableBuffer msg;
1335 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_BL_CLOSEFILE));
1338 static_cast<FwAssertArgType>(_status)
1344 _status = msg.serialize(port);
1347 static_cast<FwAssertArgType>(_status)
1350 _status = msg.serialize(opCode);
1353 static_cast<FwAssertArgType>(_status)
1356 _status = msg.serialize(cmdSeq);
1359 static_cast<FwAssertArgType>(_status)
1362 _status = msg.serialize(args);
1365 static_cast<FwAssertArgType>(_status)
1374 static_cast<FwAssertArgType>(qStatus)
1390 ComponentIpcSerializableBuffer msg;
1394 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_BL_SETLOGGING));
1397 static_cast<FwAssertArgType>(_status)
1403 _status = msg.serialize(port);
1406 static_cast<FwAssertArgType>(_status)
1409 _status = msg.serialize(opCode);
1412 static_cast<FwAssertArgType>(_status)
1415 _status = msg.serialize(cmdSeq);
1418 static_cast<FwAssertArgType>(_status)
1421 _status = msg.serialize(args);
1424 static_cast<FwAssertArgType>(_status)
1433 static_cast<FwAssertArgType>(qStatus)
1449 ComponentIpcSerializableBuffer msg;
1453 _status = msg.serialize(static_cast<FwEnumStoreType>(CMD_BL_FLUSHFILE));
1456 static_cast<FwAssertArgType>(_status)
1462 _status = msg.serialize(port);
1465 static_cast<FwAssertArgType>(_status)
1468 _status = msg.serialize(opCode);
1471 static_cast<FwAssertArgType>(_status)
1474 _status = msg.serialize(cmdSeq);
1477 static_cast<FwAssertArgType>(_status)
1480 _status = msg.serialize(args);
1483 static_cast<FwAssertArgType>(_status)
1492 static_cast<FwAssertArgType>(qStatus)
1557 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1558 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1566 if (this->m_eventOut_OutputPort[0].isConnected()) {
1570 #if FW_AMPCS_COMPATIBLE 1572 _status = _logBuff.
serialize(static_cast<U8>(1));
1575 static_cast<FwAssertArgType>(_status)
1582 static_cast<FwAssertArgType>(_status)
1585 this->m_eventOut_OutputPort[0].
invoke(
1594 #if FW_ENABLE_TEXT_LOGGING 1595 if (this->m_eventOutText_OutputPort[0].isConnected()) {
1596 #if FW_OBJECT_NAMES == 1 1597 const char* _formatString =
1598 "(%s) %s: File %s closed";
1600 const char* _formatString =
1601 "%s: File %s closed";
1608 this->m_objName.toChar(),
1610 "BL_LogFileClosed ",
1614 this->m_eventOutText_OutputPort[0].invoke(
1632 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1633 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1641 if (this->m_eventOut_OutputPort[0].isConnected()) {
1645 #if FW_AMPCS_COMPATIBLE 1647 _status = _logBuff.
serialize(static_cast<U8>(2));
1650 static_cast<FwAssertArgType>(_status)
1654 #if FW_AMPCS_COMPATIBLE 1657 static_cast<U8>(
sizeof(U32))
1661 static_cast<FwAssertArgType>(_status)
1667 static_cast<FwAssertArgType>(_status)
1673 static_cast<FwAssertArgType>(_status)
1676 this->m_eventOut_OutputPort[0].
invoke(
1685 #if FW_ENABLE_TEXT_LOGGING 1686 if (this->m_eventOutText_OutputPort[0].isConnected()) {
1687 #if FW_OBJECT_NAMES == 1 1688 const char* _formatString =
1689 "(%s) %s: Error %" PRIu32
" opening file %s";
1691 const char* _formatString =
1692 "%s: Error %" PRIu32
" opening file %s";
1699 this->m_objName.toChar(),
1701 "BL_LogFileOpenError ",
1706 this->m_eventOutText_OutputPort[0].invoke(
1724 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1725 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1733 if (this->m_eventOut_OutputPort[0].isConnected()) {
1737 #if FW_AMPCS_COMPATIBLE 1739 _status = _logBuff.
serialize(static_cast<U8>(2));
1742 static_cast<FwAssertArgType>(_status)
1749 static_cast<FwAssertArgType>(_status)
1752 #if FW_AMPCS_COMPATIBLE 1755 static_cast<U8>(
sizeof(U32))
1759 static_cast<FwAssertArgType>(_status)
1765 static_cast<FwAssertArgType>(_status)
1768 this->m_eventOut_OutputPort[0].
invoke(
1777 #if FW_ENABLE_TEXT_LOGGING 1778 if (this->m_eventOutText_OutputPort[0].isConnected()) {
1779 #if FW_OBJECT_NAMES == 1 1780 const char* _formatString =
1781 "(%s) %s: Failed creating validation file %s with status %" PRIu32
"";
1783 const char* _formatString =
1784 "%s: Failed creating validation file %s with status %" PRIu32
"";
1791 this->m_objName.toChar(),
1793 "BL_LogFileValidationError ",
1798 this->m_eventOutText_OutputPort[0].invoke(
1818 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1819 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1827 if (this->m_eventOut_OutputPort[0].isConnected()) {
1831 #if FW_AMPCS_COMPATIBLE 1833 _status = _logBuff.
serialize(static_cast<U8>(4));
1836 static_cast<FwAssertArgType>(_status)
1840 #if FW_AMPCS_COMPATIBLE 1843 static_cast<U8>(
sizeof(U32))
1847 static_cast<FwAssertArgType>(_status)
1853 static_cast<FwAssertArgType>(_status)
1856 #if FW_AMPCS_COMPATIBLE 1859 static_cast<U8>(
sizeof(U32))
1863 static_cast<FwAssertArgType>(_status)
1866 _status = _logBuff.
serialize(bytesWritten);
1869 static_cast<FwAssertArgType>(_status)
1872 #if FW_AMPCS_COMPATIBLE 1875 static_cast<U8>(
sizeof(U32))
1879 static_cast<FwAssertArgType>(_status)
1882 _status = _logBuff.
serialize(bytesToWrite);
1885 static_cast<FwAssertArgType>(_status)
1891 static_cast<FwAssertArgType>(_status)
1894 this->m_eventOut_OutputPort[0].
invoke(
1903 #if FW_ENABLE_TEXT_LOGGING 1904 if (this->m_eventOutText_OutputPort[0].isConnected()) {
1905 #if FW_OBJECT_NAMES == 1 1906 const char* _formatString =
1907 "(%s) %s: Error %" PRIu32
" while writing %" PRIu32
" of %" PRIu32
" bytes to %s";
1909 const char* _formatString =
1910 "%s: Error %" PRIu32
" while writing %" PRIu32
" of %" PRIu32
" bytes to %s";
1917 this->m_objName.toChar(),
1919 "BL_LogFileWriteError ",
1926 this->m_eventOutText_OutputPort[0].invoke(
1941 if (this->m_timeCaller_OutputPort[0].isConnected()) {
1942 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
1950 if (this->m_eventOut_OutputPort[0].isConnected()) {
1953 #if FW_AMPCS_COMPATIBLE 1956 _status = _logBuff.
serialize(static_cast<U8>(0));
1959 static_cast<FwAssertArgType>(_status)
1963 this->m_eventOut_OutputPort[0].
invoke(
1972 #if FW_ENABLE_TEXT_LOGGING 1973 if (this->m_eventOutText_OutputPort[0].isConnected()) {
1974 #if FW_OBJECT_NAMES == 1 1975 const char* _formatString =
1976 "(%s) %s: Buffer logger was activated";
1978 const char* _formatString =
1979 "%s: Buffer logger was activated";
1986 this->m_objName.toChar(),
1991 this->m_eventOutText_OutputPort[0].invoke(
2006 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2007 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2015 if (this->m_eventOut_OutputPort[0].isConnected()) {
2018 #if FW_AMPCS_COMPATIBLE 2021 _status = _logBuff.
serialize(static_cast<U8>(0));
2024 static_cast<FwAssertArgType>(_status)
2028 this->m_eventOut_OutputPort[0].
invoke(
2037 #if FW_ENABLE_TEXT_LOGGING 2038 if (this->m_eventOutText_OutputPort[0].isConnected()) {
2039 #if FW_OBJECT_NAMES == 1 2040 const char* _formatString =
2041 "(%s) %s: Buffer logger was deactivated";
2043 const char* _formatString =
2044 "%s: Buffer logger was deactivated";
2051 this->m_objName.toChar(),
2056 this->m_eventOutText_OutputPort[0].invoke(
2071 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2072 this->m_timeCaller_OutputPort[0].
invoke(_logTime);
2080 if (this->m_eventOut_OutputPort[0].isConnected()) {
2083 #if FW_AMPCS_COMPATIBLE 2086 _status = _logBuff.
serialize(static_cast<U8>(0));
2089 static_cast<FwAssertArgType>(_status)
2093 this->m_eventOut_OutputPort[0].
invoke(
2102 #if FW_ENABLE_TEXT_LOGGING 2103 if (this->m_eventOutText_OutputPort[0].isConnected()) {
2104 #if FW_OBJECT_NAMES == 1 2105 const char* _formatString =
2106 "(%s) %s: No log file open command";
2108 const char* _formatString =
2109 "%s: No log file open command";
2116 this->m_objName.toChar(),
2118 "BL_NoLogFileOpenInitError " 2121 this->m_eventOutText_OutputPort[0].invoke(
2141 if (this->m_tlmOut_OutputPort[0].isConnected()) {
2143 this->m_timeCaller_OutputPort[0].isConnected() &&
2146 this->m_timeCaller_OutputPort[0].
invoke(_tlmTime);
2153 static_cast<FwAssertArgType>(_stat)
2160 this->m_tlmOut_OutputPort[0].
invoke(
2175 if (this->m_timeCaller_OutputPort[0].isConnected()) {
2177 this->m_timeCaller_OutputPort[0].
invoke(_time);
2192 ComponentIpcSerializableBuffer msg;
2202 static_cast<FwAssertArgType>(msgStatus)
2212 static_cast<FwAssertArgType>(deserStatus)
2215 MsgTypeEnum msgType =
static_cast<MsgTypeEnum
>(desMsg);
2217 if (msgType == BUFFERLOGGER_COMPONENT_EXIT) {
2222 deserStatus = msg.deserialize(portNum);
2225 static_cast<FwAssertArgType>(deserStatus)
2230 case BUFFERSENDIN_BUFFERSEND: {
2233 deserStatus = msg.deserialize(fwBuffer);
2236 static_cast<FwAssertArgType>(deserStatus)
2251 deserStatus = msg.deserialize(data);
2254 static_cast<FwAssertArgType>(deserStatus)
2259 deserStatus = msg.deserialize(context);
2262 static_cast<FwAssertArgType>(deserStatus)
2278 deserStatus = msg.deserialize(key);
2281 static_cast<FwAssertArgType>(deserStatus)
2293 case SCHEDIN_SCHED: {
2296 deserStatus = msg.deserialize(context);
2299 static_cast<FwAssertArgType>(deserStatus)
2311 case CMD_BL_OPENFILE: {
2314 deserStatus = msg.deserialize(opCode);
2317 static_cast<FwAssertArgType>(deserStatus)
2322 deserStatus = msg.deserialize(cmdSeq);
2325 static_cast<FwAssertArgType>(deserStatus)
2330 deserStatus = msg.deserialize(args);
2333 static_cast<FwAssertArgType>(deserStatus)
2343 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2356 #if FW_CMD_CHECK_RESIDUAL 2358 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2376 case CMD_BL_CLOSEFILE: {
2379 deserStatus = msg.deserialize(opCode);
2382 static_cast<FwAssertArgType>(deserStatus)
2387 deserStatus = msg.deserialize(cmdSeq);
2390 static_cast<FwAssertArgType>(deserStatus)
2395 deserStatus = msg.deserialize(args);
2398 static_cast<FwAssertArgType>(deserStatus)
2406 #if FW_CMD_CHECK_RESIDUAL 2408 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2423 case CMD_BL_SETLOGGING: {
2426 deserStatus = msg.deserialize(opCode);
2429 static_cast<FwAssertArgType>(deserStatus)
2434 deserStatus = msg.deserialize(cmdSeq);
2437 static_cast<FwAssertArgType>(deserStatus)
2442 deserStatus = msg.deserialize(args);
2445 static_cast<FwAssertArgType>(deserStatus)
2455 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2468 #if FW_CMD_CHECK_RESIDUAL 2470 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2488 case CMD_BL_FLUSHFILE: {
2491 deserStatus = msg.deserialize(opCode);
2494 static_cast<FwAssertArgType>(deserStatus)
2499 deserStatus = msg.deserialize(cmdSeq);
2502 static_cast<FwAssertArgType>(deserStatus)
2507 deserStatus = msg.deserialize(args);
2510 static_cast<FwAssertArgType>(deserStatus)
2518 #if FW_CMD_CHECK_RESIDUAL 2520 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2545 void BufferLoggerComponentBase ::
2557 const U32 idBase = callComp->
getIdBase();
2558 FW_ASSERT(opCode >= idBase, static_cast<FwAssertArgType>(opCode), static_cast<FwAssertArgType>(idBase));
2561 switch (opCode - idBase) {
2563 compPtr->BL_OpenFile_cmdHandlerBase(
2572 compPtr->BL_CloseFile_cmdHandlerBase(
2581 compPtr->BL_SetLogging_cmdHandlerBase(
2590 compPtr->BL_FlushFile_cmdHandlerBase(
2604 void BufferLoggerComponentBase ::
2605 m_p_bufferSendIn_in(
2613 compPtr->bufferSendIn_handlerBase(
2619 void BufferLoggerComponentBase ::
2629 compPtr->comIn_handlerBase(
2636 void BufferLoggerComponentBase ::
2645 compPtr->pingIn_handlerBase(
2651 void BufferLoggerComponentBase ::
2660 compPtr->schedIn_handlerBase(
Serialization/Deserialization operation was successful.
void BL_SetLogging_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
void set_cmdResponseOut_OutputPort(FwIndexType portNum, Fw::InputCmdResponsePort *port)
Connect port to cmdResponseOut[portNum].
void addCallPort(InputTimePort *callPort)
Register an input port.
void regCommands()
Register commands with the Command Dispatcher.
virtual void bufferSendIn_preMsgHook(FwIndexType portNum, Fw::Buffer &fwBuffer)
Pre-message hook for async input port bufferSendIn.
Svc::InputSchedPort * get_schedIn_InputPort(FwIndexType portNum)
bool isConnected_cmdResponseOut_OutputPort(FwIndexType portNum)
virtual void schedIn_preMsgHook(FwIndexType portNum, U32 context)
Pre-message hook for async input port schedIn.
NATIVE_UINT_TYPE SizeType
Status
status returned from the queue send function
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
void set_tlmOut_OutputPort(FwIndexType portNum, Fw::InputTlmPort *port)
Connect port to tlmOut[portNum].
void pingOut_out(FwIndexType portNum, U32 key)
Invoke output port pingOut.
void pingIn_handlerBase(FwIndexType portNum, U32 key)
Handler base-class function for input port pingIn.
virtual void BL_SetLogging_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command BL_SetLogging.
virtual void BL_CloseFile_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command BL_CloseFile.
bool isConnected_timeCaller_OutputPort(FwIndexType portNum)
PlatformSizeType FwSizeType
Flushes the current open log file to disk; a no-op with fprime's unbuffered file I/O, so always returns success.
void invoke(U32 key) const
Invoke a port interface.
The Buffer Logger encountered an error writing to a log file.
virtual void BL_SetLogging_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, Svc::BufferLogger_LogState state)=0
virtual void BL_OpenFile_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command BL_OpenFile.
virtual void BL_FlushFile_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Pre-message hook for command BL_FlushFile.
virtual void bufferSendIn_handler(FwIndexType portNum, Fw::Buffer &fwBuffer)=0
Handler for input port bufferSendIn.
void BL_OpenFile_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Open a new log file with specified name; also resets unique file counter to 0.
FwIndexType getNum_cmdIn_InputPorts() const
bool isConnected_pingOut_OutputPort(FwIndexType portNum)
FwIndexType getNum_tlmOut_OutputPorts() const
bool isConnected_tlmOut_OutputPort(FwIndexType portNum)
void init()
Initialization function.
void log_DIAGNOSTIC_BL_LogFileClosed(const Fw::StringBase &file) const
Enum representing a command response.
The Buffer Logger closed a log file.
void addCallPort(InputCmdRegPort *callPort)
Register an input port.
PlatformIndexType FwIndexType
bool isConnected_eventOut_OutputPort(FwIndexType portNum)
Os::Queue m_queue
queue object for active component
Software diagnostic events.
void addCallPort(InputTlmPort *callPort)
Register an input port.
void bufferSendIn_handlerBase(FwIndexType portNum, Fw::Buffer &fwBuffer)
Handler base-class function for input port bufferSendIn.
void init()
Object initializer.
SerializeStatus
forward declaration for string
virtual void comIn_handler(FwIndexType portNum, Fw::ComBuffer &data, U32 context)=0
Handler for input port comIn.
FwIndexType getNum_bufferSendOut_OutputPorts() const
Message will block until space is available.
void log_WARNING_HI_BL_LogFileOpenError(U32 errornum, const Fw::StringBase &file) const
void log_ACTIVITY_LO_BL_Activated() const
Buffer logger was deactivated.
void set_pingOut_OutputPort(FwIndexType portNum, Svc::InputPingPort *port)
Connect port to pingOut[portNum].
bool isConnected_bufferSendOut_OutputPort(FwIndexType portNum)
virtual void comIn_preMsgHook(FwIndexType portNum, Fw::ComBuffer &data, U32 context)
Pre-message hook for async input port comIn.
FwIndexType getNum_cmdRegOut_OutputPorts() const
void invoke(FwOpcodeType opCode) const
Invoke a port interface.
void set_bufferSendOut_OutputPort(FwIndexType portNum, Fw::InputBufferSendPort *port)
Connect port to bufferSendOut[portNum].
Fw::InputCmdPort * get_cmdIn_InputPort(FwIndexType portNum)
Serializable::SizeType getBuffLeft() const
returns how much deserialization buffer is left
void init()
Initialization function.
No log file open command was received by BufferLogger.
The Buffer Logger encountered an error opening a log file.
Less important informational events.
Os::Queue::Status createQueue(FwSizeType depth, FwSizeType msgSize)
#define FW_MIN(a, b)
MIN macro.
void invoke(Fw::Buffer &fwBuffer) const
Invoke a port interface.
void init()
Initialization function.
void tlmWrite_BufferLogger_NumLoggedBuffers(U32 arg, Fw::Time _tlmTime=Fw::Time()) const
void addCallPort(InputBufferSendPort *callPort)
Register an input port.
void invoke(Fw::Time &time) const
Invoke a port interface.
virtual void BL_FlushFile_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
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 addCallPort(InputPingPort *callPort)
Register an input port.
Status send(const U8 *buffer, FwSizeType size, FwQueuePriorityType priority, BlockingType blockType) override
send a message into the queue through delegate
void BL_CloseFile_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
FwIndexType getNum_eventOut_OutputPorts() const
void log_WARNING_HI_BL_LogFileWriteError(U32 errornum, U32 bytesWritten, U32 bytesToWrite, const Fw::StringBase &file) const
BufferLoggerComponentBase(const char *compName="")
Construct BufferLoggerComponentBase object.
virtual void schedIn_handler(FwIndexType portNum, U32 context)=0
Handler for input port schedIn.
void resetDeser()
reset deserialization to beginning
Channel ID for BufferLogger_NumLoggedBuffers.
A serious but recoverable event.
Errors dispatching messages.
void invoke(FwChanIdType id, Fw::Time &timeTag, Fw::TlmBuffer &val) const
Invoke a port interface.
Fw::InputBufferSendPort * get_bufferSendIn_InputPort(FwIndexType portNum)
virtual void pingIn_preMsgHook(FwIndexType portNum, U32 key)
Pre-message hook for async input port pingIn.
FormatStatus format(const CHAR *formatString,...)
write formatted string to buffer
void init()
Initialization function.
Buffer logger was activated.
uint8_t U8
8-bit unsigned integer
#define PRI_PlatformIntType
void cmdResponse_out(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdResponse response)
Emit command response.
FwIndexType getNum_bufferSendIn_InputPorts() const
FwIndexType getNum_schedIn_InputPorts() const
void log_ACTIVITY_LO_BL_Deactivated() const
Fw::InputComPort * get_comIn_InputPort(FwIndexType portNum)
Command failed to deserialize.
void init()
Initialization function.
void comIn_handlerBase(FwIndexType portNum, Fw::ComBuffer &data, U32 context)
Handler base-class function for input port comIn.
void invoke(FwEventIdType id, Fw::Time &timeTag, const Fw::LogSeverity &severity, Fw::LogBuffer &args) const
Invoke a port interface.
PlatformQueuePriorityType FwQueuePriorityType
void bufferSendOut_out(FwIndexType portNum, Fw::Buffer &fwBuffer)
Invoke output port bufferSendOut.
message to exit active component task
virtual void pingIn_handler(FwIndexType portNum, U32 key)=0
Handler for input port pingIn.
A message was sent requesting an exit of the loop.
virtual ~BufferLoggerComponentBase()
Destroy BufferLoggerComponentBase object.
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
void addCallPort(InputLogPort *callPort)
Register an input port.
void init()
Initialization function.
The Buffer Logger encountered an error writing a validation file.
message sent/received okay
FwIndexType getNum_cmdResponseOut_OutputPorts() const
FwIndexType getNum_comIn_InputPorts() const
virtual SerializeStatus serialize(SerializeBufferBase &buffer) const
serialization function
void BL_FlushFile_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
bool isConnected_cmdRegOut_OutputPort(FwIndexType portNum)
void set_timeCaller_OutputPort(FwIndexType portNum, Fw::InputTimePort *port)
Connect port to timeCaller[portNum].
void set_eventOut_OutputPort(FwIndexType portNum, Fw::InputLogPort *port)
Connect port to eventOut[portNum].
Message will return with status when space is unavailable.
void log_WARNING_HI_BL_NoLogFileOpenInitError() const
Status receive(U8 *destination, FwSizeType capacity, BlockingType blockType, FwSizeType &actualSize, FwQueuePriorityType &priority) override
receive a message from the queue through delegate
Svc::InputPingPort * get_pingIn_InputPort(FwIndexType portNum)
Sets the volatile logging state.
void schedIn_handlerBase(FwIndexType portNum, U32 context)
Handler base-class function for input port schedIn.
void init()
Initialization function.
FwIndexType getNum_pingOut_OutputPorts() const
virtual void BL_CloseFile_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) ...
virtual void BL_OpenFile_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &file)=0
FwIndexType getNum_pingIn_InputPorts() const
Close the currently open log file, if any.
#define FW_LOG_STRING_MAX_SIZE
Max size of log string parameter type.
virtual const CHAR * toChar() const =0
void addCallPort(InputCmdResponsePort *callPort)
Register an input port.
void log_WARNING_HI_BL_LogFileValidationError(const Fw::StringBase &validationFile, U32 status) const
void set_cmdRegOut_OutputPort(FwIndexType portNum, Fw::InputCmdRegPort *port)
Connect port to cmdRegOut[portNum].
FwIndexType getNum_timeCaller_OutputPorts() const