F´ Flight Software - C/C++ Documentation  NASA-v1.5.0
A framework for building embedded system applications to NASA flight quality standards.
ActiveLoggerComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title ActiveLoggerComponentAc.cpp
3 // \author Auto-generated
4 // \brief cpp file for ActiveLogger component base class
5 //
6 // \copyright
7 // Copyright 2009-2015, by the California Institute of Technology.
8 // ALL RIGHTS RESERVED. United States Government Sponsorship
9 // acknowledged.
10 //
11 // ======================================================================
12 
13 #include <stdio.h>
14 #include <FpConfig.hpp>
16 #include <Fw/Types/Assert.hpp>
17 #if FW_ENABLE_TEXT_LOGGING
19 #endif
20 
21 
22 namespace Svc {
23 
24  // ----------------------------------------------------------------------
25  // Anonymous namespace to prevent name collisions
26  // ----------------------------------------------------------------------
27 
28  namespace {
29 
30  typedef enum {
31  ACTIVELOGGER_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
32  PINGIN_PING,
33  CMD_ALOG_DUMP_EVENT_LOG,
34  CMD_ALOG_SET_ID_FILTER,
35  CMD_ALOG_DUMP_FILTER_STATE,
36  INT_IF_LOQQUEUE
37  } MsgTypeEnum;
38 
39  // Get the max size by doing a union of the input port serialization sizes.
40 
41  typedef union {
44  // Size of loqQueue argument list
46  sizeof(FwEventIdType) +
48  sizeof(FwEnumStoreType) +
50  0
51  ];
52  } BuffUnion;
53 
54  // Define a message buffer class large enough to handle all the
55  // asynchronous inputs to the component
56 
57  class ComponentIpcSerializableBuffer :
59  {
60 
61  public:
62 
63  enum {
64  // Max. message size = size of data + message id + port
65  SERIALIZATION_SIZE =
66  sizeof(BuffUnion) +
67  sizeof(NATIVE_INT_TYPE) +
68  sizeof(NATIVE_INT_TYPE)
69  };
70 
71  NATIVE_UINT_TYPE getBuffCapacity(void) const {
72  return sizeof(m_buff);
73  }
74 
75  U8* getBuffAddr(void) {
76  return m_buff;
77  }
78 
79  const U8* getBuffAddr(void) const {
80  return m_buff;
81  }
82 
83  private:
84  // Should be the max of all the input ports serialized sizes...
85  U8 m_buff[SERIALIZATION_SIZE];
86 
87  };
88 
89  }
90 
91  // ----------------------------------------------------------------------
92  // Getters for numbers of input ports
93  // ----------------------------------------------------------------------
94 
97  {
98  FW_ASSERT(portNum < this->getNum_LogRecv_InputPorts(),static_cast<AssertArg>(portNum));
99  return &this->m_LogRecv_InputPort[portNum];
100  }
101 
104  {
105  FW_ASSERT(portNum < this->getNum_pingIn_InputPorts(),static_cast<AssertArg>(portNum));
106  return &this->m_pingIn_InputPort[portNum];
107  }
108 
111  {
112  FW_ASSERT(portNum < this->getNum_CmdDisp_InputPorts(),static_cast<AssertArg>(portNum));
113  return &this->m_CmdDisp_InputPort[portNum];
114  }
115 
116  // ----------------------------------------------------------------------
117  // Typed connectors for output ports
118  // ----------------------------------------------------------------------
119 
122  NATIVE_INT_TYPE portNum,
123  Fw::InputComPort* port
124  )
125  {
126  FW_ASSERT(portNum < this->getNum_PktSend_OutputPorts(),static_cast<AssertArg>(portNum));
127  this->m_PktSend_OutputPort[portNum].addCallPort(port);
128  }
129 
132  NATIVE_INT_TYPE portNum,
134  )
135  {
136  FW_ASSERT(portNum < this->getNum_FatalAnnounce_OutputPorts(),static_cast<AssertArg>(portNum));
138  }
139 
142  NATIVE_INT_TYPE portNum,
143  Svc::InputPingPort* port
144  )
145  {
146  FW_ASSERT(portNum < this->getNum_pingOut_OutputPorts(),static_cast<AssertArg>(portNum));
148  }
149 
152  NATIVE_INT_TYPE portNum,
154  )
155  {
156  FW_ASSERT(portNum < this->getNum_CmdStatus_OutputPorts(),static_cast<AssertArg>(portNum));
158  }
159 
162  NATIVE_INT_TYPE portNum,
163  Fw::InputCmdRegPort* port
164  )
165  {
166  FW_ASSERT(portNum < this->getNum_CmdReg_OutputPorts(),static_cast<AssertArg>(portNum));
168  }
169 
172  NATIVE_INT_TYPE portNum,
173  Fw::InputTimePort* port
174  )
175  {
176  FW_ASSERT(portNum < this->getNum_Time_OutputPorts(),static_cast<AssertArg>(portNum));
178  }
179 
182  NATIVE_INT_TYPE portNum,
183  Fw::InputLogPort* port
184  )
185  {
186  FW_ASSERT(portNum < this->getNum_Log_OutputPorts(),static_cast<AssertArg>(portNum));
187  this->m_Log_OutputPort[portNum].addCallPort(port);
188  }
189 
190 #if FW_ENABLE_TEXT_LOGGING == 1
191  void ActiveLoggerComponentBase ::
192  set_LogText_OutputPort(
193  NATIVE_INT_TYPE portNum,
195  )
196  {
197  FW_ASSERT(portNum < this->getNum_LogText_OutputPorts(),static_cast<AssertArg>(portNum));
198  this->m_LogText_OutputPort[portNum].addCallPort(port);
199  }
200 #endif
201 
202  // ----------------------------------------------------------------------
203  // Serialization connectors for output ports
204  // ----------------------------------------------------------------------
205 
206 #if FW_PORT_SERIALIZATION
207 
210  NATIVE_INT_TYPE portNum,
211  Fw::InputSerializePort *port
212  )
213  {
214  FW_ASSERT(portNum < this->getNum_PktSend_OutputPorts(),static_cast<AssertArg>(portNum));
215  return this->m_PktSend_OutputPort[portNum].registerSerialPort(port);
216  }
217 
220  NATIVE_INT_TYPE portNum,
221  Fw::InputSerializePort *port
222  )
223  {
224  FW_ASSERT(portNum < this->getNum_FatalAnnounce_OutputPorts(),static_cast<AssertArg>(portNum));
225  return this->m_FatalAnnounce_OutputPort[portNum].registerSerialPort(port);
226  }
227 
230  NATIVE_INT_TYPE portNum,
231  Fw::InputSerializePort *port
232  )
233  {
234  FW_ASSERT(portNum < this->getNum_pingOut_OutputPorts(),static_cast<AssertArg>(portNum));
235  return this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
236  }
237 
240  NATIVE_INT_TYPE portNum,
241  Fw::InputSerializePort *port
242  )
243  {
244  FW_ASSERT(portNum < this->getNum_CmdStatus_OutputPorts(),static_cast<AssertArg>(portNum));
245  return this->m_CmdStatus_OutputPort[portNum].registerSerialPort(port);
246  }
247 
250  NATIVE_INT_TYPE portNum,
251  Fw::InputSerializePort *port
252  )
253  {
254  FW_ASSERT(portNum < this->getNum_CmdReg_OutputPorts(),static_cast<AssertArg>(portNum));
255  return this->m_CmdReg_OutputPort[portNum].registerSerialPort(port);
256  }
257 
260  NATIVE_INT_TYPE portNum,
261  Fw::InputSerializePort *port
262  )
263  {
264  FW_ASSERT(portNum < this->getNum_Time_OutputPorts(),static_cast<AssertArg>(portNum));
265  return this->m_Time_OutputPort[portNum].registerSerialPort(port);
266  }
267 
270  NATIVE_INT_TYPE portNum,
271  Fw::InputSerializePort *port
272  )
273  {
274  FW_ASSERT(portNum < this->getNum_Log_OutputPorts(),static_cast<AssertArg>(portNum));
275  return this->m_Log_OutputPort[portNum].registerSerialPort(port);
276  }
277 
278 #if FW_ENABLE_TEXT_LOGGING == 1
279  void ActiveLoggerComponentBase ::
280  set_LogText_OutputPort(
281  NATIVE_INT_TYPE portNum,
282  Fw::InputSerializePort *port
283  )
284  {
285  FW_ASSERT(portNum < this->getNum_LogText_OutputPorts(),static_cast<AssertArg>(portNum));
286  return this->m_LogText_OutputPort[portNum].registerSerialPort(port);
287  }
288 #endif
289 
290 #endif
291 
292  // ----------------------------------------------------------------------
293  // Command registration
294  // ----------------------------------------------------------------------
295 
297  regCommands(void)
298  {
299  FW_ASSERT(this->m_CmdReg_OutputPort[0].isConnected());
300  this->m_CmdReg_OutputPort[0].invoke(
301  this->getIdBase() + OPCODE_ALOG_SET_EVENT_REPORT_FILTER
302  );
303  this->m_CmdReg_OutputPort[0].invoke(
305  );
306  this->m_CmdReg_OutputPort[0].invoke(
308  );
309  this->m_CmdReg_OutputPort[0].invoke(
311  );
312  this->m_CmdReg_OutputPort[0].invoke(
314  );
315  }
316 
317  // ----------------------------------------------------------------------
318  // Component construction, initialization, and destruction
319  // ----------------------------------------------------------------------
320 
322 #if FW_OBJECT_NAMES == 1
323  ActiveLoggerComponentBase(const char* compName) :
324  Fw::ActiveComponentBase(compName)
325 #else
327  Fw::ActiveComponentBase()
328 #endif
329  {
330 
331 
332 
333  }
334 
336  init(
337  NATIVE_INT_TYPE queueDepth,
338  NATIVE_INT_TYPE instance
339  )
340  {
341 
342  // Initialize base class
344 
345  // Connect input port LogRecv
346  for (
347  NATIVE_INT_TYPE port = 0;
348  port < this->getNum_LogRecv_InputPorts();
349  port++
350  ) {
351 
352  this->m_LogRecv_InputPort[port].init();
353  this->m_LogRecv_InputPort[port].addCallComp(
354  this,
355  m_p_LogRecv_in
356  );
357  this->m_LogRecv_InputPort[port].setPortNum(port);
358 
359 #if FW_OBJECT_NAMES == 1
360  char portName[120];
361  (void) snprintf(
362  portName,
363  sizeof(portName),
364  "%s_LogRecv_InputPort[%d]",
365  this->m_objName,
366  port
367  );
368  this->m_LogRecv_InputPort[port].setObjName(portName);
369 #endif
370 
371  }
372 
373  // Connect input port pingIn
374  for (
375  NATIVE_INT_TYPE port = 0;
376  port < this->getNum_pingIn_InputPorts();
377  port++
378  ) {
379 
380  this->m_pingIn_InputPort[port].init();
381  this->m_pingIn_InputPort[port].addCallComp(
382  this,
384  );
385  this->m_pingIn_InputPort[port].setPortNum(port);
386 
387 #if FW_OBJECT_NAMES == 1
388  char portName[120];
389  (void) snprintf(
390  portName,
391  sizeof(portName),
392  "%s_pingIn_InputPort[%d]",
393  this->m_objName,
394  port
395  );
396  this->m_pingIn_InputPort[port].setObjName(portName);
397 #endif
398 
399  }
400 
401  // Connect input port CmdDisp
402  for (
403  NATIVE_INT_TYPE port = 0;
404  port < this->getNum_CmdDisp_InputPorts();
405  port++
406  ) {
407 
408  this->m_CmdDisp_InputPort[port].init();
409  this->m_CmdDisp_InputPort[port].addCallComp(
410  this,
412  );
413  this->m_CmdDisp_InputPort[port].setPortNum(port);
414 
415 #if FW_OBJECT_NAMES == 1
416  char portName[120];
417  (void) snprintf(
418  portName,
419  sizeof(portName),
420  "%s_CmdDisp_InputPort[%d]",
421  this->m_objName,
422  port
423  );
424  this->m_CmdDisp_InputPort[port].setObjName(portName);
425 #endif
426 
427  }
428 
429  // Initialize output port PktSend
430  for (
431  NATIVE_INT_TYPE port = 0;
432  port < this->getNum_PktSend_OutputPorts();
433  port++
434  ) {
435  this->m_PktSend_OutputPort[port].init();
436 
437 #if FW_OBJECT_NAMES == 1
438  char portName[120];
439  (void) snprintf(
440  portName,
441  sizeof(portName),
442  "%s_PktSend_OutputPort[%d]",
443  this->m_objName,
444  port
445  );
446  this->m_PktSend_OutputPort[port].setObjName(portName);
447 #endif
448 
449  }
450 
451  // Initialize output port FatalAnnounce
452  for (
453  NATIVE_INT_TYPE port = 0;
454  port < this->getNum_FatalAnnounce_OutputPorts();
455  port++
456  ) {
457  this->m_FatalAnnounce_OutputPort[port].init();
458 
459 #if FW_OBJECT_NAMES == 1
460  char portName[120];
461  (void) snprintf(
462  portName,
463  sizeof(portName),
464  "%s_FatalAnnounce_OutputPort[%d]",
465  this->m_objName,
466  port
467  );
468  this->m_FatalAnnounce_OutputPort[port].setObjName(portName);
469 #endif
470 
471  }
472 
473  // Initialize output port pingOut
474  for (
475  NATIVE_INT_TYPE port = 0;
476  port < this->getNum_pingOut_OutputPorts();
477  port++
478  ) {
479  this->m_pingOut_OutputPort[port].init();
480 
481 #if FW_OBJECT_NAMES == 1
482  char portName[120];
483  (void) snprintf(
484  portName,
485  sizeof(portName),
486  "%s_pingOut_OutputPort[%d]",
487  this->m_objName,
488  port
489  );
490  this->m_pingOut_OutputPort[port].setObjName(portName);
491 #endif
492 
493  }
494 
495  // Initialize output port CmdStatus
496  for (
497  NATIVE_INT_TYPE port = 0;
498  port < this->getNum_CmdStatus_OutputPorts();
499  port++
500  ) {
501  this->m_CmdStatus_OutputPort[port].init();
502 
503 #if FW_OBJECT_NAMES == 1
504  char portName[120];
505  (void) snprintf(
506  portName,
507  sizeof(portName),
508  "%s_CmdStatus_OutputPort[%d]",
509  this->m_objName,
510  port
511  );
512  this->m_CmdStatus_OutputPort[port].setObjName(portName);
513 #endif
514 
515  }
516 
517  // Initialize output port CmdReg
518  for (
519  NATIVE_INT_TYPE port = 0;
520  port < this->getNum_CmdReg_OutputPorts();
521  port++
522  ) {
523  this->m_CmdReg_OutputPort[port].init();
524 
525 #if FW_OBJECT_NAMES == 1
526  char portName[120];
527  (void) snprintf(
528  portName,
529  sizeof(portName),
530  "%s_CmdReg_OutputPort[%d]",
531  this->m_objName,
532  port
533  );
534  this->m_CmdReg_OutputPort[port].setObjName(portName);
535 #endif
536 
537  }
538 
539  // Initialize output port Time
540  for (
541  NATIVE_INT_TYPE port = 0;
542  port < this->getNum_Time_OutputPorts();
543  port++
544  ) {
545  this->m_Time_OutputPort[port].init();
546 
547 #if FW_OBJECT_NAMES == 1
548  char portName[120];
549  (void) snprintf(
550  portName,
551  sizeof(portName),
552  "%s_Time_OutputPort[%d]",
553  this->m_objName,
554  port
555  );
556  this->m_Time_OutputPort[port].setObjName(portName);
557 #endif
558 
559  }
560 
561  // Initialize output port Log
562  for (
563  NATIVE_INT_TYPE port = 0;
564  port < this->getNum_Log_OutputPorts();
565  port++
566  ) {
567  this->m_Log_OutputPort[port].init();
568 
569 #if FW_OBJECT_NAMES == 1
570  char portName[120];
571  (void) snprintf(
572  portName,
573  sizeof(portName),
574  "%s_Log_OutputPort[%d]",
575  this->m_objName,
576  port
577  );
578  this->m_Log_OutputPort[port].setObjName(portName);
579 #endif
580 
581  }
582 
583  // Initialize output port LogText
584 #if FW_ENABLE_TEXT_LOGGING == 1
585  for (
586  NATIVE_INT_TYPE port = 0;
587  port < this->getNum_LogText_OutputPorts();
588  port++
589  ) {
590  this->m_LogText_OutputPort[port].init();
591 
592 #if FW_OBJECT_NAMES == 1
593  char portName[120];
594  (void) snprintf(
595  portName,
596  sizeof(portName),
597  "%s_LogText_OutputPort[%d]",
598  this->m_objName,
599  port
600  );
601  this->m_LogText_OutputPort[port].setObjName(portName);
602 #endif
603 
604  }
605 #endif
606 
607  Os::Queue::QueueStatus qStat =
608  this->createQueue(
609  queueDepth,
610  ComponentIpcSerializableBuffer::SERIALIZATION_SIZE
611  );
612  FW_ASSERT(
613  Os::Queue::QUEUE_OK == qStat,
614  static_cast<AssertArg>(qStat)
615  );
616 
617  }
618 
621 
622  }
623 
624  // ----------------------------------------------------------------------
625  // Invocation functions for output ports
626  // ----------------------------------------------------------------------
627 
628  void ActiveLoggerComponentBase ::
629  PktSend_out(
630  NATIVE_INT_TYPE portNum,
631  Fw::ComBuffer &data, U32 context
632  )
633  {
634  FW_ASSERT(portNum < this->getNum_PktSend_OutputPorts(),static_cast<AssertArg>(portNum));
635  this->m_PktSend_OutputPort[portNum].invoke(data, context);
636  }
637 
640  NATIVE_INT_TYPE portNum,
641  FwEventIdType Id
642  )
643  {
644  FW_ASSERT(portNum < this->getNum_FatalAnnounce_OutputPorts(),static_cast<AssertArg>(portNum));
646  }
647 
650  NATIVE_INT_TYPE portNum,
651  U32 key
652  )
653  {
654  FW_ASSERT(portNum < this->getNum_pingOut_OutputPorts(),static_cast<AssertArg>(portNum));
655  this->m_pingOut_OutputPort[portNum].invoke(key);
656  }
657 
658  // ----------------------------------------------------------------------
659  // Getters for numbers of ports
660  // ----------------------------------------------------------------------
661 
662  NATIVE_INT_TYPE ActiveLoggerComponentBase ::
663  getNum_LogRecv_InputPorts(void)
664  {
666  this->m_LogRecv_InputPort
667  );
668  }
669 
670  NATIVE_INT_TYPE ActiveLoggerComponentBase ::
671  getNum_PktSend_OutputPorts(void)
672  {
674  this->m_PktSend_OutputPort
675  );
676  }
677 
680  {
683  );
684  }
685 
688  {
690  this->m_pingIn_InputPort
691  );
692  }
693 
696  {
699  );
700  }
701 
704  {
706  this->m_CmdDisp_InputPort
707  );
708  }
709 
712  {
715  );
716  }
717 
720  {
722  this->m_CmdReg_OutputPort
723  );
724  }
725 
728  {
730  this->m_Time_OutputPort
731  );
732  }
733 
736  {
738  this->m_Log_OutputPort
739  );
740  }
741 
742 #if FW_ENABLE_TEXT_LOGGING == 1
743  NATIVE_INT_TYPE ActiveLoggerComponentBase ::
744  getNum_LogText_OutputPorts(void)
745  {
747  this->m_LogText_OutputPort
748  );
749  }
750 #endif
751 
752  // ----------------------------------------------------------------------
753  // Port connection status queries
754  // ----------------------------------------------------------------------
755 
756  bool ActiveLoggerComponentBase ::
757  isConnected_PktSend_OutputPort(NATIVE_INT_TYPE portNum)
758  {
759  FW_ASSERT(
760  portNum < this->getNum_PktSend_OutputPorts(),
761  static_cast<AssertArg>(portNum)
762  );
763  return this->m_PktSend_OutputPort[portNum].isConnected();
764  }
765 
768  {
769  FW_ASSERT(
770  portNum < this->getNum_FatalAnnounce_OutputPorts(),
771  static_cast<AssertArg>(portNum)
772  );
774  }
775 
778  {
779  FW_ASSERT(
780  portNum < this->getNum_pingOut_OutputPorts(),
781  static_cast<AssertArg>(portNum)
782  );
783  return this->m_pingOut_OutputPort[portNum].isConnected();
784  }
785 
788  {
789  FW_ASSERT(
790  portNum < this->getNum_CmdStatus_OutputPorts(),
791  static_cast<AssertArg>(portNum)
792  );
794  }
795 
798  {
799  FW_ASSERT(
800  portNum < this->getNum_CmdReg_OutputPorts(),
801  static_cast<AssertArg>(portNum)
802  );
803  return this->m_CmdReg_OutputPort[portNum].isConnected();
804  }
805 
808  {
809  FW_ASSERT(
810  portNum < this->getNum_Time_OutputPorts(),
811  static_cast<AssertArg>(portNum)
812  );
813  return this->m_Time_OutputPort[portNum].isConnected();
814  }
815 
818  {
819  FW_ASSERT(
820  portNum < this->getNum_Log_OutputPorts(),
821  static_cast<AssertArg>(portNum)
822  );
823  return this->m_Log_OutputPort[portNum].isConnected();
824  }
825 
826 #if FW_ENABLE_TEXT_LOGGING == 1
827  bool ActiveLoggerComponentBase ::
828  isConnected_LogText_OutputPort(NATIVE_INT_TYPE portNum)
829  {
830  FW_ASSERT(
831  portNum < this->getNum_LogText_OutputPorts(),
832  static_cast<AssertArg>(portNum)
833  );
834  return this->m_LogText_OutputPort[portNum].isConnected();
835  }
836 #endif
837 
838  // ----------------------------------------------------------------------
839  // Calls for messages received on command input ports
840  // ----------------------------------------------------------------------
841 
844  Fw::PassiveComponentBase* callComp,
845  NATIVE_INT_TYPE portNum,
846  FwOpcodeType opCode,
847  U32 cmdSeq,
848  Fw::CmdArgBuffer &args
849  )
850  {
851 
852  // Select base class function based on opcode
853  FW_ASSERT(callComp);
854  ActiveLoggerComponentBase* compPtr =
855  (ActiveLoggerComponentBase*) callComp;
856 
857  const U32 idBase = callComp->getIdBase();
858  FW_ASSERT(opCode >= idBase, opCode, idBase);
859  switch (opCode - idBase) {
860 
861  case OPCODE_ALOG_SET_EVENT_REPORT_FILTER:
862  compPtr->ALOG_SET_EVENT_REPORT_FILTER_cmdHandlerBase(
863  opCode,
864  cmdSeq,
865  args
866  );
867  break;
868 
871  opCode,
872  cmdSeq,
873  args
874  );
875  break;
876 
879  opCode,
880  cmdSeq,
881  args
882  );
883  break;
884 
887  opCode,
888  cmdSeq,
889  args
890  );
891  break;
892 
895  opCode,
896  cmdSeq,
897  args
898  );
899  break;
900 
901  default: {
902  compPtr->cmdResponse_out(
903  opCode,cmdSeq,
905  );
906  break;
907  }
908 
909  }
910 
911  }
912 
913  void ActiveLoggerComponentBase ::
914  cmdResponse_out(
915  FwOpcodeType opCode,
916  U32 cmdSeq,
917  Fw::CommandResponse response
918  )
919  {
920  FW_ASSERT(this->m_CmdStatus_OutputPort[0].isConnected());
921  this->m_CmdStatus_OutputPort[0].invoke(opCode,cmdSeq,response);
922  }
923 
924  // ----------------------------------------------------------------------
925  // Base class command functions
926  // ----------------------------------------------------------------------
927 
928  void ActiveLoggerComponentBase ::
929  ALOG_SET_EVENT_REPORT_FILTER_cmdHandlerBase(
930  FwOpcodeType opCode,
931  U32 cmdSeq,
932  Fw::CmdArgBuffer &args
933  )
934  {
935 
936  // Deserialize the arguments
938 
939  // Reset the buffer
940  args.resetDeser();
941 
943  FwEnumStoreType FilterLevelInt;
944  _status = args.deserialize(FilterLevelInt);
945  FilterLevel = (InputFilterLevel)FilterLevelInt;
946  if (_status != Fw::FW_SERIALIZE_OK) {
947  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
949  opCode,
951  );
952  }
953  return;
954  }
955 
957  FwEnumStoreType FilterEnableInt;
958  _status = args.deserialize(FilterEnableInt);
959  FilterEnable = (InputFilterEnabled)FilterEnableInt;
960  if (_status != Fw::FW_SERIALIZE_OK) {
961  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
963  opCode,
965  );
966  }
967  return;
968  }
969 
970 #if FW_CMD_CHECK_RESIDUAL
971  // Make sure there was no data left over.
972  // That means the argument buffer size was incorrect.
973  if (args.getBuffLeft() != 0) {
974  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
976  opCode,
978  );
979  }
980  return;
981  }
982 #endif
983  this->ALOG_SET_EVENT_REPORT_FILTER_cmdHandler(
984  opCode,
985  cmdSeq,
987  );
988 
989  }
990 
993  FwOpcodeType opCode,
994  U32 cmdSeq,
995  Fw::CmdArgBuffer &args
996  )
997  {
998 
999  // Deserialize the arguments
1001 
1002  // Reset the buffer
1003  args.resetDeser();
1004 
1006  FwEnumStoreType FilterLevelInt;
1007  _status = args.deserialize(FilterLevelInt);
1008  FilterLevel = (SendFilterLevel)FilterLevelInt;
1009  if (_status != Fw::FW_SERIALIZE_OK) {
1010  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1011  this->m_CmdStatus_OutputPort[0].invoke(
1012  opCode,
1014  );
1015  }
1016  return;
1017  }
1018 
1020  FwEnumStoreType FilterEnableInt;
1021  _status = args.deserialize(FilterEnableInt);
1022  FilterEnable = (SendFilterEnabled)FilterEnableInt;
1023  if (_status != Fw::FW_SERIALIZE_OK) {
1024  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1025  this->m_CmdStatus_OutputPort[0].invoke(
1026  opCode,
1028  );
1029  }
1030  return;
1031  }
1032 
1033 #if FW_CMD_CHECK_RESIDUAL
1034  // Make sure there was no data left over.
1035  // That means the argument buffer size was incorrect.
1036  if (args.getBuffLeft() != 0) {
1037  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
1038  this->m_CmdStatus_OutputPort[0].invoke(
1039  opCode,
1041  );
1042  }
1043  return;
1044  }
1045 #endif
1047  opCode,
1048  cmdSeq,
1050  );
1051 
1052  }
1053 
1056  FwOpcodeType opCode,
1057  U32 cmdSeq,
1058  Fw::CmdArgBuffer &args
1059  )
1060  {
1061 
1062  // Call pre-message hook
1063  this->ALOG_DUMP_EVENT_LOG_preMsgHook(opCode,cmdSeq);
1064 
1065  // Defer deserializing arguments to the message dispatcher
1066  // to avoid deserializing and reserializing just for IPC
1067  ComponentIpcSerializableBuffer msg;
1069 
1070  // Serialize for IPC
1071  _status = msg.serialize((NATIVE_INT_TYPE)CMD_ALOG_DUMP_EVENT_LOG);
1072  FW_ASSERT (
1073  _status == Fw::FW_SERIALIZE_OK,
1074  static_cast<AssertArg>(_status)
1075  );
1076 
1077  // Fake port number to make message dequeue work
1078  NATIVE_INT_TYPE port = 0;
1079  _status = msg.serialize(port);
1080  FW_ASSERT (
1081  _status == Fw::FW_SERIALIZE_OK,
1082  static_cast<AssertArg>(_status)
1083  );
1084 
1085  _status = msg.serialize(opCode);
1086  FW_ASSERT (
1087  _status == Fw::FW_SERIALIZE_OK,
1088  static_cast<AssertArg>(_status)
1089  );
1090 
1091  _status = msg.serialize(cmdSeq);
1092  FW_ASSERT (
1093  _status == Fw::FW_SERIALIZE_OK,
1094  static_cast<AssertArg>(_status)
1095  );
1096 
1097  _status = msg.serialize(args);
1098  FW_ASSERT (
1099  _status == Fw::FW_SERIALIZE_OK,
1100  static_cast<AssertArg>(_status)
1101  );
1102 
1103  // send message
1104  Os::Queue::QueueBlocking _block =
1106  Os::Queue::QueueStatus qStatus =
1107  this->m_queue.send(msg, 0,_block);
1108  FW_ASSERT(
1109  qStatus == Os::Queue::QUEUE_OK,
1110  static_cast<AssertArg>(qStatus)
1111  );
1112 
1113  }
1114 
1115  void ActiveLoggerComponentBase::
1116  ALOG_DUMP_EVENT_LOG_preMsgHook(
1117  FwOpcodeType opCode,
1118  U32 cmdSeq
1119  )
1120  {
1121  // Defaults to no-op; can be overridden
1122  }
1123 
1126  FwOpcodeType opCode,
1127  U32 cmdSeq,
1128  Fw::CmdArgBuffer &args
1129  )
1130  {
1131 
1132  // Call pre-message hook
1133  this->ALOG_SET_ID_FILTER_preMsgHook(opCode,cmdSeq);
1134 
1135  // Defer deserializing arguments to the message dispatcher
1136  // to avoid deserializing and reserializing just for IPC
1137  ComponentIpcSerializableBuffer msg;
1139 
1140  // Serialize for IPC
1141  _status = msg.serialize((NATIVE_INT_TYPE)CMD_ALOG_SET_ID_FILTER);
1142  FW_ASSERT (
1143  _status == Fw::FW_SERIALIZE_OK,
1144  static_cast<AssertArg>(_status)
1145  );
1146 
1147  // Fake port number to make message dequeue work
1148  NATIVE_INT_TYPE port = 0;
1149  _status = msg.serialize(port);
1150  FW_ASSERT (
1151  _status == Fw::FW_SERIALIZE_OK,
1152  static_cast<AssertArg>(_status)
1153  );
1154 
1155  _status = msg.serialize(opCode);
1156  FW_ASSERT (
1157  _status == Fw::FW_SERIALIZE_OK,
1158  static_cast<AssertArg>(_status)
1159  );
1160 
1161  _status = msg.serialize(cmdSeq);
1162  FW_ASSERT (
1163  _status == Fw::FW_SERIALIZE_OK,
1164  static_cast<AssertArg>(_status)
1165  );
1166 
1167  _status = msg.serialize(args);
1168  FW_ASSERT (
1169  _status == Fw::FW_SERIALIZE_OK,
1170  static_cast<AssertArg>(_status)
1171  );
1172 
1173  // send message
1174  Os::Queue::QueueBlocking _block =
1176  Os::Queue::QueueStatus qStatus =
1177  this->m_queue.send(msg, 0,_block);
1178  FW_ASSERT(
1179  qStatus == Os::Queue::QUEUE_OK,
1180  static_cast<AssertArg>(qStatus)
1181  );
1182 
1183  }
1184 
1187  FwOpcodeType opCode,
1188  U32 cmdSeq
1189  )
1190  {
1191  // Defaults to no-op; can be overridden
1192  }
1193 
1196  FwOpcodeType opCode,
1197  U32 cmdSeq,
1198  Fw::CmdArgBuffer &args
1199  )
1200  {
1201 
1202  // Call pre-message hook
1204 
1205  // Defer deserializing arguments to the message dispatcher
1206  // to avoid deserializing and reserializing just for IPC
1207  ComponentIpcSerializableBuffer msg;
1209 
1210  // Serialize for IPC
1211  _status = msg.serialize((NATIVE_INT_TYPE)CMD_ALOG_DUMP_FILTER_STATE);
1212  FW_ASSERT (
1213  _status == Fw::FW_SERIALIZE_OK,
1214  static_cast<AssertArg>(_status)
1215  );
1216 
1217  // Fake port number to make message dequeue work
1218  NATIVE_INT_TYPE port = 0;
1219  _status = msg.serialize(port);
1220  FW_ASSERT (
1221  _status == Fw::FW_SERIALIZE_OK,
1222  static_cast<AssertArg>(_status)
1223  );
1224 
1225  _status = msg.serialize(opCode);
1226  FW_ASSERT (
1227  _status == Fw::FW_SERIALIZE_OK,
1228  static_cast<AssertArg>(_status)
1229  );
1230 
1231  _status = msg.serialize(cmdSeq);
1232  FW_ASSERT (
1233  _status == Fw::FW_SERIALIZE_OK,
1234  static_cast<AssertArg>(_status)
1235  );
1236 
1237  _status = msg.serialize(args);
1238  FW_ASSERT (
1239  _status == Fw::FW_SERIALIZE_OK,
1240  static_cast<AssertArg>(_status)
1241  );
1242 
1243  // send message
1244  Os::Queue::QueueBlocking _block =
1246  Os::Queue::QueueStatus qStatus =
1247  this->m_queue.send(msg, 0,_block);
1248  FW_ASSERT(
1249  qStatus == Os::Queue::QUEUE_OK,
1250  static_cast<AssertArg>(qStatus)
1251  );
1252 
1253  }
1254 
1257  FwOpcodeType opCode,
1258  U32 cmdSeq
1259  )
1260  {
1261  // Defaults to no-op; can be overridden
1262  }
1263 
1264  // ----------------------------------------------------------------------
1265  // Time
1266  // ----------------------------------------------------------------------
1267 
1268  Fw::Time ActiveLoggerComponentBase ::
1269  getTime(void)
1270  {
1271  if (this->m_Time_OutputPort[0].isConnected()) {
1272  Fw::Time _time;
1273  this->m_Time_OutputPort[0].invoke(_time);
1274  return _time;
1275  } else {
1276  return Fw::Time(TB_NONE,0,0);
1277  }
1278  }
1279 
1280  // ----------------------------------------------------------------------
1281  // Event handling functions
1282  // ----------------------------------------------------------------------
1283 
1284  void ActiveLoggerComponentBase ::
1285  log_WARNING_HI_ALOG_FILE_WRITE_ERR(
1286  LogWriteError stage, I32 error
1287  )
1288  {
1289 
1290 
1291  // Get the time
1292  Fw::Time _logTime;
1293  if (this->m_Time_OutputPort[0].isConnected()) {
1294  this->m_Time_OutputPort[0].invoke( _logTime);
1295  }
1296 
1297  FwEventIdType _id = static_cast<FwEventIdType>(0);
1298 
1299  _id = this->getIdBase() + EVENTID_ALOG_FILE_WRITE_ERR;
1300 
1301  // Emit the event on the log port
1302  if (this->m_Log_OutputPort[0].isConnected()) {
1303 
1304  Fw::LogBuffer _logBuff;
1306 
1307 #if FW_AMPCS_COMPATIBLE
1308  // Serialize the number of arguments
1309  _status = _logBuff.serialize(static_cast<U8>(2));
1310  FW_ASSERT(
1311  _status == Fw::FW_SERIALIZE_OK,
1312  static_cast<AssertArg>(_status)
1313  );
1314 #endif
1315 
1316 #if FW_AMPCS_COMPATIBLE
1317  // Serialize the argument size
1318  _status = _logBuff.serialize(static_cast<U8>(sizeof(FwEnumStoreType)));
1319  FW_ASSERT(
1320  _status == Fw::FW_SERIALIZE_OK,
1321  static_cast<AssertArg>(_status)
1322  );
1323 #endif
1324 
1325  _status = _logBuff.serialize(
1326  static_cast<FwEnumStoreType>(stage)
1327  );
1328  FW_ASSERT(
1329  _status == Fw::FW_SERIALIZE_OK,
1330  static_cast<AssertArg>(_status)
1331  );
1332 
1333 #if FW_AMPCS_COMPATIBLE
1334  // Serialize the argument size
1335  _status = _logBuff.serialize(
1336  static_cast<U8>(sizeof(error))
1337  );
1338  FW_ASSERT(
1339  _status == Fw::FW_SERIALIZE_OK,
1340  static_cast<AssertArg>(_status)
1341  );
1342 #endif
1343 
1344  _status = _logBuff.serialize(error);
1345  FW_ASSERT(
1346  _status == Fw::FW_SERIALIZE_OK,
1347  static_cast<AssertArg>(_status)
1348  );
1349 
1350 
1351  this->m_Log_OutputPort[0].invoke(
1352  _id,
1353  _logTime,Fw::LOG_WARNING_HI,
1354  _logBuff
1355  );
1356 
1357  }
1358 
1359  // Emit the event on the text log port
1360 #if FW_ENABLE_TEXT_LOGGING
1361  if (this->m_LogText_OutputPort[0].isConnected()) {
1362 
1363 #if FW_OBJECT_NAMES == 1
1364  const char* _formatString =
1365  "(%s) %s: Event buffer write failed in stage %d with error %d";
1366 #else
1367  const char* _formatString =
1368  "%s: Event buffer write failed in stage %d with error %d";
1369 #endif
1370 
1371  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1372 
1373  (void) snprintf(
1374  _textBuffer,
1376  _formatString,
1377 #if FW_OBJECT_NAMES == 1
1378  this->m_objName,
1379 #endif
1380  "ALOG_FILE_WRITE_ERR "
1381  , stage
1382  , error
1383  );
1384 
1385  // Null terminate
1386  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1387  Fw::TextLogString _logString = _textBuffer;
1388  this->m_LogText_OutputPort[0].invoke(
1389  _id,
1390  _logTime,Fw::TEXT_LOG_WARNING_HI,
1391  _logString
1392  );
1393 
1394  }
1395 #endif
1396 
1397  }
1398 
1399 
1402  U32 records
1403  )
1404  {
1405 
1406 
1407  // Get the time
1408  Fw::Time _logTime;
1409  if (this->m_Time_OutputPort[0].isConnected()) {
1410  this->m_Time_OutputPort[0].invoke( _logTime);
1411  }
1412 
1413  FwEventIdType _id = static_cast<FwEventIdType>(0);
1414 
1416 
1417  // Emit the event on the log port
1418  if (this->m_Log_OutputPort[0].isConnected()) {
1419 
1420  Fw::LogBuffer _logBuff;
1422 
1423 #if FW_AMPCS_COMPATIBLE
1424  // Serialize the number of arguments
1425  _status = _logBuff.serialize(static_cast<U8>(1));
1426  FW_ASSERT(
1427  _status == Fw::FW_SERIALIZE_OK,
1428  static_cast<AssertArg>(_status)
1429  );
1430 #endif
1431 
1432 #if FW_AMPCS_COMPATIBLE
1433  // Serialize the argument size
1434  _status = _logBuff.serialize(
1435  static_cast<U8>(sizeof(records))
1436  );
1437  FW_ASSERT(
1438  _status == Fw::FW_SERIALIZE_OK,
1439  static_cast<AssertArg>(_status)
1440  );
1441 #endif
1442 
1443  _status = _logBuff.serialize(records);
1444  FW_ASSERT(
1445  _status == Fw::FW_SERIALIZE_OK,
1446  static_cast<AssertArg>(_status)
1447  );
1448 
1449 
1450  this->m_Log_OutputPort[0].invoke(
1451  _id,
1452  _logTime,Fw::LOG_ACTIVITY_HI,
1453  _logBuff
1454  );
1455 
1456  }
1457 
1458  // Emit the event on the text log port
1459 #if FW_ENABLE_TEXT_LOGGING
1460  if (this->m_LogText_OutputPort[0].isConnected()) {
1461 
1462 #if FW_OBJECT_NAMES == 1
1463  const char* _formatString =
1464  "(%s) %s: Event buffer write complete. Wrote %d records.";
1465 #else
1466  const char* _formatString =
1467  "%s: Event buffer write complete. Wrote %d records.";
1468 #endif
1469 
1470  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1471 
1472  (void) snprintf(
1473  _textBuffer,
1475  _formatString,
1476 #if FW_OBJECT_NAMES == 1
1477  this->m_objName,
1478 #endif
1479  "ALOG_FILE_WRITE_COMPLETE "
1480  , records
1481  );
1482 
1483  // Null terminate
1484  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1485  Fw::TextLogString _logString = _textBuffer;
1486  this->m_LogText_OutputPort[0].invoke(
1487  _id,
1488  _logTime,Fw::TEXT_LOG_ACTIVITY_HI,
1489  _logString
1490  );
1491 
1492  }
1493 #endif
1494 
1495  }
1496 
1497 
1500  EventFilterState severity, bool recvEnabled, bool sendEnabled
1501  )
1502  {
1503 
1504 
1505  // Get the time
1506  Fw::Time _logTime;
1507  if (this->m_Time_OutputPort[0].isConnected()) {
1508  this->m_Time_OutputPort[0].invoke( _logTime);
1509  }
1510 
1511  FwEventIdType _id = static_cast<FwEventIdType>(0);
1512 
1514 
1515  // Emit the event on the log port
1516  if (this->m_Log_OutputPort[0].isConnected()) {
1517 
1518  Fw::LogBuffer _logBuff;
1520 
1521 #if FW_AMPCS_COMPATIBLE
1522  // Serialize the number of arguments
1523  _status = _logBuff.serialize(static_cast<U8>(3));
1524  FW_ASSERT(
1525  _status == Fw::FW_SERIALIZE_OK,
1526  static_cast<AssertArg>(_status)
1527  );
1528 #endif
1529 
1530 #if FW_AMPCS_COMPATIBLE
1531  // Serialize the argument size
1532  _status = _logBuff.serialize(static_cast<U8>(sizeof(FwEnumStoreType)));
1533  FW_ASSERT(
1534  _status == Fw::FW_SERIALIZE_OK,
1535  static_cast<AssertArg>(_status)
1536  );
1537 #endif
1538 
1539  _status = _logBuff.serialize(
1540  static_cast<FwEnumStoreType>(severity)
1541  );
1542  FW_ASSERT(
1543  _status == Fw::FW_SERIALIZE_OK,
1544  static_cast<AssertArg>(_status)
1545  );
1546 
1547 #if FW_AMPCS_COMPATIBLE
1548  // Serialize the argument size
1549  _status = _logBuff.serialize(
1550  static_cast<U8>(sizeof(recvEnabled))
1551  );
1552  FW_ASSERT(
1553  _status == Fw::FW_SERIALIZE_OK,
1554  static_cast<AssertArg>(_status)
1555  );
1556 #endif
1557 
1558  _status = _logBuff.serialize(recvEnabled);
1559  FW_ASSERT(
1560  _status == Fw::FW_SERIALIZE_OK,
1561  static_cast<AssertArg>(_status)
1562  );
1563 
1564 #if FW_AMPCS_COMPATIBLE
1565  // Serialize the argument size
1566  _status = _logBuff.serialize(
1567  static_cast<U8>(sizeof(sendEnabled))
1568  );
1569  FW_ASSERT(
1570  _status == Fw::FW_SERIALIZE_OK,
1571  static_cast<AssertArg>(_status)
1572  );
1573 #endif
1574 
1575  _status = _logBuff.serialize(sendEnabled);
1576  FW_ASSERT(
1577  _status == Fw::FW_SERIALIZE_OK,
1578  static_cast<AssertArg>(_status)
1579  );
1580 
1581 
1582  this->m_Log_OutputPort[0].invoke(
1583  _id,
1584  _logTime,Fw::LOG_ACTIVITY_LO,
1585  _logBuff
1586  );
1587 
1588  }
1589 
1590  // Emit the event on the text log port
1591 #if FW_ENABLE_TEXT_LOGGING
1592  if (this->m_LogText_OutputPort[0].isConnected()) {
1593 
1594 #if FW_OBJECT_NAMES == 1
1595  const char* _formatString =
1596  "(%s) %s: %d filter state. Recv: %d Send: %d";
1597 #else
1598  const char* _formatString =
1599  "%s: %d filter state. Recv: %d Send: %d";
1600 #endif
1601 
1602  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1603 
1604  (void) snprintf(
1605  _textBuffer,
1607  _formatString,
1608 #if FW_OBJECT_NAMES == 1
1609  this->m_objName,
1610 #endif
1611  "ALOG_SEVERITY_FILTER_STATE "
1612  , severity
1613  , recvEnabled
1614  , sendEnabled
1615  );
1616 
1617  // Null terminate
1618  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1619  Fw::TextLogString _logString = _textBuffer;
1620  this->m_LogText_OutputPort[0].invoke(
1621  _id,
1622  _logTime,Fw::TEXT_LOG_ACTIVITY_LO,
1623  _logString
1624  );
1625 
1626  }
1627 #endif
1628 
1629  }
1630 
1631 
1634  U32 ID
1635  )
1636  {
1637 
1638 
1639  // Get the time
1640  Fw::Time _logTime;
1641  if (this->m_Time_OutputPort[0].isConnected()) {
1642  this->m_Time_OutputPort[0].invoke( _logTime);
1643  }
1644 
1645  FwEventIdType _id = static_cast<FwEventIdType>(0);
1646 
1647  _id = this->getIdBase() + EVENTID_ALOG_ID_FILTER_ENABLED;
1648 
1649  // Emit the event on the log port
1650  if (this->m_Log_OutputPort[0].isConnected()) {
1651 
1652  Fw::LogBuffer _logBuff;
1654 
1655 #if FW_AMPCS_COMPATIBLE
1656  // Serialize the number of arguments
1657  _status = _logBuff.serialize(static_cast<U8>(1));
1658  FW_ASSERT(
1659  _status == Fw::FW_SERIALIZE_OK,
1660  static_cast<AssertArg>(_status)
1661  );
1662 #endif
1663 
1664 #if FW_AMPCS_COMPATIBLE
1665  // Serialize the argument size
1666  _status = _logBuff.serialize(
1667  static_cast<U8>(sizeof(ID))
1668  );
1669  FW_ASSERT(
1670  _status == Fw::FW_SERIALIZE_OK,
1671  static_cast<AssertArg>(_status)
1672  );
1673 #endif
1674 
1675  _status = _logBuff.serialize(ID);
1676  FW_ASSERT(
1677  _status == Fw::FW_SERIALIZE_OK,
1678  static_cast<AssertArg>(_status)
1679  );
1680 
1681 
1682  this->m_Log_OutputPort[0].invoke(
1683  _id,
1684  _logTime,Fw::LOG_ACTIVITY_HI,
1685  _logBuff
1686  );
1687 
1688  }
1689 
1690  // Emit the event on the text log port
1691 #if FW_ENABLE_TEXT_LOGGING
1692  if (this->m_LogText_OutputPort[0].isConnected()) {
1693 
1694 #if FW_OBJECT_NAMES == 1
1695  const char* _formatString =
1696  "(%s) %s: ID %d is filtered.";
1697 #else
1698  const char* _formatString =
1699  "%s: ID %d is filtered.";
1700 #endif
1701 
1702  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1703 
1704  (void) snprintf(
1705  _textBuffer,
1707  _formatString,
1708 #if FW_OBJECT_NAMES == 1
1709  this->m_objName,
1710 #endif
1711  "ALOG_ID_FILTER_ENABLED "
1712  , ID
1713  );
1714 
1715  // Null terminate
1716  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1717  Fw::TextLogString _logString = _textBuffer;
1718  this->m_LogText_OutputPort[0].invoke(
1719  _id,
1720  _logTime,Fw::TEXT_LOG_ACTIVITY_HI,
1721  _logString
1722  );
1723 
1724  }
1725 #endif
1726 
1727  }
1728 
1729 
1732  U32 ID
1733  )
1734  {
1735 
1736 
1737  // Get the time
1738  Fw::Time _logTime;
1739  if (this->m_Time_OutputPort[0].isConnected()) {
1740  this->m_Time_OutputPort[0].invoke( _logTime);
1741  }
1742 
1743  FwEventIdType _id = static_cast<FwEventIdType>(0);
1744 
1746 
1747  // Emit the event on the log port
1748  if (this->m_Log_OutputPort[0].isConnected()) {
1749 
1750  Fw::LogBuffer _logBuff;
1752 
1753 #if FW_AMPCS_COMPATIBLE
1754  // Serialize the number of arguments
1755  _status = _logBuff.serialize(static_cast<U8>(1));
1756  FW_ASSERT(
1757  _status == Fw::FW_SERIALIZE_OK,
1758  static_cast<AssertArg>(_status)
1759  );
1760 #endif
1761 
1762 #if FW_AMPCS_COMPATIBLE
1763  // Serialize the argument size
1764  _status = _logBuff.serialize(
1765  static_cast<U8>(sizeof(ID))
1766  );
1767  FW_ASSERT(
1768  _status == Fw::FW_SERIALIZE_OK,
1769  static_cast<AssertArg>(_status)
1770  );
1771 #endif
1772 
1773  _status = _logBuff.serialize(ID);
1774  FW_ASSERT(
1775  _status == Fw::FW_SERIALIZE_OK,
1776  static_cast<AssertArg>(_status)
1777  );
1778 
1779 
1780  this->m_Log_OutputPort[0].invoke(
1781  _id,
1782  _logTime,Fw::LOG_WARNING_LO,
1783  _logBuff
1784  );
1785 
1786  }
1787 
1788  // Emit the event on the text log port
1789 #if FW_ENABLE_TEXT_LOGGING
1790  if (this->m_LogText_OutputPort[0].isConnected()) {
1791 
1792 #if FW_OBJECT_NAMES == 1
1793  const char* _formatString =
1794  "(%s) %s: ID filter list is full. Cannot filter %d .";
1795 #else
1796  const char* _formatString =
1797  "%s: ID filter list is full. Cannot filter %d .";
1798 #endif
1799 
1800  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1801 
1802  (void) snprintf(
1803  _textBuffer,
1805  _formatString,
1806 #if FW_OBJECT_NAMES == 1
1807  this->m_objName,
1808 #endif
1809  "ALOG_ID_FILTER_LIST_FULL "
1810  , ID
1811  );
1812 
1813  // Null terminate
1814  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1815  Fw::TextLogString _logString = _textBuffer;
1816  this->m_LogText_OutputPort[0].invoke(
1817  _id,
1818  _logTime,Fw::TEXT_LOG_WARNING_LO,
1819  _logString
1820  );
1821 
1822  }
1823 #endif
1824 
1825  }
1826 
1827 
1830  U32 ID
1831  )
1832  {
1833 
1834 
1835  // Get the time
1836  Fw::Time _logTime;
1837  if (this->m_Time_OutputPort[0].isConnected()) {
1838  this->m_Time_OutputPort[0].invoke( _logTime);
1839  }
1840 
1841  FwEventIdType _id = static_cast<FwEventIdType>(0);
1842 
1843  _id = this->getIdBase() + EVENTID_ALOG_ID_FILTER_REMOVED;
1844 
1845  // Emit the event on the log port
1846  if (this->m_Log_OutputPort[0].isConnected()) {
1847 
1848  Fw::LogBuffer _logBuff;
1850 
1851 #if FW_AMPCS_COMPATIBLE
1852  // Serialize the number of arguments
1853  _status = _logBuff.serialize(static_cast<U8>(1));
1854  FW_ASSERT(
1855  _status == Fw::FW_SERIALIZE_OK,
1856  static_cast<AssertArg>(_status)
1857  );
1858 #endif
1859 
1860 #if FW_AMPCS_COMPATIBLE
1861  // Serialize the argument size
1862  _status = _logBuff.serialize(
1863  static_cast<U8>(sizeof(ID))
1864  );
1865  FW_ASSERT(
1866  _status == Fw::FW_SERIALIZE_OK,
1867  static_cast<AssertArg>(_status)
1868  );
1869 #endif
1870 
1871  _status = _logBuff.serialize(ID);
1872  FW_ASSERT(
1873  _status == Fw::FW_SERIALIZE_OK,
1874  static_cast<AssertArg>(_status)
1875  );
1876 
1877 
1878  this->m_Log_OutputPort[0].invoke(
1879  _id,
1880  _logTime,Fw::LOG_ACTIVITY_HI,
1881  _logBuff
1882  );
1883 
1884  }
1885 
1886  // Emit the event on the text log port
1887 #if FW_ENABLE_TEXT_LOGGING
1888  if (this->m_LogText_OutputPort[0].isConnected()) {
1889 
1890 #if FW_OBJECT_NAMES == 1
1891  const char* _formatString =
1892  "(%s) %s: ID filter ID %d removed.";
1893 #else
1894  const char* _formatString =
1895  "%s: ID filter ID %d removed.";
1896 #endif
1897 
1898  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1899 
1900  (void) snprintf(
1901  _textBuffer,
1903  _formatString,
1904 #if FW_OBJECT_NAMES == 1
1905  this->m_objName,
1906 #endif
1907  "ALOG_ID_FILTER_REMOVED "
1908  , ID
1909  );
1910 
1911  // Null terminate
1912  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1913  Fw::TextLogString _logString = _textBuffer;
1914  this->m_LogText_OutputPort[0].invoke(
1915  _id,
1916  _logTime,Fw::TEXT_LOG_ACTIVITY_HI,
1917  _logString
1918  );
1919 
1920  }
1921 #endif
1922 
1923  }
1924 
1925 
1928  U32 ID
1929  )
1930  {
1931 
1932 
1933  // Get the time
1934  Fw::Time _logTime;
1935  if (this->m_Time_OutputPort[0].isConnected()) {
1936  this->m_Time_OutputPort[0].invoke( _logTime);
1937  }
1938 
1939  FwEventIdType _id = static_cast<FwEventIdType>(0);
1940 
1942 
1943  // Emit the event on the log port
1944  if (this->m_Log_OutputPort[0].isConnected()) {
1945 
1946  Fw::LogBuffer _logBuff;
1948 
1949 #if FW_AMPCS_COMPATIBLE
1950  // Serialize the number of arguments
1951  _status = _logBuff.serialize(static_cast<U8>(1));
1952  FW_ASSERT(
1953  _status == Fw::FW_SERIALIZE_OK,
1954  static_cast<AssertArg>(_status)
1955  );
1956 #endif
1957 
1958 #if FW_AMPCS_COMPATIBLE
1959  // Serialize the argument size
1960  _status = _logBuff.serialize(
1961  static_cast<U8>(sizeof(ID))
1962  );
1963  FW_ASSERT(
1964  _status == Fw::FW_SERIALIZE_OK,
1965  static_cast<AssertArg>(_status)
1966  );
1967 #endif
1968 
1969  _status = _logBuff.serialize(ID);
1970  FW_ASSERT(
1971  _status == Fw::FW_SERIALIZE_OK,
1972  static_cast<AssertArg>(_status)
1973  );
1974 
1975 
1976  this->m_Log_OutputPort[0].invoke(
1977  _id,
1978  _logTime,Fw::LOG_WARNING_LO,
1979  _logBuff
1980  );
1981 
1982  }
1983 
1984  // Emit the event on the text log port
1985 #if FW_ENABLE_TEXT_LOGGING
1986  if (this->m_LogText_OutputPort[0].isConnected()) {
1987 
1988 #if FW_OBJECT_NAMES == 1
1989  const char* _formatString =
1990  "(%s) %s: ID filter ID %d not found.";
1991 #else
1992  const char* _formatString =
1993  "%s: ID filter ID %d not found.";
1994 #endif
1995 
1996  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1997 
1998  (void) snprintf(
1999  _textBuffer,
2001  _formatString,
2002 #if FW_OBJECT_NAMES == 1
2003  this->m_objName,
2004 #endif
2005  "ALOG_ID_FILTER_NOT_FOUND "
2006  , ID
2007  );
2008 
2009  // Null terminate
2010  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
2011  Fw::TextLogString _logString = _textBuffer;
2012  this->m_LogText_OutputPort[0].invoke(
2013  _id,
2014  _logTime,Fw::TEXT_LOG_WARNING_LO,
2015  _logString
2016  );
2017 
2018  }
2019 #endif
2020 
2021  }
2022 
2023 
2024  // ----------------------------------------------------------------------
2025  // Invocation functions for interfaces
2026  // ----------------------------------------------------------------------
2027 
2028  void ActiveLoggerComponentBase::
2029  loqQueue_internalInterfaceInvoke(
2030  FwEventIdType id, Fw::Time& timeTag, QueueLogSeverity severity, Fw::LogBuffer& args
2031  )
2032  {
2033 
2034  ComponentIpcSerializableBuffer msg;
2036 
2037  // Serialize the message ID
2038  _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(INT_IF_LOQQUEUE));
2039  FW_ASSERT (
2040  _status == Fw::FW_SERIALIZE_OK,
2041  static_cast<AssertArg>(_status)
2042  );
2043 
2044  // Fake port number to make message dequeue work
2045  _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(0));
2046  FW_ASSERT (
2047  _status == Fw::FW_SERIALIZE_OK,
2048  static_cast<AssertArg>(_status)
2049  );
2050 
2051  _status = msg.serialize(id);
2052  FW_ASSERT(_status == Fw::FW_SERIALIZE_OK, static_cast<AssertArg>(_status));
2053  _status = msg.serialize(timeTag);
2054  FW_ASSERT(_status == Fw::FW_SERIALIZE_OK, static_cast<AssertArg>(_status));
2055  _status = msg.serialize(static_cast<FwEnumStoreType>(severity));
2056  FW_ASSERT(_status == Fw::FW_SERIALIZE_OK, static_cast<AssertArg>(_status));
2057  _status = msg.serialize(args);
2058  FW_ASSERT(_status == Fw::FW_SERIALIZE_OK, static_cast<AssertArg>(_status));
2059 
2060  // send message
2061  Os::Queue::QueueBlocking _block =
2063  Os::Queue::QueueStatus qStatus =
2064  this->m_queue.send(msg, 1,_block);
2065  if (qStatus == Os::Queue::QUEUE_FULL) {
2066  this->incNumMsgDropped();
2067  return;
2068  }
2069  FW_ASSERT(
2070  qStatus == Os::Queue::QUEUE_OK,
2071  static_cast<AssertArg>(qStatus)
2072  );
2073 
2074  }
2075 
2076  // ----------------------------------------------------------------------
2077  // Calls for invocations received on typed input ports
2078  // ----------------------------------------------------------------------
2079 
2080  void ActiveLoggerComponentBase ::
2081  m_p_LogRecv_in(
2082  Fw::PassiveComponentBase* callComp,
2083  NATIVE_INT_TYPE portNum,
2084  FwEventIdType id, Fw::Time &timeTag, Fw::LogSeverity severity, Fw::LogBuffer &args
2085  )
2086  {
2087  FW_ASSERT(callComp);
2088  ActiveLoggerComponentBase* compPtr =
2089  (ActiveLoggerComponentBase*) callComp;
2090  compPtr->LogRecv_handlerBase(portNum, id, timeTag, severity, args);
2091  }
2092 
2095  Fw::PassiveComponentBase* callComp,
2096  NATIVE_INT_TYPE portNum,
2097  U32 key
2098  )
2099  {
2100  FW_ASSERT(callComp);
2101  ActiveLoggerComponentBase* compPtr =
2102  (ActiveLoggerComponentBase*) callComp;
2103  compPtr->pingIn_handlerBase(portNum, key);
2104  }
2105 
2106  // ----------------------------------------------------------------------
2107  // Port handler base-class functions for typed input ports
2108  // ----------------------------------------------------------------------
2109 
2110  void ActiveLoggerComponentBase ::
2111  LogRecv_handlerBase(
2112  NATIVE_INT_TYPE portNum,
2113  FwEventIdType id, Fw::Time &timeTag, Fw::LogSeverity severity, Fw::LogBuffer &args
2114  )
2115  {
2116 
2117  // Make sure port number is valid
2118  FW_ASSERT(portNum < this->getNum_LogRecv_InputPorts(),static_cast<AssertArg>(portNum));
2119 
2120  // Down call to pure virtual handler method implemented in Impl class
2121  this->LogRecv_handler(portNum, id, timeTag, severity, args);
2122 
2123  }
2124 
2127  NATIVE_INT_TYPE portNum,
2128  U32 key
2129  )
2130  {
2131 
2132  // Make sure port number is valid
2133  FW_ASSERT(portNum < this->getNum_pingIn_InputPorts(),static_cast<AssertArg>(portNum));
2134 
2135  // Call pre-message hook
2136  pingIn_preMsgHook(
2137  portNum,
2138  key
2139  );
2140 
2141  ComponentIpcSerializableBuffer msg;
2143 
2144  _status = msg.serialize(
2145  static_cast<NATIVE_INT_TYPE>(PINGIN_PING)
2146  );
2147  FW_ASSERT (
2148  _status == Fw::FW_SERIALIZE_OK,
2149  static_cast<AssertArg>(_status)
2150  );
2151 
2152  _status = msg.serialize(portNum);
2153  FW_ASSERT (
2154  _status == Fw::FW_SERIALIZE_OK,
2155  static_cast<AssertArg>(_status)
2156  );
2157 
2158  // Serialize argument key
2159  _status = msg.serialize(key);
2160  FW_ASSERT(
2161  _status == Fw::FW_SERIALIZE_OK,
2162  static_cast<AssertArg>(_status)
2163  );
2164 
2165 
2166  // send message
2167  Os::Queue::QueueBlocking _block =
2169  Os::Queue::QueueStatus qStatus =
2170  this->m_queue.send(msg, 0,_block);
2171  FW_ASSERT(
2172  qStatus == Os::Queue::QUEUE_OK,
2173  static_cast<AssertArg>(qStatus)
2174  );
2175 
2176  }
2177 
2178  // ----------------------------------------------------------------------
2179  // Pre-message hooks for async input ports
2180  // ----------------------------------------------------------------------
2181 
2182  void ActiveLoggerComponentBase ::
2183  pingIn_preMsgHook(
2184  NATIVE_INT_TYPE portNum,
2185  U32 key
2186  )
2187  {
2188  // Default: no-op
2189  }
2190 
2191  // ----------------------------------------------------------------------
2192  // Message dispatch method for active and queued components. Called
2193  // by active component thread or implementation code for queued components
2194  // ----------------------------------------------------------------------
2195 
2197  doDispatch(void)
2198  {
2199  ComponentIpcSerializableBuffer msg;
2200  NATIVE_INT_TYPE priority;
2201 
2202  Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_BLOCKING);
2203  FW_ASSERT(
2204  msgStatus == Os::Queue::QUEUE_OK,
2205  static_cast<AssertArg>(msgStatus)
2206  );
2207 
2208  // Reset to beginning of buffer
2209  msg.resetDeser();
2210 
2211  NATIVE_INT_TYPE desMsg;
2212  Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
2213  FW_ASSERT(
2214  deserStatus == Fw::FW_SERIALIZE_OK,
2215  static_cast<AssertArg>(deserStatus)
2216  );
2217 
2218  MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
2219 
2220  if (msgType == ACTIVELOGGER_COMPONENT_EXIT) {
2221  return MSG_DISPATCH_EXIT;
2222  }
2223 
2225  deserStatus = msg.deserialize(portNum);
2226  FW_ASSERT(
2227  deserStatus == Fw::FW_SERIALIZE_OK,
2228  static_cast<AssertArg>(deserStatus)
2229  );
2230 
2231  switch (msgType) {
2232 
2233  // Handle async input port pingIn
2234  case PINGIN_PING: {
2235 
2236  // Deserialize argument key
2237  U32 key;
2238  deserStatus = msg.deserialize(key);
2239  FW_ASSERT(
2240  deserStatus == Fw::FW_SERIALIZE_OK,
2241  static_cast<AssertArg>(deserStatus)
2242  );
2243 
2244  // Call handler function
2245  this->pingIn_handler(
2246  portNum,
2247  key
2248  );
2249 
2250  break;
2251 
2252  }
2253 
2254  // Handle command ALOG_DUMP_EVENT_LOG
2255  case CMD_ALOG_DUMP_EVENT_LOG: {
2256  // Deserialize opcode
2257  FwOpcodeType opCode;
2258  deserStatus = msg.deserialize(opCode);
2259  FW_ASSERT (
2260  deserStatus == Fw::FW_SERIALIZE_OK,
2261  static_cast<AssertArg>(deserStatus)
2262  );
2263 
2264  // Deserialize command sequence
2265  U32 cmdSeq;
2266  deserStatus = msg.deserialize(cmdSeq);
2267  FW_ASSERT (
2268  deserStatus == Fw::FW_SERIALIZE_OK,
2269  static_cast<AssertArg>(deserStatus)
2270  );
2271 
2272  // Deserialize command argument buffer
2274  deserStatus = msg.deserialize(args);
2275  FW_ASSERT (
2276  deserStatus == Fw::FW_SERIALIZE_OK,
2277  static_cast<AssertArg>(deserStatus)
2278  );
2279 
2280  // Reset buffer
2281  args.resetDeser();
2282 
2283  // Deserialize argument filename
2284  Fw::CmdStringArg filename;
2285  deserStatus = args.deserialize(filename);
2286  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2287  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2288  this->cmdResponse_out(
2289  opCode,
2290  cmdSeq,
2292  );
2293  }
2294  // Don't crash the task if bad arguments were passed from the ground
2295  break;
2296  }
2297 
2298  // Make sure there was no data left over.
2299  // That means the argument buffer size was incorrect.
2300 #if FW_CMD_CHECK_RESIDUAL
2301  if (args.getBuffLeft() != 0) {
2302  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2303  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2304  }
2305  // Don't crash the task if bad arguments were passed from the ground
2306  break;
2307  }
2308 #endif
2309  // Call handler function
2311  opCode,
2312  cmdSeq,
2313  filename
2314  );
2315 
2316  break;
2317 
2318  }
2319 
2320  // Handle command ALOG_SET_ID_FILTER
2321  case CMD_ALOG_SET_ID_FILTER: {
2322  // Deserialize opcode
2323  FwOpcodeType opCode;
2324  deserStatus = msg.deserialize(opCode);
2325  FW_ASSERT (
2326  deserStatus == Fw::FW_SERIALIZE_OK,
2327  static_cast<AssertArg>(deserStatus)
2328  );
2329 
2330  // Deserialize command sequence
2331  U32 cmdSeq;
2332  deserStatus = msg.deserialize(cmdSeq);
2333  FW_ASSERT (
2334  deserStatus == Fw::FW_SERIALIZE_OK,
2335  static_cast<AssertArg>(deserStatus)
2336  );
2337 
2338  // Deserialize command argument buffer
2340  deserStatus = msg.deserialize(args);
2341  FW_ASSERT (
2342  deserStatus == Fw::FW_SERIALIZE_OK,
2343  static_cast<AssertArg>(deserStatus)
2344  );
2345 
2346  // Reset buffer
2347  args.resetDeser();
2348 
2349  // Deserialize argument ID
2350  U32 ID;
2351  deserStatus = args.deserialize(ID);
2352  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2353  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2354  this->cmdResponse_out(
2355  opCode,
2356  cmdSeq,
2358  );
2359  }
2360  // Don't crash the task if bad arguments were passed from the ground
2361  break;
2362  }
2363 
2364  // Deserialize argument IdFilterEnable
2365  IdFilterEnabled IdFilterEnable;
2366  FwEnumStoreType IdFilterEnableInt;
2367  deserStatus = args.deserialize(IdFilterEnableInt);
2368  IdFilterEnable = (IdFilterEnabled)IdFilterEnableInt;
2369  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2370  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2371  this->cmdResponse_out(
2372  opCode,
2373  cmdSeq,
2375  );
2376  }
2377  // Don't crash the task if bad arguments were passed from the ground
2378  break;
2379  }
2380 
2381  // Make sure there was no data left over.
2382  // That means the argument buffer size was incorrect.
2383 #if FW_CMD_CHECK_RESIDUAL
2384  if (args.getBuffLeft() != 0) {
2385  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2386  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2387  }
2388  // Don't crash the task if bad arguments were passed from the ground
2389  break;
2390  }
2391 #endif
2392  // Call handler function
2394  opCode,
2395  cmdSeq,
2396  ID, IdFilterEnable
2397  );
2398 
2399  break;
2400 
2401  }
2402 
2403  // Handle command ALOG_DUMP_FILTER_STATE
2404  case CMD_ALOG_DUMP_FILTER_STATE: {
2405  // Deserialize opcode
2406  FwOpcodeType opCode;
2407  deserStatus = msg.deserialize(opCode);
2408  FW_ASSERT (
2409  deserStatus == Fw::FW_SERIALIZE_OK,
2410  static_cast<AssertArg>(deserStatus)
2411  );
2412 
2413  // Deserialize command sequence
2414  U32 cmdSeq;
2415  deserStatus = msg.deserialize(cmdSeq);
2416  FW_ASSERT (
2417  deserStatus == Fw::FW_SERIALIZE_OK,
2418  static_cast<AssertArg>(deserStatus)
2419  );
2420 
2421  // Deserialize command argument buffer
2423  deserStatus = msg.deserialize(args);
2424  FW_ASSERT (
2425  deserStatus == Fw::FW_SERIALIZE_OK,
2426  static_cast<AssertArg>(deserStatus)
2427  );
2428 
2429  // Reset buffer
2430  args.resetDeser();
2431 
2432  // Make sure there was no data left over.
2433  // That means the argument buffer size was incorrect.
2434 #if FW_CMD_CHECK_RESIDUAL
2435  if (args.getBuffLeft() != 0) {
2436  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2437  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2438  }
2439  // Don't crash the task if bad arguments were passed from the ground
2440  break;
2441  }
2442 #endif
2443  // Call handler function
2445 
2446  break;
2447 
2448  }
2449 
2450  // Handle internal interface loqQueue
2451  case INT_IF_LOQQUEUE: {
2452 
2453  FwEventIdType id;
2454  deserStatus = msg.deserialize(id);
2455 
2456  // Internal interfaces should always deserialize
2457  FW_ASSERT(
2458  Fw::FW_SERIALIZE_OK == deserStatus,
2459  static_cast<AssertArg>(deserStatus)
2460  );
2461 
2462  Fw::Time timeTag;
2463  deserStatus = msg.deserialize(timeTag);
2464 
2465  // Internal interfaces should always deserialize
2466  FW_ASSERT(
2467  Fw::FW_SERIALIZE_OK == deserStatus,
2468  static_cast<AssertArg>(deserStatus)
2469  );
2470 
2472  FwEnumStoreType severityInt;
2473  deserStatus = msg.deserialize(severityInt);
2474  severity = static_cast<QueueLogSeverity>(severityInt);
2475 
2476  // Internal interfaces should always deserialize
2477  FW_ASSERT(
2478  Fw::FW_SERIALIZE_OK == deserStatus,
2479  static_cast<AssertArg>(deserStatus)
2480  );
2481 
2483  deserStatus = msg.deserialize(args);
2484 
2485  // Internal interfaces should always deserialize
2486  FW_ASSERT(
2487  Fw::FW_SERIALIZE_OK == deserStatus,
2488  static_cast<AssertArg>(deserStatus)
2489  );
2490 
2491  // Make sure there was no data left over.
2492  // That means the buffer size was incorrect.
2493  FW_ASSERT(
2494  msg.getBuffLeft() == 0,
2495  static_cast<AssertArg>(msg.getBuffLeft())
2496  );
2497 
2498  // Call handler function
2499  this->loqQueue_internalInterfaceHandler(id, timeTag, severity, args);
2500 
2501  break;
2502 
2503  }
2504 
2505  default:
2506  return MSG_DISPATCH_ERROR;
2507 
2508  }
2509 
2510  return MSG_DISPATCH_OK;
2511 
2512  }
2513 
2514 } // end namespace Svc
Fw::TEXT_LOG_ACTIVITY_HI
@ TEXT_LOG_ACTIVITY_HI
Definition: LogTextPortAc.hpp:31
Svc::ActiveLoggerComponentBase::EVENTID_ALOG_ID_FILTER_LIST_FULL
PROTECTED EVENTID_ALOG_ID_FILTER_LIST_FULL
Definition: ActiveLoggerComponentAc.hpp:738
Fw::OutputCmdRegPort::init
void init(void)
Definition: CmdRegPortAc.cpp:89
Svc::ActiveLoggerComponentBase::InputFilterLevel
PROTECTED InputFilterLevel_MAX InputFilterLevel
Definition: ActiveLoggerComponentAc.hpp:543
Fw::TextLogString
Definition: TextLogString.hpp:11
Fw::InputTimePort
Definition: TimePortAc.hpp:28
Svc::ActiveLoggerComponentBase::m_Time_OutputPort
Fw::OutputTimePort m_Time_OutputPort[NUM_TIME_OUTPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:949
Svc::InputPingPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: PingPortAc.hpp:30
Svc::ActiveLoggerComponentBase::pingOut_out
void pingOut_out(NATIVE_INT_TYPE portNum, U32 key)
Definition: ActiveLoggerComponentAc.cpp:649
Svc::ActiveLoggerComponentBase::IdFilterEnabled
IdFilterEnabled
Definition: ActiveLoggerComponentAc.hpp:567
Svc::ActiveLoggerComponentBase::m_CmdReg_OutputPort
Fw::OutputCmdRegPort m_CmdReg_OutputPort[NUM_CMDREG_OUTPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:945
Fw::PassiveComponentBase::getIdBase
U32 getIdBase(void) const
Definition: PassiveComponentBase.cpp:40
Svc::ActiveLoggerComponentBase::pingIn_handlerBase
void pingIn_handlerBase(NATIVE_INT_TYPE portNum, U32 key)
Definition: ActiveLoggerComponentAc.cpp:2126
Svc::ActiveLoggerComponentBase::FilterLevel
PROTECTED U32 InputFilterLevel FilterLevel
Definition: ActiveLoggerComponentAc.hpp:598
Svc::ActiveLoggerComponentBase::ALOG_SET_EVENT_SEND_FILTER_cmdHandler
virtual void ALOG_SET_EVENT_SEND_FILTER_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, SendFilterLevel FilterLevel, SendFilterEnabled FilterEnable)=0
Handler for command ALOG_SET_EVENT_SEND_FILTER.
Svc::ActiveLoggerComponentBase::get_pingIn_InputPort
Svc::InputPingPort * get_pingIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:103
Fw::Time
Definition: Time.hpp:10
Svc::ActiveLoggerComponentBase::m_pingOut_OutputPort
Svc::OutputPingPort m_pingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:937
Fw::QueuedComponentBase::incNumMsgDropped
void incNumMsgDropped(void)
increment the number of messages dropped
Definition: QueuedComponentBase.cpp:46
Svc::ActiveLoggerComponentBase::log_WARNING_LO_ALOG_ID_FILTER_LIST_FULL
void log_WARNING_LO_ALOG_ID_FILTER_LIST_FULL(U32 ID)
Definition: ActiveLoggerComponentAc.cpp:1731
Fw::QueuedComponentBase::doDispatch
virtual MsgDispatchStatus doDispatch(void)=0
method to dispatch a single message in the queue.
Os::Queue::QUEUE_FULL
@ QUEUE_FULL
queue was full when attempting to send a message
Definition: Queue.hpp:36
Svc::ActiveLoggerComponentBase::id
PROTECTED FwEventIdType id
Definition: ActiveLoggerComponentAc.hpp:271
Svc::ActiveLoggerComponentBase::args
PROTECTED FwEventIdType Fw::Time Fw::LogSeverity Fw::LogBuffer & args
Definition: ActiveLoggerComponentAc.hpp:275
Fw::OutputCmdResponsePort::addCallPort
void addCallPort(InputCmdResponsePort *callPort)
Definition: CmdResponsePortAc.cpp:105
Svc::ActiveLoggerComponentBase::log_WARNING_LO_ALOG_ID_FILTER_NOT_FOUND
void log_WARNING_LO_ALOG_ID_FILTER_NOT_FOUND(U32 ID)
Definition: ActiveLoggerComponentAc.cpp:1927
Fw::SerializeBufferBase
Definition: Serializable.hpp:43
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Fw::CommandResponse
CommandResponse
Definition: CmdResponsePortAc.hpp:24
Fw::PortBase::isConnected
bool isConnected(void)
Definition: PortBase.cpp:40
Fw::OutputLogPort::invoke
void invoke(FwEventIdType id, Fw::Time &timeTag, LogSeverity severity, LogBuffer &args)
Definition: LogPortAc.cpp:121
Fw::OutputCmdRegPort::addCallPort
void addCallPort(InputCmdRegPort *callPort)
Definition: CmdRegPortAc.cpp:93
Fw::LOG_WARNING_HI
@ LOG_WARNING_HI
Definition: LogPortAc.hpp:28
FW_OBJECT_NAMES
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects)
Definition: FpConfig.hpp:91
Fw::SerializeBufferBase::serialize
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
Definition: Serializable.cpp:67
Svc::ActiveLoggerComponentBase::portNum
PRIVATE NATIVE_INT_TYPE portNum
Definition: ActiveLoggerComponentAc.hpp:971
Fw::LOG_WARNING_LO
@ LOG_WARNING_LO
Definition: LogPortAc.hpp:29
FW_NUM_ARRAY_ELEMENTS
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition: BasicTypes.hpp:103
Svc::ActiveLoggerComponentBase::set_CmdStatus_OutputPort
void set_CmdStatus_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputCmdResponsePort *port)
Definition: ActiveLoggerComponentAc.cpp:151
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.hpp:76
Svc::ActiveLoggerComponentBase::FatalAnnounce_out
void FatalAnnounce_out(NATIVE_INT_TYPE portNum, FwEventIdType Id)
Definition: ActiveLoggerComponentAc.cpp:639
Svc::ActiveLoggerComponentBase::ALOG_SET_ID_FILTER_preMsgHook
virtual void ALOG_SET_ID_FILTER_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Definition: ActiveLoggerComponentAc.cpp:1186
Svc::ActiveLoggerComponentBase::OPCODE_ALOG_DUMP_EVENT_LOG
PROTECTED OPCODE_ALOG_DUMP_EVENT_LOG
Definition: ActiveLoggerComponentAc.hpp:582
Svc::ActiveLoggerComponentBase::FilterEnable
PROTECTED U32 InputFilterLevel InputFilterEnabled FilterEnable
Definition: ActiveLoggerComponentAc.hpp:600
Svc::InputPingPort::init
void init(void)
initialization function
Definition: PingPortAc.cpp:38
FwEnumStoreType
#define FwEnumStoreType
Type representation for an enumeration value.
Definition: FpConfig.hpp:84
port1
BYTE port1[Svc::InputPingPort::SERIALIZED_SIZE]
Definition: ActiveLoggerComponentAc.cpp:42
Fw::InputCmdRegPort
Definition: CmdRegPortAc.hpp:27
Svc::OutputPingPort::init
void init(void)
Definition: PingPortAc.cpp:89
Os::Queue::QueueStatus
QueueStatus
Definition: Queue.hpp:27
Fw::COMMAND_FORMAT_ERROR
@ COMMAND_FORMAT_ERROR
Definition: CmdResponsePortAc.hpp:28
Fw::QueuedComponentBase::m_queue
Os::Queue m_queue
queue object for active component
Definition: QueuedComponentBase.hpp:36
Fw::LogBuffer
Definition: LogBuffer.hpp:22
Fw::LogSeverity
LogSeverity
Definition: LogPortAc.hpp:26
Svc::ActiveLoggerComponentBase::OPCODE_ALOG_SET_EVENT_SEND_FILTER
PROTECTED OPCODE_ALOG_SET_EVENT_SEND_FILTER
Definition: ActiveLoggerComponentAc.hpp:581
Fw::InputCmdPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: CmdPortAc.cpp:42
Svc::ActiveLoggerComponentBase::log_ACTIVITY_HI_ALOG_ID_FILTER_REMOVED
void log_ACTIVITY_HI_ALOG_ID_FILTER_REMOVED(U32 ID)
Definition: ActiveLoggerComponentAc.cpp:1829
Svc::ActiveLoggerComponentBase::ALOG_SET_ID_FILTER_cmdHandlerBase
void ALOG_SET_ID_FILTER_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: ActiveLoggerComponentAc.cpp:1125
Svc::ActiveLoggerComponentBase::ALOG_DUMP_FILTER_STATE_cmdHandlerBase
void ALOG_DUMP_FILTER_STATE_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: ActiveLoggerComponentAc.cpp:1195
Svc::ActiveLoggerComponentBase::isConnected_FatalAnnounce_OutputPort
bool isConnected_FatalAnnounce_OutputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:767
Svc::OutputPingPort::invoke
void invoke(U32 key)
Definition: PingPortAc.cpp:103
Fw::Time::deserialize
SerializeStatus deserialize(SerializeBufferBase &buffer)
deserialize to contents
Definition: Time.cpp:103
Svc::ActiveLoggerComponentBase::isConnected_CmdReg_OutputPort
bool isConnected_CmdReg_OutputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:797
ActiveLoggerComponentAc.hpp
Fw::CmdStringArg
Definition: CmdString.hpp:11
Fw::TEXT_LOG_WARNING_HI
@ TEXT_LOG_WARNING_HI
Definition: LogTextPortAc.hpp:28
Svc::ActiveLoggerComponentBase::isConnected_CmdStatus_OutputPort
bool isConnected_CmdStatus_OutputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:787
Svc::ActiveLoggerComponentBase::severity
PROTECTED FwEventIdType Fw::Time Fw::LogSeverity severity
Definition: ActiveLoggerComponentAc.hpp:273
Svc::ActiveLoggerComponentBase::EVENTID_ALOG_ID_FILTER_ENABLED
PROTECTED EVENTID_ALOG_ID_FILTER_ENABLED
Definition: ActiveLoggerComponentAc.hpp:737
Svc::ActiveLoggerComponentBase::m_pingIn_InputPort
Svc::InputPingPort m_pingIn_InputPort[NUM_PINGIN_INPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:915
Assert.hpp
Fw::FW_SERIALIZE_OK
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Svc::ActiveLoggerComponentBase::set_CmdReg_OutputPort
void set_CmdReg_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputCmdRegPort *port)
Definition: ActiveLoggerComponentAc.cpp:161
Os::Queue::send
QueueStatus send(const Fw::SerializeBufferBase &buffer, NATIVE_INT_TYPE priority, QueueBlocking block)
send a message
Definition: QueueCommon.cpp:13
Fw::InputCmdPort::init
void init(void)
initialization function
Definition: CmdPortAc.cpp:38
Svc::ActiveLoggerComponentBase::ALOG_DUMP_EVENT_LOG_cmdHandler
virtual void ALOG_DUMP_EVENT_LOG_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &filename)=0
Handler for command ALOG_DUMP_EVENT_LOG.
Fw::InputComPort
Definition: ComPortAc.hpp:28
Svc::ActiveLoggerComponentBase::OPCODE_ALOG_SET_ID_FILTER
PROTECTED OPCODE_ALOG_SET_ID_FILTER
Definition: ActiveLoggerComponentAc.hpp:583
Svc::OutputPingPort::addCallPort
void addCallPort(InputPingPort *callPort)
Definition: PingPortAc.cpp:93
EightyCharString.hpp
Svc::OutputFatalEventPort::addCallPort
void addCallPort(InputFatalEventPort *callPort)
Definition: FatalEventPortAc.cpp:93
Svc::ActiveLoggerComponentBase::pingIn_handler
virtual void pingIn_handler(NATIVE_INT_TYPE portNum, U32 key)=0
Handler for input port pingIn.
Fw::PassiveComponentBase
Definition: PassiveComponentBase.hpp:10
Fw::OutputLogPort::init
void init(void)
Definition: LogPortAc.cpp:107
Svc::ActiveLoggerComponentBase::set_FatalAnnounce_OutputPort
void set_FatalAnnounce_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputFatalEventPort *port)
Definition: ActiveLoggerComponentAc.cpp:131
Svc::ActiveLoggerComponentBase::getNum_CmdReg_OutputPorts
NATIVE_INT_TYPE getNum_CmdReg_OutputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:719
Fw::OutputTimePort::init
void init(void)
Definition: TimePortAc.cpp:89
Fw::ObjBase::init
void init(void)
Object initializer.
Definition: ObjBase.cpp:26
Os::Queue::QueueBlocking
QueueBlocking
Definition: Queue.hpp:40
Fw::QueuedComponentBase::MSG_DISPATCH_OK
@ MSG_DISPATCH_OK
Dispatch was normal.
Definition: QueuedComponentBase.hpp:26
Svc::ActiveLoggerComponentBase::set_Log_OutputPort
void set_Log_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputLogPort *port)
Definition: ActiveLoggerComponentAc.cpp:181
BYTE
U8 BYTE
byte type
Definition: BasicTypes.hpp:77
Os::Queue::receive
QueueStatus receive(Fw::SerializeBufferBase &buffer, NATIVE_INT_TYPE &priority, QueueBlocking block)
receive a message
Definition: QueueCommon.cpp:22
Fw::TEXT_LOG_WARNING_LO
@ TEXT_LOG_WARNING_LO
Definition: LogTextPortAc.hpp:29
Svc::InputPingPort
Definition: PingPortAc.hpp:27
loqQueueIntIfSize
BYTE loqQueueIntIfSize[sizeof(FwEventIdType)+Fw::Time::SERIALIZED_SIZE+sizeof(FwEnumStoreType)+Fw::LogBuffer::SERIALIZED_SIZE+0]
Definition: ActiveLoggerComponentAc.cpp:51
Svc::ActiveLoggerComponentBase::isConnected_Log_OutputPort
bool isConnected_Log_OutputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:817
Fw::TEXT_LOG_ACTIVITY_LO
@ TEXT_LOG_ACTIVITY_LO
Definition: LogTextPortAc.hpp:32
Fw::OutputCmdRegPort::invoke
void invoke(FwOpcodeType opCode)
Definition: CmdRegPortAc.cpp:103
Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT
@ ACTIVE_COMPONENT_EXIT
message to exit active component task
Definition: ActiveComponentBase.hpp:27
Svc::ActiveLoggerComponentBase::m_CmdDisp_InputPort
Fw::InputCmdPort m_CmdDisp_InputPort[NUM_CMDDISP_INPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:919
Svc::ActiveLoggerComponentBase::ALOG_SET_ID_FILTER_cmdHandler
virtual void ALOG_SET_ID_FILTER_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, U32 ID, IdFilterEnabled IdFilterEnable)=0
Handler for command ALOG_SET_ID_FILTER.
Svc::ActiveLoggerComponentBase::error
PROTECTED I32 error
Definition: ActiveLoggerComponentAc.hpp:790
Svc::OutputFatalEventPort::init
void init(void)
Definition: FatalEventPortAc.cpp:89
FwOpcodeType
#define FwOpcodeType
Type representation for a command opcode.
Definition: FpConfig.hpp:62
Fw::QueuedComponentBase::MsgDispatchStatus
MsgDispatchStatus
Definition: QueuedComponentBase.hpp:25
Svc::ActiveLoggerComponentBase::set_pingOut_OutputPort
void set_pingOut_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputPingPort *port)
Definition: ActiveLoggerComponentAc.cpp:141
NATIVE_UINT_TYPE
unsigned int NATIVE_UINT_TYPE
native unsigned integer type declaration
Definition: BasicTypes.hpp:30
Fw::OutputTimePort::invoke
void invoke(Fw::Time &time)
Definition: TimePortAc.cpp:103
Fw::LogBuffer::SERIALIZED_SIZE
@ SERIALIZED_SIZE
Definition: LogBuffer.hpp:27
Svc::ActiveLoggerComponentBase
Auto-generated base for ActiveLogger component.
Definition: ActiveLoggerComponentAc.hpp:48
Svc::ActiveLoggerComponentBase::get_CmdDisp_InputPort
Fw::InputCmdPort * get_CmdDisp_InputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:110
Svc::ActiveLoggerComponentBase::ALOG_DUMP_EVENT_LOG_cmdHandlerBase
void ALOG_DUMP_EVENT_LOG_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: ActiveLoggerComponentAc.cpp:1055
Fw::CmdArgBuffer
Definition: CmdArgBuffer.hpp:22
cmdPort
BYTE cmdPort[Fw::InputCmdPort::SERIALIZED_SIZE]
Definition: ActiveLoggerComponentAc.cpp:43
Svc::ActiveLoggerComponentBase::isConnected_pingOut_OutputPort
bool isConnected_pingOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:777
Svc::ActiveLoggerComponentBase::log_ACTIVITY_HI_ALOG_FILE_WRITE_COMPLETE
void log_ACTIVITY_HI_ALOG_FILE_WRITE_COMPLETE(U32 records)
Definition: ActiveLoggerComponentAc.cpp:1401
Fw::OutputCmdResponsePort::init
void init(void)
Definition: CmdResponsePortAc.cpp:101
Fw::COMMAND_INVALID_OPCODE
@ COMMAND_INVALID_OPCODE
Definition: CmdResponsePortAc.hpp:26
Svc::ActiveLoggerComponentBase::data
PROTECTED Fw::ComBuffer & data
Definition: ActiveLoggerComponentAc.hpp:336
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:9
Svc::ActiveLoggerComponentBase::getNum_FatalAnnounce_OutputPorts
NATIVE_INT_TYPE getNum_FatalAnnounce_OutputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:679
Svc::ActiveLoggerComponentBase::getNum_CmdStatus_OutputPorts
NATIVE_INT_TYPE getNum_CmdStatus_OutputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:711
Fw::OutputCmdResponsePort::invoke
void invoke(FwOpcodeType opCode, U32 cmdSeq, CommandResponse response)
Definition: CmdResponsePortAc.cpp:115
Svc::ActiveLoggerComponentBase::ALOG_SET_EVENT_SEND_FILTER_cmdHandlerBase
void ALOG_SET_EVENT_SEND_FILTER_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: ActiveLoggerComponentAc.cpp:992
Fw::QueuedComponentBase::MSG_DISPATCH_ERROR
@ MSG_DISPATCH_ERROR
Errors dispatching messages.
Definition: QueuedComponentBase.hpp:28
Fw::LOG_ACTIVITY_HI
@ LOG_ACTIVITY_HI
Definition: LogPortAc.hpp:31
Svc::ActiveLoggerComponentBase::OPCODE_ALOG_DUMP_FILTER_STATE
PROTECTED OPCODE_ALOG_DUMP_FILTER_STATE
Definition: ActiveLoggerComponentAc.hpp:584
Os::Queue::QUEUE_OK
@ QUEUE_OK
message sent/received okay
Definition: Queue.hpp:28
Svc::ActiveLoggerComponentBase::m_CmdStatus_OutputPort
Fw::OutputCmdResponsePort m_CmdStatus_OutputPort[NUM_CMDSTATUS_OUTPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:941
Svc::ActiveLoggerComponentBase::getNum_Log_OutputPorts
NATIVE_INT_TYPE getNum_Log_OutputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:735
Svc::ActiveLoggerComponentBase::EVENTID_ALOG_SEVERITY_FILTER_STATE
PROTECTED EVENTID_ALOG_SEVERITY_FILTER_STATE
Definition: ActiveLoggerComponentAc.hpp:736
Svc::OutputFatalEventPort::invoke
void invoke(FwEventIdType Id)
Definition: FatalEventPortAc.cpp:103
Svc::ActiveLoggerComponentBase::set_PktSend_OutputPort
void set_PktSend_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputComPort *port)
Definition: ActiveLoggerComponentAc.cpp:121
Svc::ActiveLoggerComponentBase::getNum_pingIn_InputPorts
NATIVE_INT_TYPE getNum_pingIn_InputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:687
Svc::ActiveLoggerComponentBase::timeTag
PROTECTED FwEventIdType Fw::Time & timeTag
Definition: ActiveLoggerComponentAc.hpp:272
Fw::InputCmdPort
Definition: CmdPortAc.hpp:28
Svc::ActiveLoggerComponentBase::EVENTID_ALOG_ID_FILTER_NOT_FOUND
PROTECTED EVENTID_ALOG_ID_FILTER_NOT_FOUND
Definition: ActiveLoggerComponentAc.hpp:740
FpConfig.hpp
ISF configuration file.
Fw::InputPortBase::setPortNum
void setPortNum(NATIVE_INT_TYPE portNum)
Definition: InputPortBase.cpp:25
Fw::OutputLogPort::addCallPort
void addCallPort(InputLogPort *callPort)
Definition: LogPortAc.cpp:111
Fw::QueuedComponentBase::MSG_DISPATCH_EXIT
@ MSG_DISPATCH_EXIT
A message was sent requesting an exit of the loop.
Definition: QueuedComponentBase.hpp:29
Svc::ActiveLoggerComponentBase::m_Log_OutputPort
Fw::OutputLogPort m_Log_OutputPort[NUM_LOG_OUTPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:953
Svc::ActiveLoggerComponentBase::ALOG_DUMP_FILTER_STATE_cmdHandler
virtual void ALOG_DUMP_FILTER_STATE_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
Handler for command ALOG_DUMP_FILTER_STATE.
Svc::ActiveLoggerComponentBase::response
PROTECTED U32 Fw::CommandResponse response
Definition: ActiveLoggerComponentAc.hpp:725
Svc::ActiveLoggerComponentBase::getNum_CmdDisp_InputPorts
NATIVE_INT_TYPE getNum_CmdDisp_InputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:703
Svc::ActiveLoggerComponentBase::EVENTID_ALOG_ID_FILTER_REMOVED
PROTECTED EVENTID_ALOG_ID_FILTER_REMOVED
Definition: ActiveLoggerComponentAc.hpp:739
Svc
Definition: ActiveLoggerComponentAc.cpp:22
Svc::ActiveLoggerComponentBase::key
PROTECTED U32 key
Definition: ActiveLoggerComponentAc.hpp:324
Os::Queue::QUEUE_NONBLOCKING
@ QUEUE_NONBLOCKING
Queue receive always returns even if there is no message.
Definition: Queue.hpp:42
Fw::InputCmdResponsePort
Definition: CmdResponsePortAc.hpp:37
Svc::ActiveLoggerComponentBase::SendFilterLevel
SendFilterLevel
Definition: ActiveLoggerComponentAc.hpp:551
Svc::ActiveLoggerComponentBase::log_ACTIVITY_HI_ALOG_ID_FILTER_ENABLED
void log_ACTIVITY_HI_ALOG_ID_FILTER_ENABLED(U32 ID)
Definition: ActiveLoggerComponentAc.cpp:1633
Svc::ActiveLoggerComponentBase::~ActiveLoggerComponentBase
virtual ~ActiveLoggerComponentBase(void)
Definition: ActiveLoggerComponentAc.cpp:620
Fw::InputLogPort
Definition: LogPortAc.hpp:40
Svc::ActiveLoggerComponentBase::regCommands
void regCommands(void)
Register commands with the Command Dispatcher.
Definition: ActiveLoggerComponentAc.cpp:297
Svc::ActiveLoggerComponentBase::get_LogRecv_InputPort
Fw::InputLogPort * get_LogRecv_InputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:96
Svc::ActiveLoggerComponentBase::getNum_Time_OutputPorts
NATIVE_INT_TYPE getNum_Time_OutputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:727
Svc::ActiveLoggerComponentBase::isConnected_Time_OutputPort
bool isConnected_Time_OutputPort(NATIVE_INT_TYPE portNum)
Definition: ActiveLoggerComponentAc.cpp:807
Svc::ActiveLoggerComponentBase::InputFilterEnabled
InputFilterEnabled
Definition: ActiveLoggerComponentAc.hpp:545
Svc::InputFatalEventPort
Definition: FatalEventPortAc.hpp:27
Svc::ActiveLoggerComponentBase::log_ACTIVITY_LO_ALOG_SEVERITY_FILTER_STATE
void log_ACTIVITY_LO_ALOG_SEVERITY_FILTER_STATE(EventFilterState severity, bool recvEnabled, bool sendEnabled)
Definition: ActiveLoggerComponentAc.cpp:1499
Svc::ActiveLoggerComponentBase::m_p_pingIn_in
static void m_p_pingIn_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, U32 key)
Definition: ActiveLoggerComponentAc.cpp:2094
FwEventIdType
#define FwEventIdType
Type representation for a event id.
Definition: FpConfig.hpp:70
Fw::LOG_ACTIVITY_LO
@ LOG_ACTIVITY_LO
Definition: LogPortAc.hpp:32
Svc::ActiveLoggerComponentBase::EVENTID_ALOG_FILE_WRITE_COMPLETE
PROTECTED EVENTID_ALOG_FILE_WRITE_COMPLETE
Definition: ActiveLoggerComponentAc.hpp:735
Svc::ActiveLoggerComponentBase::m_FatalAnnounce_OutputPort
Svc::OutputFatalEventPort m_FatalAnnounce_OutputPort[NUM_FATALANNOUNCE_OUTPUT_PORTS]
Definition: ActiveLoggerComponentAc.hpp:933
Svc::ActiveLoggerComponentBase::cmdSeq
PROTECTED U32 cmdSeq
Definition: ActiveLoggerComponentAc.hpp:597
NATIVE_INT_TYPE
int NATIVE_INT_TYPE
native integer type declaration
Definition: BasicTypes.hpp:29
Svc::ActiveLoggerComponentBase::SendFilterEnabled
SendFilterEnabled
Definition: ActiveLoggerComponentAc.hpp:561
AssertArg
#define AssertArg
Definition: FpConfig.hpp:51
Fw::ComBuffer
Definition: ComBuffer.hpp:21
Svc::ActiveLoggerComponentBase::EventFilterState
EventFilterState
Definition: ActiveLoggerComponentAc.hpp:768
Fw::Time::SERIALIZED_SIZE
@ SERIALIZED_SIZE
Definition: Time.hpp:14
Svc::ActiveLoggerComponentBase::getNum_pingOut_OutputPorts
NATIVE_INT_TYPE getNum_pingOut_OutputPorts(void)
Definition: ActiveLoggerComponentAc.cpp:695
Fw::QueuedComponentBase::createQueue
Os::Queue::QueueStatus createQueue(NATIVE_INT_TYPE depth, NATIVE_INT_TYPE msgSize)
Definition: QueuedComponentBase.cpp:29
TB_NONE
@ TB_NONE
No time base has been established.
Definition: FpConfig.hpp:324
Fw::InputCmdPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: CmdPortAc.hpp:31
Fw
Definition: BufferGetPortAc.cpp:6
Fw::OutputTimePort::addCallPort
void addCallPort(InputTimePort *callPort)
Definition: TimePortAc.cpp:93
Svc::ActiveLoggerComponentBase::m_p_CmdDisp_in
static void m_p_CmdDisp_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: ActiveLoggerComponentAc.cpp:843
Svc::ActiveLoggerComponentBase::ALOG_DUMP_FILTER_STATE_preMsgHook
virtual void ALOG_DUMP_FILTER_STATE_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Definition: ActiveLoggerComponentAc.cpp:1256
FW_LOG_TEXT_BUFFER_SIZE
#define FW_LOG_TEXT_BUFFER_SIZE
Max size of string for text log message.
Definition: FpConfig.hpp:291
Os::Queue::QUEUE_BLOCKING
@ QUEUE_BLOCKING
Queue receive blocks until a message arrives.
Definition: Queue.hpp:41
Svc::ActiveLoggerComponentBase::set_Time_OutputPort
void set_Time_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTimePort *port)
Definition: ActiveLoggerComponentAc.cpp:171
Svc::ActiveLoggerComponentBase::context
PROTECTED Fw::ComBuffer U32 context
Definition: ActiveLoggerComponentAc.hpp:338
Fw::InputLogTextPort
Definition: LogTextPortAc.hpp:40
Svc::ActiveLoggerComponentBase::QueueLogSeverity
PROTECTED QueueLogSeverity_MAX QueueLogSeverity
Definition: ActiveLoggerComponentAc.hpp:870
Svc::InputPingPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: PingPortAc.cpp:42