10#if FW_ENABLE_TEXT_LOGGING
21 CMD_DUMP_FILTER_STATE,
31 BYTE loqQueueIntIfSize[
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];
79 void ActiveLoggerComponentBase ::
91 port < static_cast<FwIndexType>(this->getNum_CmdDisp_InputPorts());
94 this->m_CmdDisp_InputPort[port].init();
95 this->m_CmdDisp_InputPort[port].addCallComp(
99 this->m_CmdDisp_InputPort[port].setPortNum(port);
101#if FW_OBJECT_NAMES == 1
105 this->m_objName.toChar(),
108 this->m_CmdDisp_InputPort[port].setObjName(portName.
toChar());
115 port < static_cast<FwIndexType>(this->getNum_LogRecv_InputPorts());
118 this->m_LogRecv_InputPort[port].init();
119 this->m_LogRecv_InputPort[port].addCallComp(
123 this->m_LogRecv_InputPort[port].setPortNum(port);
125#if FW_OBJECT_NAMES == 1
129 this->m_objName.toChar(),
132 this->m_LogRecv_InputPort[port].setObjName(portName.
toChar());
139 port < static_cast<FwIndexType>(this->getNum_pingIn_InputPorts());
142 this->m_pingIn_InputPort[port].init();
143 this->m_pingIn_InputPort[port].addCallComp(
147 this->m_pingIn_InputPort[port].setPortNum(port);
149#if FW_OBJECT_NAMES == 1
153 this->m_objName.toChar(),
156 this->m_pingIn_InputPort[port].setObjName(portName.
toChar());
163 port < static_cast<FwIndexType>(this->getNum_CmdReg_OutputPorts());
166 this->m_CmdReg_OutputPort[port].init();
168#if FW_OBJECT_NAMES == 1
172 this->m_objName.toChar(),
175 this->m_CmdReg_OutputPort[port].setObjName(portName.
toChar());
182 port < static_cast<FwIndexType>(this->getNum_CmdStatus_OutputPorts());
185 this->m_CmdStatus_OutputPort[port].init();
187#if FW_OBJECT_NAMES == 1
191 this->m_objName.toChar(),
194 this->m_CmdStatus_OutputPort[port].setObjName(portName.
toChar());
201 port < static_cast<FwIndexType>(this->getNum_Log_OutputPorts());
204 this->m_Log_OutputPort[port].init();
206#if FW_OBJECT_NAMES == 1
210 this->m_objName.toChar(),
213 this->m_Log_OutputPort[port].setObjName(portName.
toChar());
217#if FW_ENABLE_TEXT_LOGGING == 1
221 port < static_cast<FwIndexType>(this->getNum_LogText_OutputPorts());
224 this->m_LogText_OutputPort[port].init();
226#if FW_OBJECT_NAMES == 1
230 this->m_objName.toChar(),
233 this->m_LogText_OutputPort[port].setObjName(portName.
toChar());
241 port < static_cast<FwIndexType>(this->getNum_Time_OutputPorts());
244 this->m_Time_OutputPort[port].init();
246#if FW_OBJECT_NAMES == 1
250 this->m_objName.toChar(),
253 this->m_Time_OutputPort[port].setObjName(portName.
toChar());
260 port < static_cast<FwIndexType>(this->getNum_FatalAnnounce_OutputPorts());
263 this->m_FatalAnnounce_OutputPort[port].init();
265#if FW_OBJECT_NAMES == 1
269 this->m_objName.toChar(),
272 this->m_FatalAnnounce_OutputPort[port].setObjName(portName.
toChar());
279 port < static_cast<FwIndexType>(this->getNum_PktSend_OutputPorts());
282 this->m_PktSend_OutputPort[port].init();
284#if FW_OBJECT_NAMES == 1
288 this->m_objName.toChar(),
291 this->m_PktSend_OutputPort[port].setObjName(portName.
toChar());
298 port < static_cast<FwIndexType>(this->getNum_pingOut_OutputPorts());
301 this->m_pingOut_OutputPort[port].init();
303#if FW_OBJECT_NAMES == 1
307 this->m_objName.toChar(),
310 this->m_pingOut_OutputPort[port].setObjName(portName.
toChar());
317 static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
333 portNum < this->getNum_CmdDisp_InputPorts(),
337 return &this->m_CmdDisp_InputPort[portNum];
348 portNum < this->getNum_LogRecv_InputPorts(),
352 return &this->m_LogRecv_InputPort[portNum];
359 portNum < this->getNum_pingIn_InputPorts(),
363 return &this->m_pingIn_InputPort[portNum];
370 void ActiveLoggerComponentBase ::
371 set_CmdReg_OutputPort(
377 portNum < this->getNum_CmdReg_OutputPorts(),
381 this->m_CmdReg_OutputPort[portNum].addCallPort(port);
384 void ActiveLoggerComponentBase ::
385 set_CmdStatus_OutputPort(
391 portNum < this->getNum_CmdStatus_OutputPorts(),
395 this->m_CmdStatus_OutputPort[portNum].addCallPort(port);
398 void ActiveLoggerComponentBase ::
405 portNum < this->getNum_Log_OutputPorts(),
409 this->m_Log_OutputPort[portNum].addCallPort(port);
412#if FW_ENABLE_TEXT_LOGGING == 1
414 void ActiveLoggerComponentBase ::
415 set_LogText_OutputPort(
421 portNum < this->getNum_LogText_OutputPorts(),
425 this->m_LogText_OutputPort[portNum].addCallPort(port);
430 void ActiveLoggerComponentBase ::
437 portNum < this->getNum_Time_OutputPorts(),
441 this->m_Time_OutputPort[portNum].addCallPort(port);
448 void ActiveLoggerComponentBase ::
449 set_FatalAnnounce_OutputPort(
455 portNum < this->getNum_FatalAnnounce_OutputPorts(),
459 this->m_FatalAnnounce_OutputPort[portNum].addCallPort(port);
462 void ActiveLoggerComponentBase ::
463 set_PktSend_OutputPort(
469 portNum < this->getNum_PktSend_OutputPorts(),
473 this->m_PktSend_OutputPort[portNum].addCallPort(port);
476 void ActiveLoggerComponentBase ::
477 set_pingOut_OutputPort(
483 portNum < this->getNum_pingOut_OutputPorts(),
487 this->m_pingOut_OutputPort[portNum].addCallPort(port);
490#if FW_PORT_SERIALIZATION
496 void ActiveLoggerComponentBase ::
497 set_CmdReg_OutputPort(
499 Fw::InputSerializePort* port
503 portNum < this->getNum_CmdReg_OutputPorts(),
507 this->m_CmdReg_OutputPort[portNum].registerSerialPort(port);
510 void ActiveLoggerComponentBase ::
511 set_CmdStatus_OutputPort(
513 Fw::InputSerializePort* port
517 portNum < this->getNum_CmdStatus_OutputPorts(),
521 this->m_CmdStatus_OutputPort[portNum].registerSerialPort(port);
524 void ActiveLoggerComponentBase ::
527 Fw::InputSerializePort* port
531 portNum < this->getNum_Log_OutputPorts(),
535 this->m_Log_OutputPort[portNum].registerSerialPort(port);
538#if FW_ENABLE_TEXT_LOGGING == 1
540 void ActiveLoggerComponentBase ::
541 set_LogText_OutputPort(
543 Fw::InputSerializePort* port
547 portNum < this->getNum_LogText_OutputPorts(),
551 this->m_LogText_OutputPort[portNum].registerSerialPort(port);
556 void ActiveLoggerComponentBase ::
559 Fw::InputSerializePort* port
563 portNum < this->getNum_Time_OutputPorts(),
567 this->m_Time_OutputPort[portNum].registerSerialPort(port);
572#if FW_PORT_SERIALIZATION
578 void ActiveLoggerComponentBase ::
579 set_FatalAnnounce_OutputPort(
581 Fw::InputSerializePort* port
585 portNum < this->getNum_FatalAnnounce_OutputPorts(),
589 this->m_FatalAnnounce_OutputPort[portNum].registerSerialPort(port);
592 void ActiveLoggerComponentBase ::
593 set_PktSend_OutputPort(
595 Fw::InputSerializePort* port
599 portNum < this->getNum_PktSend_OutputPorts(),
603 this->m_PktSend_OutputPort[portNum].registerSerialPort(port);
606 void ActiveLoggerComponentBase ::
607 set_pingOut_OutputPort(
609 Fw::InputSerializePort* port
613 portNum < this->getNum_pingOut_OutputPorts(),
617 this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
626 void ActiveLoggerComponentBase ::
629 FW_ASSERT(this->m_CmdReg_OutputPort[0].isConnected());
631 this->m_CmdReg_OutputPort[0].invoke(
632 this->getIdBase() + OPCODE_SET_EVENT_FILTER
635 this->m_CmdReg_OutputPort[0].invoke(
636 this->getIdBase() + OPCODE_SET_ID_FILTER
639 this->m_CmdReg_OutputPort[0].invoke(
640 this->getIdBase() + OPCODE_DUMP_FILTER_STATE
648 ActiveLoggerComponentBase ::
649 ActiveLoggerComponentBase(
const char* compName) :
650 Fw::ActiveComponentBase(compName)
655 ActiveLoggerComponentBase ::
656 ~ActiveLoggerComponentBase()
666 getNum_CmdDisp_InputPorts()
const
676 getNum_LogRecv_InputPorts()
const
682 getNum_pingIn_InputPorts()
const
692 getNum_CmdReg_OutputPorts()
const
698 getNum_CmdStatus_OutputPorts()
const
704 getNum_Log_OutputPorts()
const
709#if FW_ENABLE_TEXT_LOGGING == 1
712 getNum_LogText_OutputPorts()
const
720 getNum_Time_OutputPorts()
const
730 getNum_FatalAnnounce_OutputPorts()
const
736 getNum_PktSend_OutputPorts()
const
742 getNum_pingOut_OutputPorts()
const
751 bool ActiveLoggerComponentBase ::
755 portNum < this->getNum_CmdReg_OutputPorts(),
759 return this->m_CmdReg_OutputPort[portNum].isConnected();
762 bool ActiveLoggerComponentBase ::
763 isConnected_CmdStatus_OutputPort(
FwIndexType portNum)
766 portNum < this->getNum_CmdStatus_OutputPorts(),
770 return this->m_CmdStatus_OutputPort[portNum].isConnected();
773 bool ActiveLoggerComponentBase ::
777 portNum < this->getNum_Log_OutputPorts(),
781 return this->m_Log_OutputPort[portNum].isConnected();
784#if FW_ENABLE_TEXT_LOGGING == 1
786 bool ActiveLoggerComponentBase ::
787 isConnected_LogText_OutputPort(
FwIndexType portNum)
790 portNum < this->getNum_LogText_OutputPorts(),
794 return this->m_LogText_OutputPort[portNum].isConnected();
799 bool ActiveLoggerComponentBase ::
803 portNum < this->getNum_Time_OutputPorts(),
807 return this->m_Time_OutputPort[portNum].isConnected();
814 bool ActiveLoggerComponentBase ::
815 isConnected_FatalAnnounce_OutputPort(
FwIndexType portNum)
818 portNum < this->getNum_FatalAnnounce_OutputPorts(),
822 return this->m_FatalAnnounce_OutputPort[portNum].isConnected();
825 bool ActiveLoggerComponentBase ::
826 isConnected_PktSend_OutputPort(
FwIndexType portNum)
829 portNum < this->getNum_PktSend_OutputPorts(),
833 return this->m_PktSend_OutputPort[portNum].isConnected();
836 bool ActiveLoggerComponentBase ::
837 isConnected_pingOut_OutputPort(
FwIndexType portNum)
840 portNum < this->getNum_pingOut_OutputPorts(),
844 return this->m_pingOut_OutputPort[portNum].isConnected();
853 void ActiveLoggerComponentBase ::
864 portNum < this->getNum_LogRecv_InputPorts(),
869 this->LogRecv_handler(
878 void ActiveLoggerComponentBase ::
886 portNum < this->getNum_pingIn_InputPorts(),
895 ComponentIpcSerializableBuffer msg;
899 _status = msg.serialize(
908 _status = msg.serialize(portNum);
915 _status = msg.serialize(key);
939 void ActiveLoggerComponentBase ::
952 void ActiveLoggerComponentBase ::
959 portNum < this->getNum_FatalAnnounce_OutputPorts(),
962 this->m_FatalAnnounce_OutputPort[portNum].invoke(
967 void ActiveLoggerComponentBase ::
975 portNum < this->getNum_PktSend_OutputPorts(),
978 this->m_PktSend_OutputPort[portNum].invoke(
984 void ActiveLoggerComponentBase ::
991 portNum < this->getNum_pingOut_OutputPorts(),
994 this->m_pingOut_OutputPort[portNum].invoke(
1003 void ActiveLoggerComponentBase ::
1004 loqQueue_internalInterfaceInvoke(
1011 ComponentIpcSerializableBuffer msg;
1015 _status = msg.serialize(
static_cast<FwEnumStoreType>(INT_IF_LOQQUEUE));
1022 _status = msg.serialize(
static_cast<FwIndexType>(0));
1028 _status = msg.serialize(
id);
1034 _status = msg.serialize(timeTag);
1040 _status = msg.serialize(severity);
1046 _status = msg.serialize(args);
1057 this->incNumMsgDropped();
1071 void ActiveLoggerComponentBase ::
1078 FW_ASSERT(this->m_CmdStatus_OutputPort[0].isConnected());
1079 this->m_CmdStatus_OutputPort[0].invoke(opCode, cmdSeq, response);
1088 void ActiveLoggerComponentBase ::
1089 SET_EVENT_FILTER_cmdHandlerBase(
1104 if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1105 this->m_CmdStatus_OutputPort[0].invoke(
1117 if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1118 this->m_CmdStatus_OutputPort[0].invoke(
1127#if FW_CMD_CHECK_RESIDUAL
1131 if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1132 this->m_CmdStatus_OutputPort[0].invoke(
1142 this->SET_EVENT_FILTER_cmdHandler(
1149 void ActiveLoggerComponentBase ::
1150 SET_ID_FILTER_cmdHandlerBase(
1157 this->SET_ID_FILTER_preMsgHook(opCode,cmdSeq);
1161 ComponentIpcSerializableBuffer msg;
1165 _status = msg.serialize(
static_cast<FwEnumStoreType>(CMD_SET_ID_FILTER));
1174 _status = msg.serialize(port);
1180 _status = msg.serialize(opCode);
1186 _status = msg.serialize(cmdSeq);
1192 _status = msg.serialize(args);
1208 void ActiveLoggerComponentBase ::
1209 DUMP_FILTER_STATE_cmdHandlerBase(
1216 this->DUMP_FILTER_STATE_preMsgHook(opCode,cmdSeq);
1220 ComponentIpcSerializableBuffer msg;
1224 _status = msg.serialize(
static_cast<FwEnumStoreType>(CMD_DUMP_FILTER_STATE));
1233 _status = msg.serialize(port);
1239 _status = msg.serialize(opCode);
1245 _status = msg.serialize(cmdSeq);
1251 _status = msg.serialize(args);
1275 void ActiveLoggerComponentBase ::
1276 SET_ID_FILTER_preMsgHook(
1286 void ActiveLoggerComponentBase ::
1287 DUMP_FILTER_STATE_preMsgHook(
1301 void ActiveLoggerComponentBase ::
1302 log_ACTIVITY_LO_SEVERITY_FILTER_STATE(
1309 if (this->m_Time_OutputPort[0].isConnected()) {
1310 this->m_Time_OutputPort[0].invoke(_logTime);
1315 _id = this->getIdBase() + EVENTID_SEVERITY_FILTER_STATE;
1318 if (this->m_Log_OutputPort[0].isConnected()) {
1322#if FW_AMPCS_COMPATIBLE
1331#if FW_AMPCS_COMPATIBLE
1347#if FW_AMPCS_COMPATIBLE
1350 static_cast<U8>(
sizeof(
U8))
1363 this->m_Log_OutputPort[0].invoke(
1372#if FW_ENABLE_TEXT_LOGGING
1373 if (this->m_LogText_OutputPort[0].isConnected()) {
1374#if FW_OBJECT_NAMES == 1
1375 const char* _formatString =
1376 "(%s) %s: %s filter state. %d";
1378 const char* _formatString =
1379 "%s: %s filter state. %d";
1383 severity.toString(severityStr);
1389 this->m_objName.toChar(),
1391 "SEVERITY_FILTER_STATE ",
1396 this->m_LogText_OutputPort[0].invoke(
1406 void ActiveLoggerComponentBase ::
1407 log_ACTIVITY_HI_ID_FILTER_ENABLED(U32 ID)
const
1411 if (this->m_Time_OutputPort[0].isConnected()) {
1412 this->m_Time_OutputPort[0].invoke(_logTime);
1417 _id = this->getIdBase() + EVENTID_ID_FILTER_ENABLED;
1420 if (this->m_Log_OutputPort[0].isConnected()) {
1424#if FW_AMPCS_COMPATIBLE
1433#if FW_AMPCS_COMPATIBLE
1436 static_cast<U8>(
sizeof(U32))
1449 this->m_Log_OutputPort[0].invoke(
1458#if FW_ENABLE_TEXT_LOGGING
1459 if (this->m_LogText_OutputPort[0].isConnected()) {
1460#if FW_OBJECT_NAMES == 1
1461 const char* _formatString =
1462 "(%s) %s: ID %" PRIu32
" is filtered.";
1464 const char* _formatString =
1465 "%s: ID %" PRIu32
" is filtered.";
1472 this->m_objName.toChar(),
1474 "ID_FILTER_ENABLED ",
1478 this->m_LogText_OutputPort[0].invoke(
1488 void ActiveLoggerComponentBase ::
1489 log_WARNING_LO_ID_FILTER_LIST_FULL(U32 ID)
const
1493 if (this->m_Time_OutputPort[0].isConnected()) {
1494 this->m_Time_OutputPort[0].invoke(_logTime);
1499 _id = this->getIdBase() + EVENTID_ID_FILTER_LIST_FULL;
1502 if (this->m_Log_OutputPort[0].isConnected()) {
1506#if FW_AMPCS_COMPATIBLE
1515#if FW_AMPCS_COMPATIBLE
1518 static_cast<U8>(
sizeof(U32))
1531 this->m_Log_OutputPort[0].invoke(
1540#if FW_ENABLE_TEXT_LOGGING
1541 if (this->m_LogText_OutputPort[0].isConnected()) {
1542#if FW_OBJECT_NAMES == 1
1543 const char* _formatString =
1544 "(%s) %s: ID filter list is full. Cannot filter %" PRIu32
" .";
1546 const char* _formatString =
1547 "%s: ID filter list is full. Cannot filter %" PRIu32
" .";
1554 this->m_objName.toChar(),
1556 "ID_FILTER_LIST_FULL ",
1560 this->m_LogText_OutputPort[0].invoke(
1570 void ActiveLoggerComponentBase ::
1571 log_ACTIVITY_HI_ID_FILTER_REMOVED(U32 ID)
const
1575 if (this->m_Time_OutputPort[0].isConnected()) {
1576 this->m_Time_OutputPort[0].invoke(_logTime);
1581 _id = this->getIdBase() + EVENTID_ID_FILTER_REMOVED;
1584 if (this->m_Log_OutputPort[0].isConnected()) {
1588#if FW_AMPCS_COMPATIBLE
1597#if FW_AMPCS_COMPATIBLE
1600 static_cast<U8>(
sizeof(U32))
1613 this->m_Log_OutputPort[0].invoke(
1622#if FW_ENABLE_TEXT_LOGGING
1623 if (this->m_LogText_OutputPort[0].isConnected()) {
1624#if FW_OBJECT_NAMES == 1
1625 const char* _formatString =
1626 "(%s) %s: ID filter ID %" PRIu32
" removed.";
1628 const char* _formatString =
1629 "%s: ID filter ID %" PRIu32
" removed.";
1636 this->m_objName.toChar(),
1638 "ID_FILTER_REMOVED ",
1642 this->m_LogText_OutputPort[0].invoke(
1652 void ActiveLoggerComponentBase ::
1653 log_WARNING_LO_ID_FILTER_NOT_FOUND(U32 ID)
const
1657 if (this->m_Time_OutputPort[0].isConnected()) {
1658 this->m_Time_OutputPort[0].invoke(_logTime);
1663 _id = this->getIdBase() + EVENTID_ID_FILTER_NOT_FOUND;
1666 if (this->m_Log_OutputPort[0].isConnected()) {
1670#if FW_AMPCS_COMPATIBLE
1679#if FW_AMPCS_COMPATIBLE
1682 static_cast<U8>(
sizeof(U32))
1695 this->m_Log_OutputPort[0].invoke(
1704#if FW_ENABLE_TEXT_LOGGING
1705 if (this->m_LogText_OutputPort[0].isConnected()) {
1706#if FW_OBJECT_NAMES == 1
1707 const char* _formatString =
1708 "(%s) %s: ID filter ID %" PRIu32
" not found.";
1710 const char* _formatString =
1711 "%s: ID filter ID %" PRIu32
" not found.";
1718 this->m_objName.toChar(),
1720 "ID_FILTER_NOT_FOUND ",
1724 this->m_LogText_OutputPort[0].invoke(
1741 if (this->m_Time_OutputPort[0].isConnected()) {
1743 this->m_Time_OutputPort[0].invoke(_time);
1758 ComponentIpcSerializableBuffer msg;
1781 MsgTypeEnum msgType =
static_cast<MsgTypeEnum
>(desMsg);
1783 if (msgType == ACTIVELOGGER_COMPONENT_EXIT) {
1784 return MSG_DISPATCH_EXIT;
1788 deserStatus = msg.deserialize(portNum);
1799 deserStatus = msg.deserialize(key);
1805 this->pingIn_handler(
1814 case CMD_SET_ID_FILTER: {
1817 deserStatus = msg.deserialize(opCode);
1825 deserStatus = msg.deserialize(cmdSeq);
1833 deserStatus = msg.deserialize(args);
1846 if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1847 this->cmdResponse_out(
1861 if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1862 this->cmdResponse_out(
1874#if FW_CMD_CHECK_RESIDUAL
1876 if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1885 this->SET_ID_FILTER_cmdHandler(
1895 case CMD_DUMP_FILTER_STATE: {
1898 deserStatus = msg.deserialize(opCode);
1906 deserStatus = msg.deserialize(cmdSeq);
1914 deserStatus = msg.deserialize(args);
1925#if FW_CMD_CHECK_RESIDUAL
1927 if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1936 this->DUMP_FILTER_STATE_cmdHandler(opCode, cmdSeq);
1942 case INT_IF_LOQQUEUE: {
1944 deserStatus = msg.deserialize(
id);
1953 deserStatus = msg.deserialize(timeTag);
1962 deserStatus = msg.deserialize(severity);
1971 deserStatus = msg.deserialize(args);
1982 msg.getBuffLeft() == 0,
1987 this->loqQueue_internalInterfaceHandler(
1998 return MSG_DISPATCH_ERROR;
2001 return MSG_DISPATCH_OK;
2008 void ActiveLoggerComponentBase ::
2018 ActiveLoggerComponentBase* compPtr =
static_cast<ActiveLoggerComponentBase*
>(callComp);
2020 const U32 idBase = callComp->
getIdBase();
2024 switch (opCode - idBase) {
2025 case OPCODE_SET_EVENT_FILTER: {
2026 compPtr->SET_EVENT_FILTER_cmdHandlerBase(
2034 case OPCODE_SET_ID_FILTER: {
2035 compPtr->SET_ID_FILTER_cmdHandlerBase(
2043 case OPCODE_DUMP_FILTER_STATE: {
2044 compPtr->DUMP_FILTER_STATE_cmdHandlerBase(
2058 void ActiveLoggerComponentBase ::
2069 ActiveLoggerComponentBase* compPtr =
static_cast<ActiveLoggerComponentBase*
>(callComp);
2070 compPtr->LogRecv_handlerBase(
2079 void ActiveLoggerComponentBase ::
2087 ActiveLoggerComponentBase* compPtr =
static_cast<ActiveLoggerComponentBase*
>(callComp);
2088 compPtr->pingIn_handlerBase(
uint8_t U8
8-bit unsigned integer
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
#define PRI_PlatformIntType
@ TB_NONE
No time base has been established.
PlatformAssertArgType FwAssertArgType
PlatformSizeType FwSizeType
PlatformQueuePriorityType FwQueuePriorityType
PlatformIndexType FwIndexType
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects)/*#en...
@ ACTIVE_COMPONENT_EXIT
message to exit active component task
Enum representing a command response.
@ FORMAT_ERROR
Command failed to deserialize.
Enum representing event severity.
@ SERIALIZED_SIZE
The size of the serial representation.
@ ACTIVITY_HI
Important informational events.
@ WARNING_LO
A less serious but recoverable event.
@ ACTIVITY_LO
Less important informational events.
void init()
Object initializer.
const char * toChar() const
NATIVE_UINT_TYPE SizeType
void resetDeser()
reset deserialization to beginning
Serializable::SizeType getBuffLeft() const
returns how much deserialization buffer is left
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
void format(const CHAR *formatString,...)
write formatted string to buffer
const char * toChar() const
@ BLOCKING
Message will block until space is available.
@ NONBLOCKING
Message will return with status when space is unavailable.
Status
status returned from the queue send function
@ FULL
queue was full when attempting to send a message
@ OP_OK
message sent/received okay
Enabled and disabled state.
@ SERIALIZED_SIZE
The size of the serial representation.
SerializeStatus
forward declaration for string
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.