F´ Flight Software - C/C++ Documentation  NASA-v1.5.0
A framework for building embedded system applications to NASA flight quality standards.
HealthComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title HealthComponentAc.cpp
3 // \author Auto-generated
4 // \brief cpp file for Health 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  HEALTH_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
32  PINGRETURN_PING,
33  CMD_HLTH_ENABLE,
34  CMD_HLTH_PING_ENABLE,
35  CMD_HLTH_CHNG_PING
36  } MsgTypeEnum;
37 
38  // Get the max size by doing a union of the input port serialization sizes.
39 
40  typedef union {
43  } BuffUnion;
44 
45  // Define a message buffer class large enough to handle all the
46  // asynchronous inputs to the component
47 
48  class ComponentIpcSerializableBuffer :
50  {
51 
52  public:
53 
54  enum {
55  // Max. message size = size of data + message id + port
56  SERIALIZATION_SIZE =
57  sizeof(BuffUnion) +
58  sizeof(NATIVE_INT_TYPE) +
59  sizeof(NATIVE_INT_TYPE)
60  };
61 
62  NATIVE_UINT_TYPE getBuffCapacity(void) const {
63  return sizeof(m_buff);
64  }
65 
66  U8* getBuffAddr(void) {
67  return m_buff;
68  }
69 
70  const U8* getBuffAddr(void) const {
71  return m_buff;
72  }
73 
74  private:
75  // Should be the max of all the input ports serialized sizes...
76  U8 m_buff[SERIALIZATION_SIZE];
77 
78  };
79 
80  }
81 
82  // ----------------------------------------------------------------------
83  // Getters for numbers of input ports
84  // ----------------------------------------------------------------------
85 
88  {
89  FW_ASSERT(portNum < this->getNum_PingReturn_InputPorts(),static_cast<AssertArg>(portNum));
90  return &this->m_PingReturn_InputPort[portNum];
91  }
92 
95  {
96  FW_ASSERT(portNum < this->getNum_Run_InputPorts(),static_cast<AssertArg>(portNum));
97  return &this->m_Run_InputPort[portNum];
98  }
99 
102  {
103  FW_ASSERT(portNum < this->getNum_CmdDisp_InputPorts(),static_cast<AssertArg>(portNum));
104  return &this->m_CmdDisp_InputPort[portNum];
105  }
106 
107  // ----------------------------------------------------------------------
108  // Typed connectors for output ports
109  // ----------------------------------------------------------------------
110 
113  NATIVE_INT_TYPE portNum,
114  Svc::InputPingPort* port
115  )
116  {
117  FW_ASSERT(portNum < this->getNum_PingSend_OutputPorts(),static_cast<AssertArg>(portNum));
118  this->m_PingSend_OutputPort[portNum].addCallPort(port);
119  }
120 
123  NATIVE_INT_TYPE portNum,
125  )
126  {
127  FW_ASSERT(portNum < this->getNum_WdogStroke_OutputPorts(),static_cast<AssertArg>(portNum));
129  }
130 
133  NATIVE_INT_TYPE portNum,
135  )
136  {
137  FW_ASSERT(portNum < this->getNum_CmdStatus_OutputPorts(),static_cast<AssertArg>(portNum));
139  }
140 
143  NATIVE_INT_TYPE portNum,
144  Fw::InputCmdRegPort* port
145  )
146  {
147  FW_ASSERT(portNum < this->getNum_CmdReg_OutputPorts(),static_cast<AssertArg>(portNum));
149  }
150 
153  NATIVE_INT_TYPE portNum,
154  Fw::InputTlmPort* port
155  )
156  {
157  FW_ASSERT(portNum < this->getNum_Tlm_OutputPorts(),static_cast<AssertArg>(portNum));
158  this->m_Tlm_OutputPort[portNum].addCallPort(port);
159  }
160 
163  NATIVE_INT_TYPE portNum,
164  Fw::InputTimePort* port
165  )
166  {
167  FW_ASSERT(portNum < this->getNum_Time_OutputPorts(),static_cast<AssertArg>(portNum));
169  }
170 
173  NATIVE_INT_TYPE portNum,
174  Fw::InputLogPort* port
175  )
176  {
177  FW_ASSERT(portNum < this->getNum_Log_OutputPorts(),static_cast<AssertArg>(portNum));
178  this->m_Log_OutputPort[portNum].addCallPort(port);
179  }
180 
181 #if FW_ENABLE_TEXT_LOGGING == 1
182  void HealthComponentBase ::
183  set_LogText_OutputPort(
184  NATIVE_INT_TYPE portNum,
186  )
187  {
188  FW_ASSERT(portNum < this->getNum_LogText_OutputPorts(),static_cast<AssertArg>(portNum));
189  this->m_LogText_OutputPort[portNum].addCallPort(port);
190  }
191 #endif
192 
193  // ----------------------------------------------------------------------
194  // Serialization connectors for output ports
195  // ----------------------------------------------------------------------
196 
197 #if FW_PORT_SERIALIZATION
198 
201  NATIVE_INT_TYPE portNum,
202  Fw::InputSerializePort *port
203  )
204  {
205  FW_ASSERT(portNum < this->getNum_PingSend_OutputPorts(),static_cast<AssertArg>(portNum));
206  return this->m_PingSend_OutputPort[portNum].registerSerialPort(port);
207  }
208 
211  NATIVE_INT_TYPE portNum,
212  Fw::InputSerializePort *port
213  )
214  {
215  FW_ASSERT(portNum < this->getNum_WdogStroke_OutputPorts(),static_cast<AssertArg>(portNum));
216  return this->m_WdogStroke_OutputPort[portNum].registerSerialPort(port);
217  }
218 
221  NATIVE_INT_TYPE portNum,
222  Fw::InputSerializePort *port
223  )
224  {
225  FW_ASSERT(portNum < this->getNum_CmdStatus_OutputPorts(),static_cast<AssertArg>(portNum));
226  return this->m_CmdStatus_OutputPort[portNum].registerSerialPort(port);
227  }
228 
231  NATIVE_INT_TYPE portNum,
232  Fw::InputSerializePort *port
233  )
234  {
235  FW_ASSERT(portNum < this->getNum_CmdReg_OutputPorts(),static_cast<AssertArg>(portNum));
236  return this->m_CmdReg_OutputPort[portNum].registerSerialPort(port);
237  }
238 
241  NATIVE_INT_TYPE portNum,
242  Fw::InputSerializePort *port
243  )
244  {
245  FW_ASSERT(portNum < this->getNum_Tlm_OutputPorts(),static_cast<AssertArg>(portNum));
246  return this->m_Tlm_OutputPort[portNum].registerSerialPort(port);
247  }
248 
251  NATIVE_INT_TYPE portNum,
252  Fw::InputSerializePort *port
253  )
254  {
255  FW_ASSERT(portNum < this->getNum_Time_OutputPorts(),static_cast<AssertArg>(portNum));
256  return this->m_Time_OutputPort[portNum].registerSerialPort(port);
257  }
258 
261  NATIVE_INT_TYPE portNum,
262  Fw::InputSerializePort *port
263  )
264  {
265  FW_ASSERT(portNum < this->getNum_Log_OutputPorts(),static_cast<AssertArg>(portNum));
266  return this->m_Log_OutputPort[portNum].registerSerialPort(port);
267  }
268 
269 #if FW_ENABLE_TEXT_LOGGING == 1
270  void HealthComponentBase ::
271  set_LogText_OutputPort(
272  NATIVE_INT_TYPE portNum,
273  Fw::InputSerializePort *port
274  )
275  {
276  FW_ASSERT(portNum < this->getNum_LogText_OutputPorts(),static_cast<AssertArg>(portNum));
277  return this->m_LogText_OutputPort[portNum].registerSerialPort(port);
278  }
279 #endif
280 
281 #endif
282 
283  // ----------------------------------------------------------------------
284  // Command registration
285  // ----------------------------------------------------------------------
286 
288  regCommands(void)
289  {
290  FW_ASSERT(this->m_CmdReg_OutputPort[0].isConnected());
291  this->m_CmdReg_OutputPort[0].invoke(
292  this->getIdBase() + OPCODE_HLTH_ENABLE
293  );
294  this->m_CmdReg_OutputPort[0].invoke(
296  );
297  this->m_CmdReg_OutputPort[0].invoke(
299  );
300  }
301 
302  // ----------------------------------------------------------------------
303  // Component construction, initialization, and destruction
304  // ----------------------------------------------------------------------
305 
307 #if FW_OBJECT_NAMES == 1
308  HealthComponentBase(const char* compName) :
309  Fw::QueuedComponentBase(compName)
310 #else
312  Fw::QueuedComponentBase()
313 #endif
314  {
315 
316 
317 
318 
319  }
320 
322  init(
323  NATIVE_INT_TYPE queueDepth,
324  NATIVE_INT_TYPE instance
325  )
326  {
327 
328  // Initialize base class
330 
331  // Connect input port PingReturn
332  for (
333  NATIVE_INT_TYPE port = 0;
334  port < this->getNum_PingReturn_InputPorts();
335  port++
336  ) {
337 
338  this->m_PingReturn_InputPort[port].init();
339  this->m_PingReturn_InputPort[port].addCallComp(
340  this,
341  m_p_PingReturn_in
342  );
343  this->m_PingReturn_InputPort[port].setPortNum(port);
344 
345 #if FW_OBJECT_NAMES == 1
346  char portName[120];
347  (void) snprintf(
348  portName,
349  sizeof(portName),
350  "%s_PingReturn_InputPort[%d]",
351  this->m_objName,
352  port
353  );
354  this->m_PingReturn_InputPort[port].setObjName(portName);
355 #endif
356 
357  }
358 
359  // Connect input port Run
360  for (
361  NATIVE_INT_TYPE port = 0;
362  port < this->getNum_Run_InputPorts();
363  port++
364  ) {
365 
366  this->m_Run_InputPort[port].init();
367  this->m_Run_InputPort[port].addCallComp(
368  this,
369  m_p_Run_in
370  );
371  this->m_Run_InputPort[port].setPortNum(port);
372 
373 #if FW_OBJECT_NAMES == 1
374  char portName[120];
375  (void) snprintf(
376  portName,
377  sizeof(portName),
378  "%s_Run_InputPort[%d]",
379  this->m_objName,
380  port
381  );
382  this->m_Run_InputPort[port].setObjName(portName);
383 #endif
384 
385  }
386 
387  // Connect input port CmdDisp
388  for (
389  NATIVE_INT_TYPE port = 0;
390  port < this->getNum_CmdDisp_InputPorts();
391  port++
392  ) {
393 
394  this->m_CmdDisp_InputPort[port].init();
395  this->m_CmdDisp_InputPort[port].addCallComp(
396  this,
398  );
399  this->m_CmdDisp_InputPort[port].setPortNum(port);
400 
401 #if FW_OBJECT_NAMES == 1
402  char portName[120];
403  (void) snprintf(
404  portName,
405  sizeof(portName),
406  "%s_CmdDisp_InputPort[%d]",
407  this->m_objName,
408  port
409  );
410  this->m_CmdDisp_InputPort[port].setObjName(portName);
411 #endif
412 
413  }
414 
415  // Initialize output port PingSend
416  for (
417  NATIVE_INT_TYPE port = 0;
418  port < this->getNum_PingSend_OutputPorts();
419  port++
420  ) {
421  this->m_PingSend_OutputPort[port].init();
422 
423 #if FW_OBJECT_NAMES == 1
424  char portName[120];
425  (void) snprintf(
426  portName,
427  sizeof(portName),
428  "%s_PingSend_OutputPort[%d]",
429  this->m_objName,
430  port
431  );
432  this->m_PingSend_OutputPort[port].setObjName(portName);
433 #endif
434 
435  }
436 
437  // Initialize output port WdogStroke
438  for (
439  NATIVE_INT_TYPE port = 0;
440  port < this->getNum_WdogStroke_OutputPorts();
441  port++
442  ) {
443  this->m_WdogStroke_OutputPort[port].init();
444 
445 #if FW_OBJECT_NAMES == 1
446  char portName[120];
447  (void) snprintf(
448  portName,
449  sizeof(portName),
450  "%s_WdogStroke_OutputPort[%d]",
451  this->m_objName,
452  port
453  );
454  this->m_WdogStroke_OutputPort[port].setObjName(portName);
455 #endif
456 
457  }
458 
459  // Initialize output port CmdStatus
460  for (
461  NATIVE_INT_TYPE port = 0;
462  port < this->getNum_CmdStatus_OutputPorts();
463  port++
464  ) {
465  this->m_CmdStatus_OutputPort[port].init();
466 
467 #if FW_OBJECT_NAMES == 1
468  char portName[120];
469  (void) snprintf(
470  portName,
471  sizeof(portName),
472  "%s_CmdStatus_OutputPort[%d]",
473  this->m_objName,
474  port
475  );
476  this->m_CmdStatus_OutputPort[port].setObjName(portName);
477 #endif
478 
479  }
480 
481  // Initialize output port CmdReg
482  for (
483  NATIVE_INT_TYPE port = 0;
484  port < this->getNum_CmdReg_OutputPorts();
485  port++
486  ) {
487  this->m_CmdReg_OutputPort[port].init();
488 
489 #if FW_OBJECT_NAMES == 1
490  char portName[120];
491  (void) snprintf(
492  portName,
493  sizeof(portName),
494  "%s_CmdReg_OutputPort[%d]",
495  this->m_objName,
496  port
497  );
498  this->m_CmdReg_OutputPort[port].setObjName(portName);
499 #endif
500 
501  }
502 
503  // Initialize output port Tlm
504  for (
505  NATIVE_INT_TYPE port = 0;
506  port < this->getNum_Tlm_OutputPorts();
507  port++
508  ) {
509  this->m_Tlm_OutputPort[port].init();
510 
511 #if FW_OBJECT_NAMES == 1
512  char portName[120];
513  (void) snprintf(
514  portName,
515  sizeof(portName),
516  "%s_Tlm_OutputPort[%d]",
517  this->m_objName,
518  port
519  );
520  this->m_Tlm_OutputPort[port].setObjName(portName);
521 #endif
522 
523  }
524 
525  // Initialize output port Time
526  for (
527  NATIVE_INT_TYPE port = 0;
528  port < this->getNum_Time_OutputPorts();
529  port++
530  ) {
531  this->m_Time_OutputPort[port].init();
532 
533 #if FW_OBJECT_NAMES == 1
534  char portName[120];
535  (void) snprintf(
536  portName,
537  sizeof(portName),
538  "%s_Time_OutputPort[%d]",
539  this->m_objName,
540  port
541  );
542  this->m_Time_OutputPort[port].setObjName(portName);
543 #endif
544 
545  }
546 
547  // Initialize output port Log
548  for (
549  NATIVE_INT_TYPE port = 0;
550  port < this->getNum_Log_OutputPorts();
551  port++
552  ) {
553  this->m_Log_OutputPort[port].init();
554 
555 #if FW_OBJECT_NAMES == 1
556  char portName[120];
557  (void) snprintf(
558  portName,
559  sizeof(portName),
560  "%s_Log_OutputPort[%d]",
561  this->m_objName,
562  port
563  );
564  this->m_Log_OutputPort[port].setObjName(portName);
565 #endif
566 
567  }
568 
569  // Initialize output port LogText
570 #if FW_ENABLE_TEXT_LOGGING == 1
571  for (
572  NATIVE_INT_TYPE port = 0;
573  port < this->getNum_LogText_OutputPorts();
574  port++
575  ) {
576  this->m_LogText_OutputPort[port].init();
577 
578 #if FW_OBJECT_NAMES == 1
579  char portName[120];
580  (void) snprintf(
581  portName,
582  sizeof(portName),
583  "%s_LogText_OutputPort[%d]",
584  this->m_objName,
585  port
586  );
587  this->m_LogText_OutputPort[port].setObjName(portName);
588 #endif
589 
590  }
591 #endif
592 
593  Os::Queue::QueueStatus qStat =
594  this->createQueue(
595  queueDepth,
596  ComponentIpcSerializableBuffer::SERIALIZATION_SIZE
597  );
598  FW_ASSERT(
599  Os::Queue::QUEUE_OK == qStat,
600  static_cast<AssertArg>(qStat)
601  );
602 
603  }
604 
607 
608  }
609 
610  // ----------------------------------------------------------------------
611  // Invocation functions for output ports
612  // ----------------------------------------------------------------------
613 
614  void HealthComponentBase ::
615  PingSend_out(
616  NATIVE_INT_TYPE portNum,
617  U32 key
618  )
619  {
620  FW_ASSERT(portNum < this->getNum_PingSend_OutputPorts(),static_cast<AssertArg>(portNum));
621  this->m_PingSend_OutputPort[portNum].invoke(key);
622  }
623 
626  NATIVE_INT_TYPE portNum,
627  U32 code
628  )
629  {
630  FW_ASSERT(portNum < this->getNum_WdogStroke_OutputPorts(),static_cast<AssertArg>(portNum));
632  }
633 
634  // ----------------------------------------------------------------------
635  // Getters for numbers of ports
636  // ----------------------------------------------------------------------
637 
638  NATIVE_INT_TYPE HealthComponentBase ::
639  getNum_PingSend_OutputPorts(void)
640  {
642  this->m_PingSend_OutputPort
643  );
644  }
645 
646  NATIVE_INT_TYPE HealthComponentBase ::
647  getNum_PingReturn_InputPorts(void)
648  {
650  this->m_PingReturn_InputPort
651  );
652  }
653 
656  {
658  this->m_Run_InputPort
659  );
660  }
661 
664  {
667  );
668  }
669 
672  {
674  this->m_CmdDisp_InputPort
675  );
676  }
677 
680  {
683  );
684  }
685 
688  {
690  this->m_CmdReg_OutputPort
691  );
692  }
693 
696  {
698  this->m_Tlm_OutputPort
699  );
700  }
701 
704  {
706  this->m_Time_OutputPort
707  );
708  }
709 
712  {
714  this->m_Log_OutputPort
715  );
716  }
717 
718 #if FW_ENABLE_TEXT_LOGGING == 1
719  NATIVE_INT_TYPE HealthComponentBase ::
720  getNum_LogText_OutputPorts(void)
721  {
723  this->m_LogText_OutputPort
724  );
725  }
726 #endif
727 
728  // ----------------------------------------------------------------------
729  // Port connection status queries
730  // ----------------------------------------------------------------------
731 
732  bool HealthComponentBase ::
733  isConnected_PingSend_OutputPort(NATIVE_INT_TYPE portNum)
734  {
735  FW_ASSERT(
736  portNum < this->getNum_PingSend_OutputPorts(),
737  static_cast<AssertArg>(portNum)
738  );
739  return this->m_PingSend_OutputPort[portNum].isConnected();
740  }
741 
744  {
745  FW_ASSERT(
746  portNum < this->getNum_WdogStroke_OutputPorts(),
747  static_cast<AssertArg>(portNum)
748  );
750  }
751 
754  {
755  FW_ASSERT(
756  portNum < this->getNum_CmdStatus_OutputPorts(),
757  static_cast<AssertArg>(portNum)
758  );
760  }
761 
764  {
765  FW_ASSERT(
766  portNum < this->getNum_CmdReg_OutputPorts(),
767  static_cast<AssertArg>(portNum)
768  );
769  return this->m_CmdReg_OutputPort[portNum].isConnected();
770  }
771 
774  {
775  FW_ASSERT(
776  portNum < this->getNum_Tlm_OutputPorts(),
777  static_cast<AssertArg>(portNum)
778  );
779  return this->m_Tlm_OutputPort[portNum].isConnected();
780  }
781 
784  {
785  FW_ASSERT(
786  portNum < this->getNum_Time_OutputPorts(),
787  static_cast<AssertArg>(portNum)
788  );
789  return this->m_Time_OutputPort[portNum].isConnected();
790  }
791 
794  {
795  FW_ASSERT(
796  portNum < this->getNum_Log_OutputPorts(),
797  static_cast<AssertArg>(portNum)
798  );
799  return this->m_Log_OutputPort[portNum].isConnected();
800  }
801 
802 #if FW_ENABLE_TEXT_LOGGING == 1
803  bool HealthComponentBase ::
804  isConnected_LogText_OutputPort(NATIVE_INT_TYPE portNum)
805  {
806  FW_ASSERT(
807  portNum < this->getNum_LogText_OutputPorts(),
808  static_cast<AssertArg>(portNum)
809  );
810  return this->m_LogText_OutputPort[portNum].isConnected();
811  }
812 #endif
813 
814  // ----------------------------------------------------------------------
815  // Calls for messages received on command input ports
816  // ----------------------------------------------------------------------
817 
820  Fw::PassiveComponentBase* callComp,
821  NATIVE_INT_TYPE portNum,
822  FwOpcodeType opCode,
823  U32 cmdSeq,
824  Fw::CmdArgBuffer &args
825  )
826  {
827 
828  // Select base class function based on opcode
829  FW_ASSERT(callComp);
830  HealthComponentBase* compPtr =
831  (HealthComponentBase*) callComp;
832 
833  const U32 idBase = callComp->getIdBase();
834  FW_ASSERT(opCode >= idBase, opCode, idBase);
835  switch (opCode - idBase) {
836 
837  case OPCODE_HLTH_ENABLE:
838  compPtr->HLTH_ENABLE_cmdHandlerBase(
839  opCode,
840  cmdSeq,
841  args
842  );
843  break;
844 
847  opCode,
848  cmdSeq,
849  args
850  );
851  break;
852 
853  case OPCODE_HLTH_CHNG_PING:
855  opCode,
856  cmdSeq,
857  args
858  );
859  break;
860 
861  default: {
862  compPtr->cmdResponse_out(
863  opCode,cmdSeq,
865  );
866  break;
867  }
868 
869  }
870 
871  }
872 
873  void HealthComponentBase ::
874  cmdResponse_out(
875  FwOpcodeType opCode,
876  U32 cmdSeq,
877  Fw::CommandResponse response
878  )
879  {
880  FW_ASSERT(this->m_CmdStatus_OutputPort[0].isConnected());
881  this->m_CmdStatus_OutputPort[0].invoke(opCode,cmdSeq,response);
882  }
883 
884  // ----------------------------------------------------------------------
885  // Base class command functions
886  // ----------------------------------------------------------------------
887 
888  void HealthComponentBase ::
889  HLTH_ENABLE_cmdHandlerBase(
890  FwOpcodeType opCode,
891  U32 cmdSeq,
892  Fw::CmdArgBuffer &args
893  )
894  {
895 
896  // Call pre-message hook
897  this->HLTH_ENABLE_preMsgHook(opCode,cmdSeq);
898 
899  // Defer deserializing arguments to the message dispatcher
900  // to avoid deserializing and reserializing just for IPC
901  ComponentIpcSerializableBuffer msg;
903 
904  // Serialize for IPC
905  _status = msg.serialize((NATIVE_INT_TYPE)CMD_HLTH_ENABLE);
906  FW_ASSERT (
907  _status == Fw::FW_SERIALIZE_OK,
908  static_cast<AssertArg>(_status)
909  );
910 
911  // Fake port number to make message dequeue work
912  NATIVE_INT_TYPE port = 0;
913  _status = msg.serialize(port);
914  FW_ASSERT (
915  _status == Fw::FW_SERIALIZE_OK,
916  static_cast<AssertArg>(_status)
917  );
918 
919  _status = msg.serialize(opCode);
920  FW_ASSERT (
921  _status == Fw::FW_SERIALIZE_OK,
922  static_cast<AssertArg>(_status)
923  );
924 
925  _status = msg.serialize(cmdSeq);
926  FW_ASSERT (
927  _status == Fw::FW_SERIALIZE_OK,
928  static_cast<AssertArg>(_status)
929  );
930 
931  _status = msg.serialize(args);
932  FW_ASSERT (
933  _status == Fw::FW_SERIALIZE_OK,
934  static_cast<AssertArg>(_status)
935  );
936 
937  // send message
938  Os::Queue::QueueBlocking _block =
940  Os::Queue::QueueStatus qStatus =
941  this->m_queue.send(msg, 0,_block);
942  FW_ASSERT(
943  qStatus == Os::Queue::QUEUE_OK,
944  static_cast<AssertArg>(qStatus)
945  );
946 
947  }
948 
949  void HealthComponentBase::
950  HLTH_ENABLE_preMsgHook(
951  FwOpcodeType opCode,
952  U32 cmdSeq
953  )
954  {
955  // Defaults to no-op; can be overridden
956  }
957 
960  FwOpcodeType opCode,
961  U32 cmdSeq,
962  Fw::CmdArgBuffer &args
963  )
964  {
965 
966  // Call pre-message hook
967  this->HLTH_PING_ENABLE_preMsgHook(opCode,cmdSeq);
968 
969  // Defer deserializing arguments to the message dispatcher
970  // to avoid deserializing and reserializing just for IPC
971  ComponentIpcSerializableBuffer msg;
973 
974  // Serialize for IPC
975  _status = msg.serialize((NATIVE_INT_TYPE)CMD_HLTH_PING_ENABLE);
976  FW_ASSERT (
977  _status == Fw::FW_SERIALIZE_OK,
978  static_cast<AssertArg>(_status)
979  );
980 
981  // Fake port number to make message dequeue work
982  NATIVE_INT_TYPE port = 0;
983  _status = msg.serialize(port);
984  FW_ASSERT (
985  _status == Fw::FW_SERIALIZE_OK,
986  static_cast<AssertArg>(_status)
987  );
988 
989  _status = msg.serialize(opCode);
990  FW_ASSERT (
991  _status == Fw::FW_SERIALIZE_OK,
992  static_cast<AssertArg>(_status)
993  );
994 
995  _status = msg.serialize(cmdSeq);
996  FW_ASSERT (
997  _status == Fw::FW_SERIALIZE_OK,
998  static_cast<AssertArg>(_status)
999  );
1000 
1001  _status = msg.serialize(args);
1002  FW_ASSERT (
1003  _status == Fw::FW_SERIALIZE_OK,
1004  static_cast<AssertArg>(_status)
1005  );
1006 
1007  // send message
1008  Os::Queue::QueueBlocking _block =
1010  Os::Queue::QueueStatus qStatus =
1011  this->m_queue.send(msg, 0,_block);
1012  FW_ASSERT(
1013  qStatus == Os::Queue::QUEUE_OK,
1014  static_cast<AssertArg>(qStatus)
1015  );
1016 
1017  }
1018 
1021  FwOpcodeType opCode,
1022  U32 cmdSeq
1023  )
1024  {
1025  // Defaults to no-op; can be overridden
1026  }
1027 
1030  FwOpcodeType opCode,
1031  U32 cmdSeq,
1032  Fw::CmdArgBuffer &args
1033  )
1034  {
1035 
1036  // Call pre-message hook
1037  this->HLTH_CHNG_PING_preMsgHook(opCode,cmdSeq);
1038 
1039  // Defer deserializing arguments to the message dispatcher
1040  // to avoid deserializing and reserializing just for IPC
1041  ComponentIpcSerializableBuffer msg;
1043 
1044  // Serialize for IPC
1045  _status = msg.serialize((NATIVE_INT_TYPE)CMD_HLTH_CHNG_PING);
1046  FW_ASSERT (
1047  _status == Fw::FW_SERIALIZE_OK,
1048  static_cast<AssertArg>(_status)
1049  );
1050 
1051  // Fake port number to make message dequeue work
1052  NATIVE_INT_TYPE port = 0;
1053  _status = msg.serialize(port);
1054  FW_ASSERT (
1055  _status == Fw::FW_SERIALIZE_OK,
1056  static_cast<AssertArg>(_status)
1057  );
1058 
1059  _status = msg.serialize(opCode);
1060  FW_ASSERT (
1061  _status == Fw::FW_SERIALIZE_OK,
1062  static_cast<AssertArg>(_status)
1063  );
1064 
1065  _status = msg.serialize(cmdSeq);
1066  FW_ASSERT (
1067  _status == Fw::FW_SERIALIZE_OK,
1068  static_cast<AssertArg>(_status)
1069  );
1070 
1071  _status = msg.serialize(args);
1072  FW_ASSERT (
1073  _status == Fw::FW_SERIALIZE_OK,
1074  static_cast<AssertArg>(_status)
1075  );
1076 
1077  // send message
1078  Os::Queue::QueueBlocking _block =
1080  Os::Queue::QueueStatus qStatus =
1081  this->m_queue.send(msg, 0,_block);
1082  FW_ASSERT(
1083  qStatus == Os::Queue::QUEUE_OK,
1084  static_cast<AssertArg>(qStatus)
1085  );
1086 
1087  }
1088 
1091  FwOpcodeType opCode,
1092  U32 cmdSeq
1093  )
1094  {
1095  // Defaults to no-op; can be overridden
1096  }
1097 
1098  // ----------------------------------------------------------------------
1099  // Telemetry write functions
1100  // ----------------------------------------------------------------------
1101 
1102  void HealthComponentBase ::
1103  tlmWrite_PingLateWarnings(U32 arg)
1104  {
1105 
1106  if (this->m_Tlm_OutputPort[0].isConnected()) {
1107  Fw::Time _tlmTime;
1108  if (this->m_Time_OutputPort[0].isConnected()) {
1109  this->m_Time_OutputPort[0].invoke( _tlmTime);
1110  }
1111  Fw::TlmBuffer _tlmBuff;
1112  Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
1113  FW_ASSERT(
1114  _stat == Fw::FW_SERIALIZE_OK,
1115  static_cast<AssertArg>(_stat)
1116  );
1117 
1118  FwChanIdType _id;
1119 
1120  _id = this->getIdBase() + CHANNELID_PINGLATEWARNINGS;
1121 
1122  this->m_Tlm_OutputPort[0].invoke(
1123  _id,
1124  _tlmTime,
1125  _tlmBuff
1126  );
1127  }
1128 
1129  }
1130 
1131  // ----------------------------------------------------------------------
1132  // Time
1133  // ----------------------------------------------------------------------
1134 
1135  Fw::Time HealthComponentBase ::
1136  getTime(void)
1137  {
1138  if (this->m_Time_OutputPort[0].isConnected()) {
1139  Fw::Time _time;
1140  this->m_Time_OutputPort[0].invoke(_time);
1141  return _time;
1142  } else {
1143  return Fw::Time(TB_NONE,0,0);
1144  }
1145  }
1146 
1147  // ----------------------------------------------------------------------
1148  // Event handling functions
1149  // ----------------------------------------------------------------------
1150 
1151  void HealthComponentBase ::
1152  log_WARNING_HI_HLTH_PING_WARN(
1153  Fw::LogStringArg& entry
1154  )
1155  {
1156 
1157 
1158  // Get the time
1159  Fw::Time _logTime;
1160  if (this->m_Time_OutputPort[0].isConnected()) {
1161  this->m_Time_OutputPort[0].invoke( _logTime);
1162  }
1163 
1164  FwEventIdType _id = static_cast<FwEventIdType>(0);
1165 
1166  _id = this->getIdBase() + EVENTID_HLTH_PING_WARN;
1167 
1168  // Emit the event on the log port
1169  if (this->m_Log_OutputPort[0].isConnected()) {
1170 
1171  Fw::LogBuffer _logBuff;
1173 
1174 #if FW_AMPCS_COMPATIBLE
1175  // Serialize the number of arguments
1176  _status = _logBuff.serialize(static_cast<U8>(1));
1177  FW_ASSERT(
1178  _status == Fw::FW_SERIALIZE_OK,
1179  static_cast<AssertArg>(_status)
1180  );
1181 #endif
1182 
1183  entry.setMaxSerialize(40);
1184  _status = _logBuff.serialize(entry);
1185  FW_ASSERT(
1186  _status == Fw::FW_SERIALIZE_OK,
1187  static_cast<AssertArg>(_status)
1188  );
1189 
1190 
1191  this->m_Log_OutputPort[0].invoke(
1192  _id,
1193  _logTime,Fw::LOG_WARNING_HI,
1194  _logBuff
1195  );
1196 
1197  }
1198 
1199  // Emit the event on the text log port
1200 #if FW_ENABLE_TEXT_LOGGING
1201  if (this->m_LogText_OutputPort[0].isConnected()) {
1202 
1203 #if FW_OBJECT_NAMES == 1
1204  const char* _formatString =
1205  "(%s) %s: Ping entry %s late warning";
1206 #else
1207  const char* _formatString =
1208  "%s: Ping entry %s late warning";
1209 #endif
1210 
1211  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1212 
1213  (void) snprintf(
1214  _textBuffer,
1216  _formatString,
1217 #if FW_OBJECT_NAMES == 1
1218  this->m_objName,
1219 #endif
1220  "HLTH_PING_WARN "
1221  , entry.toChar()
1222  );
1223 
1224  // Null terminate
1225  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1226  Fw::TextLogString _logString = _textBuffer;
1227  this->m_LogText_OutputPort[0].invoke(
1228  _id,
1229  _logTime,Fw::TEXT_LOG_WARNING_HI,
1230  _logString
1231  );
1232 
1233  }
1234 #endif
1235 
1236  }
1237 
1238 
1241  Fw::LogStringArg& entry
1242  )
1243  {
1244 
1245 
1246  // Get the time
1247  Fw::Time _logTime;
1248  if (this->m_Time_OutputPort[0].isConnected()) {
1249  this->m_Time_OutputPort[0].invoke( _logTime);
1250  }
1251 
1252  FwEventIdType _id = static_cast<FwEventIdType>(0);
1253 
1254  _id = this->getIdBase() + EVENTID_HLTH_PING_LATE;
1255 
1256  // Emit the event on the log port
1257  if (this->m_Log_OutputPort[0].isConnected()) {
1258 
1259  Fw::LogBuffer _logBuff;
1261 
1262 #if FW_AMPCS_COMPATIBLE
1263  // Serialize the number of arguments
1264  _status = _logBuff.serialize(static_cast<U8>(1+1));
1265  FW_ASSERT(
1266  _status == Fw::FW_SERIALIZE_OK,
1267  static_cast<AssertArg>(_status)
1268  );
1269  // For FATAL, add stack size of 4 and a dummy entry. No support for stacks yet.
1270  _status = _logBuff.serialize(static_cast<U8>(4));
1271  FW_ASSERT(
1272  _status == Fw::FW_SERIALIZE_OK,
1273  static_cast<AssertArg>(_status)
1274  );
1275  _status = _logBuff.serialize(static_cast<U32>(0));
1276  FW_ASSERT(
1277  _status == Fw::FW_SERIALIZE_OK,
1278  static_cast<AssertArg>(_status)
1279  );
1280 #endif
1281 
1282  entry.setMaxSerialize(40);
1283  _status = _logBuff.serialize(entry);
1284  FW_ASSERT(
1285  _status == Fw::FW_SERIALIZE_OK,
1286  static_cast<AssertArg>(_status)
1287  );
1288 
1289 
1290  this->m_Log_OutputPort[0].invoke(
1291  _id,
1292  _logTime,Fw::LOG_FATAL,
1293  _logBuff
1294  );
1295 
1296  }
1297 
1298  // Emit the event on the text log port
1299 #if FW_ENABLE_TEXT_LOGGING
1300  if (this->m_LogText_OutputPort[0].isConnected()) {
1301 
1302 #if FW_OBJECT_NAMES == 1
1303  const char* _formatString =
1304  "(%s) %s: Ping entry %s did not respond";
1305 #else
1306  const char* _formatString =
1307  "%s: Ping entry %s did not respond";
1308 #endif
1309 
1310  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1311 
1312  (void) snprintf(
1313  _textBuffer,
1315  _formatString,
1316 #if FW_OBJECT_NAMES == 1
1317  this->m_objName,
1318 #endif
1319  "HLTH_PING_LATE "
1320  , entry.toChar()
1321  );
1322 
1323  // Null terminate
1324  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1325  Fw::TextLogString _logString = _textBuffer;
1326  this->m_LogText_OutputPort[0].invoke(
1327  _id,
1328  _logTime,Fw::TEXT_LOG_FATAL,
1329  _logString
1330  );
1331 
1332  }
1333 #endif
1334 
1335  }
1336 
1337 
1340  Fw::LogStringArg& entry, U32 badKey
1341  )
1342  {
1343 
1344 
1345  // Get the time
1346  Fw::Time _logTime;
1347  if (this->m_Time_OutputPort[0].isConnected()) {
1348  this->m_Time_OutputPort[0].invoke( _logTime);
1349  }
1350 
1351  FwEventIdType _id = static_cast<FwEventIdType>(0);
1352 
1353  _id = this->getIdBase() + EVENTID_HLTH_PING_WRONG_KEY;
1354 
1355  // Emit the event on the log port
1356  if (this->m_Log_OutputPort[0].isConnected()) {
1357 
1358  Fw::LogBuffer _logBuff;
1360 
1361 #if FW_AMPCS_COMPATIBLE
1362  // Serialize the number of arguments
1363  _status = _logBuff.serialize(static_cast<U8>(2+1));
1364  FW_ASSERT(
1365  _status == Fw::FW_SERIALIZE_OK,
1366  static_cast<AssertArg>(_status)
1367  );
1368  // For FATAL, add stack size of 4 and a dummy entry. No support for stacks yet.
1369  _status = _logBuff.serialize(static_cast<U8>(4));
1370  FW_ASSERT(
1371  _status == Fw::FW_SERIALIZE_OK,
1372  static_cast<AssertArg>(_status)
1373  );
1374  _status = _logBuff.serialize(static_cast<U32>(0));
1375  FW_ASSERT(
1376  _status == Fw::FW_SERIALIZE_OK,
1377  static_cast<AssertArg>(_status)
1378  );
1379 #endif
1380 
1381  entry.setMaxSerialize(40);
1382  _status = _logBuff.serialize(entry);
1383  FW_ASSERT(
1384  _status == Fw::FW_SERIALIZE_OK,
1385  static_cast<AssertArg>(_status)
1386  );
1387 
1388 #if FW_AMPCS_COMPATIBLE
1389  // Serialize the argument size
1390  _status = _logBuff.serialize(
1391  static_cast<U8>(sizeof(badKey))
1392  );
1393  FW_ASSERT(
1394  _status == Fw::FW_SERIALIZE_OK,
1395  static_cast<AssertArg>(_status)
1396  );
1397 #endif
1398 
1399  _status = _logBuff.serialize(badKey);
1400  FW_ASSERT(
1401  _status == Fw::FW_SERIALIZE_OK,
1402  static_cast<AssertArg>(_status)
1403  );
1404 
1405 
1406  this->m_Log_OutputPort[0].invoke(
1407  _id,
1408  _logTime,Fw::LOG_FATAL,
1409  _logBuff
1410  );
1411 
1412  }
1413 
1414  // Emit the event on the text log port
1415 #if FW_ENABLE_TEXT_LOGGING
1416  if (this->m_LogText_OutputPort[0].isConnected()) {
1417 
1418 #if FW_OBJECT_NAMES == 1
1419  const char* _formatString =
1420  "(%s) %s: Ping entry %s responded with wrong key 0x%08X";
1421 #else
1422  const char* _formatString =
1423  "%s: Ping entry %s responded with wrong key 0x%08X";
1424 #endif
1425 
1426  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1427 
1428  (void) snprintf(
1429  _textBuffer,
1431  _formatString,
1432 #if FW_OBJECT_NAMES == 1
1433  this->m_objName,
1434 #endif
1435  "HLTH_PING_WRONG_KEY "
1436  , entry.toChar()
1437  , badKey
1438  );
1439 
1440  // Null terminate
1441  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1442  Fw::TextLogString _logString = _textBuffer;
1443  this->m_LogText_OutputPort[0].invoke(
1444  _id,
1445  _logTime,Fw::TEXT_LOG_FATAL,
1446  _logString
1447  );
1448 
1449  }
1450 #endif
1451 
1452  }
1453 
1454 
1457  HealthIsEnabled enabled
1458  )
1459  {
1460 
1461 
1462  // Get the time
1463  Fw::Time _logTime;
1464  if (this->m_Time_OutputPort[0].isConnected()) {
1465  this->m_Time_OutputPort[0].invoke( _logTime);
1466  }
1467 
1468  FwEventIdType _id = static_cast<FwEventIdType>(0);
1469 
1470  _id = this->getIdBase() + EVENTID_HLTH_CHECK_ENABLE;
1471 
1472  // Emit the event on the log port
1473  if (this->m_Log_OutputPort[0].isConnected()) {
1474 
1475  Fw::LogBuffer _logBuff;
1477 
1478 #if FW_AMPCS_COMPATIBLE
1479  // Serialize the number of arguments
1480  _status = _logBuff.serialize(static_cast<U8>(1));
1481  FW_ASSERT(
1482  _status == Fw::FW_SERIALIZE_OK,
1483  static_cast<AssertArg>(_status)
1484  );
1485 #endif
1486 
1487 #if FW_AMPCS_COMPATIBLE
1488  // Serialize the argument size
1489  _status = _logBuff.serialize(static_cast<U8>(sizeof(FwEnumStoreType)));
1490  FW_ASSERT(
1491  _status == Fw::FW_SERIALIZE_OK,
1492  static_cast<AssertArg>(_status)
1493  );
1494 #endif
1495 
1496  _status = _logBuff.serialize(
1497  static_cast<FwEnumStoreType>(enabled)
1498  );
1499  FW_ASSERT(
1500  _status == Fw::FW_SERIALIZE_OK,
1501  static_cast<AssertArg>(_status)
1502  );
1503 
1504 
1505  this->m_Log_OutputPort[0].invoke(
1506  _id,
1507  _logTime,Fw::LOG_ACTIVITY_HI,
1508  _logBuff
1509  );
1510 
1511  }
1512 
1513  // Emit the event on the text log port
1514 #if FW_ENABLE_TEXT_LOGGING
1515  if (this->m_LogText_OutputPort[0].isConnected()) {
1516 
1517 #if FW_OBJECT_NAMES == 1
1518  const char* _formatString =
1519  "(%s) %s: Health checking set to %d";
1520 #else
1521  const char* _formatString =
1522  "%s: Health checking set to %d";
1523 #endif
1524 
1525  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1526 
1527  (void) snprintf(
1528  _textBuffer,
1530  _formatString,
1531 #if FW_OBJECT_NAMES == 1
1532  this->m_objName,
1533 #endif
1534  "HLTH_CHECK_ENABLE "
1535  , enabled
1536  );
1537 
1538  // Null terminate
1539  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1540  Fw::TextLogString _logString = _textBuffer;
1541  this->m_LogText_OutputPort[0].invoke(
1542  _id,
1543  _logTime,Fw::TEXT_LOG_ACTIVITY_HI,
1544  _logString
1545  );
1546 
1547  }
1548 #endif
1549 
1550  }
1551 
1552 
1555  HealthPingIsEnabled enabled, Fw::LogStringArg& entry
1556  )
1557  {
1558 
1559 
1560  // Get the time
1561  Fw::Time _logTime;
1562  if (this->m_Time_OutputPort[0].isConnected()) {
1563  this->m_Time_OutputPort[0].invoke( _logTime);
1564  }
1565 
1566  FwEventIdType _id = static_cast<FwEventIdType>(0);
1567 
1568  _id = this->getIdBase() + EVENTID_HLTH_CHECK_PING;
1569 
1570  // Emit the event on the log port
1571  if (this->m_Log_OutputPort[0].isConnected()) {
1572 
1573  Fw::LogBuffer _logBuff;
1575 
1576 #if FW_AMPCS_COMPATIBLE
1577  // Serialize the number of arguments
1578  _status = _logBuff.serialize(static_cast<U8>(2));
1579  FW_ASSERT(
1580  _status == Fw::FW_SERIALIZE_OK,
1581  static_cast<AssertArg>(_status)
1582  );
1583 #endif
1584 
1585 #if FW_AMPCS_COMPATIBLE
1586  // Serialize the argument size
1587  _status = _logBuff.serialize(static_cast<U8>(sizeof(FwEnumStoreType)));
1588  FW_ASSERT(
1589  _status == Fw::FW_SERIALIZE_OK,
1590  static_cast<AssertArg>(_status)
1591  );
1592 #endif
1593 
1594  _status = _logBuff.serialize(
1595  static_cast<FwEnumStoreType>(enabled)
1596  );
1597  FW_ASSERT(
1598  _status == Fw::FW_SERIALIZE_OK,
1599  static_cast<AssertArg>(_status)
1600  );
1601 
1602  entry.setMaxSerialize(40);
1603  _status = _logBuff.serialize(entry);
1604  FW_ASSERT(
1605  _status == Fw::FW_SERIALIZE_OK,
1606  static_cast<AssertArg>(_status)
1607  );
1608 
1609 
1610  this->m_Log_OutputPort[0].invoke(
1611  _id,
1612  _logTime,Fw::LOG_ACTIVITY_HI,
1613  _logBuff
1614  );
1615 
1616  }
1617 
1618  // Emit the event on the text log port
1619 #if FW_ENABLE_TEXT_LOGGING
1620  if (this->m_LogText_OutputPort[0].isConnected()) {
1621 
1622 #if FW_OBJECT_NAMES == 1
1623  const char* _formatString =
1624  "(%s) %s: Health checking set to %d for %s";
1625 #else
1626  const char* _formatString =
1627  "%s: Health checking set to %d for %s";
1628 #endif
1629 
1630  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1631 
1632  (void) snprintf(
1633  _textBuffer,
1635  _formatString,
1636 #if FW_OBJECT_NAMES == 1
1637  this->m_objName,
1638 #endif
1639  "HLTH_CHECK_PING "
1640  , enabled
1641  , entry.toChar()
1642  );
1643 
1644  // Null terminate
1645  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1646  Fw::TextLogString _logString = _textBuffer;
1647  this->m_LogText_OutputPort[0].invoke(
1648  _id,
1649  _logTime,Fw::TEXT_LOG_ACTIVITY_HI,
1650  _logString
1651  );
1652 
1653  }
1654 #endif
1655 
1656  }
1657 
1658 
1661  Fw::LogStringArg& entry
1662  )
1663  {
1664 
1665 
1666  // Get the time
1667  Fw::Time _logTime;
1668  if (this->m_Time_OutputPort[0].isConnected()) {
1669  this->m_Time_OutputPort[0].invoke( _logTime);
1670  }
1671 
1672  FwEventIdType _id = static_cast<FwEventIdType>(0);
1673 
1675 
1676  // Emit the event on the log port
1677  if (this->m_Log_OutputPort[0].isConnected()) {
1678 
1679  Fw::LogBuffer _logBuff;
1681 
1682 #if FW_AMPCS_COMPATIBLE
1683  // Serialize the number of arguments
1684  _status = _logBuff.serialize(static_cast<U8>(1));
1685  FW_ASSERT(
1686  _status == Fw::FW_SERIALIZE_OK,
1687  static_cast<AssertArg>(_status)
1688  );
1689 #endif
1690 
1691  entry.setMaxSerialize(40);
1692  _status = _logBuff.serialize(entry);
1693  FW_ASSERT(
1694  _status == Fw::FW_SERIALIZE_OK,
1695  static_cast<AssertArg>(_status)
1696  );
1697 
1698 
1699  this->m_Log_OutputPort[0].invoke(
1700  _id,
1701  _logTime,Fw::LOG_WARNING_LO,
1702  _logBuff
1703  );
1704 
1705  }
1706 
1707  // Emit the event on the text log port
1708 #if FW_ENABLE_TEXT_LOGGING
1709  if (this->m_LogText_OutputPort[0].isConnected()) {
1710 
1711 #if FW_OBJECT_NAMES == 1
1712  const char* _formatString =
1713  "(%s) %s: Couldn't find entry %s";
1714 #else
1715  const char* _formatString =
1716  "%s: Couldn't find entry %s";
1717 #endif
1718 
1719  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1720 
1721  (void) snprintf(
1722  _textBuffer,
1724  _formatString,
1725 #if FW_OBJECT_NAMES == 1
1726  this->m_objName,
1727 #endif
1728  "HLTH_CHECK_LOOKUP_ERROR "
1729  , entry.toChar()
1730  );
1731 
1732  // Null terminate
1733  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1734  Fw::TextLogString _logString = _textBuffer;
1735  this->m_LogText_OutputPort[0].invoke(
1736  _id,
1737  _logTime,Fw::TEXT_LOG_WARNING_LO,
1738  _logString
1739  );
1740 
1741  }
1742 #endif
1743 
1744  }
1745 
1746 
1749  Fw::LogStringArg& entry, U32 warn, U32 fatal
1750  )
1751  {
1752 
1753 
1754  // Get the time
1755  Fw::Time _logTime;
1756  if (this->m_Time_OutputPort[0].isConnected()) {
1757  this->m_Time_OutputPort[0].invoke( _logTime);
1758  }
1759 
1760  FwEventIdType _id = static_cast<FwEventIdType>(0);
1761 
1762  _id = this->getIdBase() + EVENTID_HLTH_PING_UPDATED;
1763 
1764  // Emit the event on the log port
1765  if (this->m_Log_OutputPort[0].isConnected()) {
1766 
1767  Fw::LogBuffer _logBuff;
1769 
1770 #if FW_AMPCS_COMPATIBLE
1771  // Serialize the number of arguments
1772  _status = _logBuff.serialize(static_cast<U8>(3));
1773  FW_ASSERT(
1774  _status == Fw::FW_SERIALIZE_OK,
1775  static_cast<AssertArg>(_status)
1776  );
1777 #endif
1778 
1779  entry.setMaxSerialize(40);
1780  _status = _logBuff.serialize(entry);
1781  FW_ASSERT(
1782  _status == Fw::FW_SERIALIZE_OK,
1783  static_cast<AssertArg>(_status)
1784  );
1785 
1786 #if FW_AMPCS_COMPATIBLE
1787  // Serialize the argument size
1788  _status = _logBuff.serialize(
1789  static_cast<U8>(sizeof(warn))
1790  );
1791  FW_ASSERT(
1792  _status == Fw::FW_SERIALIZE_OK,
1793  static_cast<AssertArg>(_status)
1794  );
1795 #endif
1796 
1797  _status = _logBuff.serialize(warn);
1798  FW_ASSERT(
1799  _status == Fw::FW_SERIALIZE_OK,
1800  static_cast<AssertArg>(_status)
1801  );
1802 
1803 #if FW_AMPCS_COMPATIBLE
1804  // Serialize the argument size
1805  _status = _logBuff.serialize(
1806  static_cast<U8>(sizeof(fatal))
1807  );
1808  FW_ASSERT(
1809  _status == Fw::FW_SERIALIZE_OK,
1810  static_cast<AssertArg>(_status)
1811  );
1812 #endif
1813 
1814  _status = _logBuff.serialize(fatal);
1815  FW_ASSERT(
1816  _status == Fw::FW_SERIALIZE_OK,
1817  static_cast<AssertArg>(_status)
1818  );
1819 
1820 
1821  this->m_Log_OutputPort[0].invoke(
1822  _id,
1823  _logTime,Fw::LOG_ACTIVITY_HI,
1824  _logBuff
1825  );
1826 
1827  }
1828 
1829  // Emit the event on the text log port
1830 #if FW_ENABLE_TEXT_LOGGING
1831  if (this->m_LogText_OutputPort[0].isConnected()) {
1832 
1833 #if FW_OBJECT_NAMES == 1
1834  const char* _formatString =
1835  "(%s) %s: Health ping for %s changed to WARN %d FATAL %d";
1836 #else
1837  const char* _formatString =
1838  "%s: Health ping for %s changed to WARN %d FATAL %d";
1839 #endif
1840 
1841  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1842 
1843  (void) snprintf(
1844  _textBuffer,
1846  _formatString,
1847 #if FW_OBJECT_NAMES == 1
1848  this->m_objName,
1849 #endif
1850  "HLTH_PING_UPDATED "
1851  , entry.toChar()
1852  , warn
1853  , fatal
1854  );
1855 
1856  // Null terminate
1857  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1858  Fw::TextLogString _logString = _textBuffer;
1859  this->m_LogText_OutputPort[0].invoke(
1860  _id,
1861  _logTime,Fw::TEXT_LOG_ACTIVITY_HI,
1862  _logString
1863  );
1864 
1865  }
1866 #endif
1867 
1868  }
1869 
1870 
1873  Fw::LogStringArg& entry, U32 warn, U32 fatal
1874  )
1875  {
1876 
1877 
1878  // Get the time
1879  Fw::Time _logTime;
1880  if (this->m_Time_OutputPort[0].isConnected()) {
1881  this->m_Time_OutputPort[0].invoke( _logTime);
1882  }
1883 
1884  FwEventIdType _id = static_cast<FwEventIdType>(0);
1885 
1887 
1888  // Emit the event on the log port
1889  if (this->m_Log_OutputPort[0].isConnected()) {
1890 
1891  Fw::LogBuffer _logBuff;
1893 
1894 #if FW_AMPCS_COMPATIBLE
1895  // Serialize the number of arguments
1896  _status = _logBuff.serialize(static_cast<U8>(3));
1897  FW_ASSERT(
1898  _status == Fw::FW_SERIALIZE_OK,
1899  static_cast<AssertArg>(_status)
1900  );
1901 #endif
1902 
1903  entry.setMaxSerialize(40);
1904  _status = _logBuff.serialize(entry);
1905  FW_ASSERT(
1906  _status == Fw::FW_SERIALIZE_OK,
1907  static_cast<AssertArg>(_status)
1908  );
1909 
1910 #if FW_AMPCS_COMPATIBLE
1911  // Serialize the argument size
1912  _status = _logBuff.serialize(
1913  static_cast<U8>(sizeof(warn))
1914  );
1915  FW_ASSERT(
1916  _status == Fw::FW_SERIALIZE_OK,
1917  static_cast<AssertArg>(_status)
1918  );
1919 #endif
1920 
1921  _status = _logBuff.serialize(warn);
1922  FW_ASSERT(
1923  _status == Fw::FW_SERIALIZE_OK,
1924  static_cast<AssertArg>(_status)
1925  );
1926 
1927 #if FW_AMPCS_COMPATIBLE
1928  // Serialize the argument size
1929  _status = _logBuff.serialize(
1930  static_cast<U8>(sizeof(fatal))
1931  );
1932  FW_ASSERT(
1933  _status == Fw::FW_SERIALIZE_OK,
1934  static_cast<AssertArg>(_status)
1935  );
1936 #endif
1937 
1938  _status = _logBuff.serialize(fatal);
1939  FW_ASSERT(
1940  _status == Fw::FW_SERIALIZE_OK,
1941  static_cast<AssertArg>(_status)
1942  );
1943 
1944 
1945  this->m_Log_OutputPort[0].invoke(
1946  _id,
1947  _logTime,Fw::LOG_WARNING_HI,
1948  _logBuff
1949  );
1950 
1951  }
1952 
1953  // Emit the event on the text log port
1954 #if FW_ENABLE_TEXT_LOGGING
1955  if (this->m_LogText_OutputPort[0].isConnected()) {
1956 
1957 #if FW_OBJECT_NAMES == 1
1958  const char* _formatString =
1959  "(%s) %s: Health ping for %s invalid values: WARN %d FATAL %d";
1960 #else
1961  const char* _formatString =
1962  "%s: Health ping for %s invalid values: WARN %d FATAL %d";
1963 #endif
1964 
1965  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1966 
1967  (void) snprintf(
1968  _textBuffer,
1970  _formatString,
1971 #if FW_OBJECT_NAMES == 1
1972  this->m_objName,
1973 #endif
1974  "HLTH_PING_INVALID_VALUES "
1975  , entry.toChar()
1976  , warn
1977  , fatal
1978  );
1979 
1980  // Null terminate
1981  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1982  Fw::TextLogString _logString = _textBuffer;
1983  this->m_LogText_OutputPort[0].invoke(
1984  _id,
1985  _logTime,Fw::TEXT_LOG_WARNING_HI,
1986  _logString
1987  );
1988 
1989  }
1990 #endif
1991 
1992  }
1993 
1994 
1995  // ----------------------------------------------------------------------
1996  // Calls for invocations received on typed input ports
1997  // ----------------------------------------------------------------------
1998 
1999  void HealthComponentBase ::
2000  m_p_PingReturn_in(
2001  Fw::PassiveComponentBase* callComp,
2002  NATIVE_INT_TYPE portNum,
2003  U32 key
2004  )
2005  {
2006  FW_ASSERT(callComp);
2007  HealthComponentBase* compPtr =
2008  (HealthComponentBase*) callComp;
2009  compPtr->PingReturn_handlerBase(portNum, key);
2010  }
2011 
2013  m_p_Run_in(
2014  Fw::PassiveComponentBase* callComp,
2015  NATIVE_INT_TYPE portNum,
2016  NATIVE_UINT_TYPE context
2017  )
2018  {
2019  FW_ASSERT(callComp);
2020  HealthComponentBase* compPtr =
2021  (HealthComponentBase*) callComp;
2022  compPtr->Run_handlerBase(portNum, context);
2023  }
2024 
2025  // ----------------------------------------------------------------------
2026  // Port handler base-class functions for typed input ports
2027  // ----------------------------------------------------------------------
2028 
2029  void HealthComponentBase ::
2030  PingReturn_handlerBase(
2031  NATIVE_INT_TYPE portNum,
2032  U32 key
2033  )
2034  {
2035 
2036  // Make sure port number is valid
2037  FW_ASSERT(portNum < this->getNum_PingReturn_InputPorts(),static_cast<AssertArg>(portNum));
2038 
2039  // Call pre-message hook
2040  PingReturn_preMsgHook(
2041  portNum,
2042  key
2043  );
2044 
2045  ComponentIpcSerializableBuffer msg;
2047 
2048  _status = msg.serialize(
2049  static_cast<NATIVE_INT_TYPE>(PINGRETURN_PING)
2050  );
2051  FW_ASSERT (
2052  _status == Fw::FW_SERIALIZE_OK,
2053  static_cast<AssertArg>(_status)
2054  );
2055 
2056  _status = msg.serialize(portNum);
2057  FW_ASSERT (
2058  _status == Fw::FW_SERIALIZE_OK,
2059  static_cast<AssertArg>(_status)
2060  );
2061 
2062  // Serialize argument key
2063  _status = msg.serialize(key);
2064  FW_ASSERT(
2065  _status == Fw::FW_SERIALIZE_OK,
2066  static_cast<AssertArg>(_status)
2067  );
2068 
2069 
2070  // send message
2071  Os::Queue::QueueBlocking _block =
2073  Os::Queue::QueueStatus qStatus =
2074  this->m_queue.send(msg, 0,_block);
2075  FW_ASSERT(
2076  qStatus == Os::Queue::QUEUE_OK,
2077  static_cast<AssertArg>(qStatus)
2078  );
2079 
2080  }
2081 
2084  NATIVE_INT_TYPE portNum,
2085  NATIVE_UINT_TYPE context
2086  )
2087  {
2088 
2089  // Make sure port number is valid
2090  FW_ASSERT(portNum < this->getNum_Run_InputPorts(),static_cast<AssertArg>(portNum));
2091 
2092  // Down call to pure virtual handler method implemented in Impl class
2093  this->Run_handler(portNum, context);
2094 
2095  }
2096 
2097  // ----------------------------------------------------------------------
2098  // Pre-message hooks for async input ports
2099  // ----------------------------------------------------------------------
2100 
2101  void HealthComponentBase ::
2102  PingReturn_preMsgHook(
2103  NATIVE_INT_TYPE portNum,
2104  U32 key
2105  )
2106  {
2107  // Default: no-op
2108  }
2109 
2110  // ----------------------------------------------------------------------
2111  // Message dispatch method for active and queued components. Called
2112  // by active component thread or implementation code for queued components
2113  // ----------------------------------------------------------------------
2114 
2116  doDispatch(void)
2117  {
2118  ComponentIpcSerializableBuffer msg;
2119  NATIVE_INT_TYPE priority;
2120 
2121  Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_NONBLOCKING);
2122  if (Os::Queue::QUEUE_NO_MORE_MSGS == msgStatus) {
2124  } else {
2125  FW_ASSERT(
2126  msgStatus == Os::Queue::QUEUE_OK,
2127  static_cast<AssertArg>(msgStatus)
2128  );
2129  }
2130 
2131  // Reset to beginning of buffer
2132  msg.resetDeser();
2133 
2134  NATIVE_INT_TYPE desMsg;
2135  Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
2136  FW_ASSERT(
2137  deserStatus == Fw::FW_SERIALIZE_OK,
2138  static_cast<AssertArg>(deserStatus)
2139  );
2140 
2141  MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
2142 
2143  if (msgType == HEALTH_COMPONENT_EXIT) {
2144  return MSG_DISPATCH_EXIT;
2145  }
2146 
2148  deserStatus = msg.deserialize(portNum);
2149  FW_ASSERT(
2150  deserStatus == Fw::FW_SERIALIZE_OK,
2151  static_cast<AssertArg>(deserStatus)
2152  );
2153 
2154  switch (msgType) {
2155 
2156  // Handle async input port PingReturn
2157  case PINGRETURN_PING: {
2158 
2159  // Deserialize argument key
2160  U32 key;
2161  deserStatus = msg.deserialize(key);
2162  FW_ASSERT(
2163  deserStatus == Fw::FW_SERIALIZE_OK,
2164  static_cast<AssertArg>(deserStatus)
2165  );
2166 
2167  // Call handler function
2168  this->PingReturn_handler(
2169  portNum,
2170  key
2171  );
2172 
2173  break;
2174 
2175  }
2176 
2177  // Handle command HLTH_ENABLE
2178  case CMD_HLTH_ENABLE: {
2179  // Deserialize opcode
2180  FwOpcodeType opCode;
2181  deserStatus = msg.deserialize(opCode);
2182  FW_ASSERT (
2183  deserStatus == Fw::FW_SERIALIZE_OK,
2184  static_cast<AssertArg>(deserStatus)
2185  );
2186 
2187  // Deserialize command sequence
2188  U32 cmdSeq;
2189  deserStatus = msg.deserialize(cmdSeq);
2190  FW_ASSERT (
2191  deserStatus == Fw::FW_SERIALIZE_OK,
2192  static_cast<AssertArg>(deserStatus)
2193  );
2194 
2195  // Deserialize command argument buffer
2197  deserStatus = msg.deserialize(args);
2198  FW_ASSERT (
2199  deserStatus == Fw::FW_SERIALIZE_OK,
2200  static_cast<AssertArg>(deserStatus)
2201  );
2202 
2203  // Reset buffer
2204  args.resetDeser();
2205 
2206  // Deserialize argument enable
2208  FwEnumStoreType enableInt;
2209  deserStatus = args.deserialize(enableInt);
2210  enable = (HealthEnabled)enableInt;
2211  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2212  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2213  this->cmdResponse_out(
2214  opCode,
2215  cmdSeq,
2217  );
2218  }
2219  // Don't crash the task if bad arguments were passed from the ground
2220  break;
2221  }
2222 
2223  // Make sure there was no data left over.
2224  // That means the argument buffer size was incorrect.
2225 #if FW_CMD_CHECK_RESIDUAL
2226  if (args.getBuffLeft() != 0) {
2227  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2228  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2229  }
2230  // Don't crash the task if bad arguments were passed from the ground
2231  break;
2232  }
2233 #endif
2234  // Call handler function
2235  this->HLTH_ENABLE_cmdHandler(
2236  opCode,
2237  cmdSeq,
2238  enable
2239  );
2240 
2241  break;
2242 
2243  }
2244 
2245  // Handle command HLTH_PING_ENABLE
2246  case CMD_HLTH_PING_ENABLE: {
2247  // Deserialize opcode
2248  FwOpcodeType opCode;
2249  deserStatus = msg.deserialize(opCode);
2250  FW_ASSERT (
2251  deserStatus == Fw::FW_SERIALIZE_OK,
2252  static_cast<AssertArg>(deserStatus)
2253  );
2254 
2255  // Deserialize command sequence
2256  U32 cmdSeq;
2257  deserStatus = msg.deserialize(cmdSeq);
2258  FW_ASSERT (
2259  deserStatus == Fw::FW_SERIALIZE_OK,
2260  static_cast<AssertArg>(deserStatus)
2261  );
2262 
2263  // Deserialize command argument buffer
2265  deserStatus = msg.deserialize(args);
2266  FW_ASSERT (
2267  deserStatus == Fw::FW_SERIALIZE_OK,
2268  static_cast<AssertArg>(deserStatus)
2269  );
2270 
2271  // Reset buffer
2272  args.resetDeser();
2273 
2274  // Deserialize argument entry
2275  Fw::CmdStringArg entry;
2276  deserStatus = args.deserialize(entry);
2277  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2278  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2279  this->cmdResponse_out(
2280  opCode,
2281  cmdSeq,
2283  );
2284  }
2285  // Don't crash the task if bad arguments were passed from the ground
2286  break;
2287  }
2288 
2289  // Deserialize argument enable
2291  FwEnumStoreType enableInt;
2292  deserStatus = args.deserialize(enableInt);
2293  enable = (PingEnabled)enableInt;
2294  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2295  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2296  this->cmdResponse_out(
2297  opCode,
2298  cmdSeq,
2300  );
2301  }
2302  // Don't crash the task if bad arguments were passed from the ground
2303  break;
2304  }
2305 
2306  // Make sure there was no data left over.
2307  // That means the argument buffer size was incorrect.
2308 #if FW_CMD_CHECK_RESIDUAL
2309  if (args.getBuffLeft() != 0) {
2310  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2311  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2312  }
2313  // Don't crash the task if bad arguments were passed from the ground
2314  break;
2315  }
2316 #endif
2317  // Call handler function
2319  opCode,
2320  cmdSeq,
2321  entry, enable
2322  );
2323 
2324  break;
2325 
2326  }
2327 
2328  // Handle command HLTH_CHNG_PING
2329  case CMD_HLTH_CHNG_PING: {
2330  // Deserialize opcode
2331  FwOpcodeType opCode;
2332  deserStatus = msg.deserialize(opCode);
2333  FW_ASSERT (
2334  deserStatus == Fw::FW_SERIALIZE_OK,
2335  static_cast<AssertArg>(deserStatus)
2336  );
2337 
2338  // Deserialize command sequence
2339  U32 cmdSeq;
2340  deserStatus = msg.deserialize(cmdSeq);
2341  FW_ASSERT (
2342  deserStatus == Fw::FW_SERIALIZE_OK,
2343  static_cast<AssertArg>(deserStatus)
2344  );
2345 
2346  // Deserialize command argument buffer
2348  deserStatus = msg.deserialize(args);
2349  FW_ASSERT (
2350  deserStatus == Fw::FW_SERIALIZE_OK,
2351  static_cast<AssertArg>(deserStatus)
2352  );
2353 
2354  // Reset buffer
2355  args.resetDeser();
2356 
2357  // Deserialize argument entry
2358  Fw::CmdStringArg entry;
2359  deserStatus = args.deserialize(entry);
2360  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2361  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2362  this->cmdResponse_out(
2363  opCode,
2364  cmdSeq,
2366  );
2367  }
2368  // Don't crash the task if bad arguments were passed from the ground
2369  break;
2370  }
2371 
2372  // Deserialize argument warningValue
2373  U32 warningValue;
2374  deserStatus = args.deserialize(warningValue);
2375  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2376  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2377  this->cmdResponse_out(
2378  opCode,
2379  cmdSeq,
2381  );
2382  }
2383  // Don't crash the task if bad arguments were passed from the ground
2384  break;
2385  }
2386 
2387  // Deserialize argument fatalValue
2388  U32 fatalValue;
2389  deserStatus = args.deserialize(fatalValue);
2390  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2391  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2392  this->cmdResponse_out(
2393  opCode,
2394  cmdSeq,
2396  );
2397  }
2398  // Don't crash the task if bad arguments were passed from the ground
2399  break;
2400  }
2401 
2402  // Make sure there was no data left over.
2403  // That means the argument buffer size was incorrect.
2404 #if FW_CMD_CHECK_RESIDUAL
2405  if (args.getBuffLeft() != 0) {
2406  if (this->m_CmdStatus_OutputPort[0].isConnected()) {
2407  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2408  }
2409  // Don't crash the task if bad arguments were passed from the ground
2410  break;
2411  }
2412 #endif
2413  // Call handler function
2415  opCode,
2416  cmdSeq,
2417  entry, warningValue, fatalValue
2418  );
2419 
2420  break;
2421 
2422  }
2423 
2424  default:
2425  return MSG_DISPATCH_ERROR;
2426 
2427  }
2428 
2429  return MSG_DISPATCH_OK;
2430 
2431  }
2432 
2433 } // end namespace Svc
Fw::TEXT_LOG_ACTIVITY_HI
@ TEXT_LOG_ACTIVITY_HI
Definition: LogTextPortAc.hpp:31
Fw::OutputCmdRegPort::init
void init(void)
Definition: CmdRegPortAc.cpp:89
Svc::HealthComponentBase::WdogStroke_out
void WdogStroke_out(NATIVE_INT_TYPE portNum, U32 code)
Definition: HealthComponentAc.cpp:625
Fw::TextLogString
Definition: TextLogString.hpp:11
Fw::InputTimePort
Definition: TimePortAc.hpp:28
Svc::HealthComponentBase::HLTH_CHNG_PING_preMsgHook
virtual void HLTH_CHNG_PING_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Definition: HealthComponentAc.cpp:1090
Svc::InputPingPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: PingPortAc.hpp:30
Fw::InputTlmPort
Definition: TlmPortAc.hpp:29
Svc::HealthComponentBase::getNum_CmdDisp_InputPorts
NATIVE_INT_TYPE getNum_CmdDisp_InputPorts(void)
Definition: HealthComponentAc.cpp:671
Fw::PassiveComponentBase::getIdBase
U32 getIdBase(void) const
Definition: PassiveComponentBase.cpp:40
Svc::HealthComponentBase
Auto-generated base for Health component.
Definition: HealthComponentAc.hpp:49
Svc::HealthComponentBase::regCommands
void regCommands(void)
Register commands with the Command Dispatcher.
Definition: HealthComponentAc.cpp:288
Fw::Time
Definition: Time.hpp:10
Svc::HealthComponentBase::HLTH_PING_ENABLE_cmdHandler
virtual void HLTH_PING_ENABLE_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &entry, PingEnabled enable)=0
Handler for command HLTH_PING_ENABLE.
Svc::HealthComponentBase::m_Log_OutputPort
Fw::OutputLogPort m_Log_OutputPort[NUM_LOG_OUTPUT_PORTS]
Definition: HealthComponentAc.hpp:862
Fw::QueuedComponentBase::doDispatch
virtual MsgDispatchStatus doDispatch(void)=0
method to dispatch a single message in the queue.
Svc::HealthComponentBase::OPCODE_HLTH_CHNG_PING
PROTECTED OPCODE_HLTH_CHNG_PING
Definition: HealthComponentAc.hpp:553
Fw::OutputCmdResponsePort::addCallPort
void addCallPort(InputCmdResponsePort *callPort)
Definition: CmdResponsePortAc.cpp:105
Fw::SerializeBufferBase
Definition: Serializable.hpp:43
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Fw::TlmBuffer
Definition: TlmBuffer.hpp:21
Svc::InputSchedPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: SchedPortAc.cpp:42
Fw::CommandResponse
CommandResponse
Definition: CmdResponsePortAc.hpp:24
FwChanIdType
#define FwChanIdType
Type representation for a channel id.
Definition: FpConfig.hpp:66
Fw::SerializeBufferBase::resetDeser
void resetDeser(void)
reset deserialization to beginning
Definition: Serializable.cpp:575
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
Svc::HealthComponentBase::isConnected_CmdStatus_OutputPort
bool isConnected_CmdStatus_OutputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:753
Svc::HealthComponentBase::HealthEnabled
PROTECTED HealthEnabled_MAX HealthEnabled
Definition: HealthComponentAc.hpp:536
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
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
cmdPort
BYTE cmdPort[Fw::InputCmdPort::SERIALIZED_SIZE]
Definition: HealthComponentAc.cpp:42
Fw::LOG_FATAL
@ LOG_FATAL
Definition: LogPortAc.hpp:27
Fw::LogStringArg
Definition: LogString.hpp:11
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.hpp:76
Svc::HealthComponentBase::getNum_Time_OutputPorts
NATIVE_INT_TYPE getNum_Time_OutputPorts(void)
Definition: HealthComponentAc.cpp:703
Svc::HealthComponentBase::log_WARNING_HI_HLTH_PING_INVALID_VALUES
void log_WARNING_HI_HLTH_PING_INVALID_VALUES(Fw::LogStringArg &entry, U32 warn, U32 fatal)
Definition: HealthComponentAc.cpp:1872
FwEnumStoreType
#define FwEnumStoreType
Type representation for an enumeration value.
Definition: FpConfig.hpp:84
Fw::InputCmdRegPort
Definition: CmdRegPortAc.hpp:27
Os::Queue::QueueStatus
QueueStatus
Definition: Queue.hpp:27
Svc::HealthComponentBase::OPCODE_HLTH_PING_ENABLE
PROTECTED OPCODE_HLTH_PING_ENABLE
Definition: HealthComponentAc.hpp:552
Svc::HealthComponentBase::getNum_Tlm_OutputPorts
NATIVE_INT_TYPE getNum_Tlm_OutputPorts(void)
Definition: HealthComponentAc.cpp:695
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
Svc::HealthComponentBase::set_Log_OutputPort
void set_Log_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputLogPort *port)
Definition: HealthComponentAc.cpp:172
Svc::InputWatchDogPort
Definition: WatchDogPortAc.hpp:27
Svc::HealthComponentBase::log_ACTIVITY_HI_HLTH_PING_UPDATED
void log_ACTIVITY_HI_HLTH_PING_UPDATED(Fw::LogStringArg &entry, U32 warn, U32 fatal)
Definition: HealthComponentAc.cpp:1748
Svc::HealthComponentBase::getNum_CmdReg_OutputPorts
NATIVE_INT_TYPE getNum_CmdReg_OutputPorts(void)
Definition: HealthComponentAc.cpp:687
Fw::InputCmdPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: CmdPortAc.cpp:42
Svc::HealthComponentBase::EVENTID_HLTH_CHECK_PING
PROTECTED EVENTID_HLTH_CHECK_PING
Definition: HealthComponentAc.hpp:676
Svc::HealthComponentBase::log_WARNING_LO_HLTH_CHECK_LOOKUP_ERROR
void log_WARNING_LO_HLTH_CHECK_LOOKUP_ERROR(Fw::LogStringArg &entry)
Definition: HealthComponentAc.cpp:1660
Svc::HealthComponentBase::set_WdogStroke_OutputPort
void set_WdogStroke_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputWatchDogPort *port)
Definition: HealthComponentAc.cpp:122
Svc::InputSchedPort::init
void init(void)
initialization function
Definition: SchedPortAc.cpp:38
Svc::HealthComponentBase::isConnected_CmdReg_OutputPort
bool isConnected_CmdReg_OutputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:763
Svc::HealthComponentBase::get_Run_InputPort
Svc::InputSchedPort * get_Run_InputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:94
Svc::HealthComponentBase::m_CmdStatus_OutputPort
Fw::OutputCmdResponsePort m_CmdStatus_OutputPort[NUM_CMDSTATUS_OUTPUT_PORTS]
Definition: HealthComponentAc.hpp:846
Fw::CmdStringArg
Definition: CmdString.hpp:11
Fw::TEXT_LOG_WARNING_HI
@ TEXT_LOG_WARNING_HI
Definition: LogTextPortAc.hpp:28
Svc::HealthComponentBase::portNum
PRIVATE NATIVE_INT_TYPE portNum
Definition: HealthComponentAc.hpp:880
Assert.hpp
Svc::HealthComponentBase::EVENTID_HLTH_CHECK_ENABLE
PROTECTED EVENTID_HLTH_CHECK_ENABLE
Definition: HealthComponentAc.hpp:675
Fw::FW_SERIALIZE_OK
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Os::Queue::send
QueueStatus send(const Fw::SerializeBufferBase &buffer, NATIVE_INT_TYPE priority, QueueBlocking block)
send a message
Definition: QueueCommon.cpp:13
Fw::SerializeBufferBase::getBuffLeft
NATIVE_UINT_TYPE getBuffLeft() const
returns how much deserialization buffer is left
Definition: Serializable.cpp:619
Fw::InputCmdPort::init
void init(void)
initialization function
Definition: CmdPortAc.cpp:38
Fw::LogStringArg::toChar
const char * toChar(void) const
Definition: LogString.cpp:38
Svc::HealthComponentBase::EVENTID_HLTH_PING_INVALID_VALUES
PROTECTED EVENTID_HLTH_PING_INVALID_VALUES
Definition: HealthComponentAc.hpp:679
Svc::HealthComponentBase::cmdSeq
PROTECTED U32 cmdSeq
Definition: HealthComponentAc.hpp:566
HealthComponentAc.hpp
EightyCharString.hpp
Svc::HealthComponentBase::enable
PROTECTED U32 HealthEnabled enable
Definition: HealthComponentAc.hpp:568
Fw::PassiveComponentBase
Definition: PassiveComponentBase.hpp:10
Fw::OutputLogPort::init
void init(void)
Definition: LogPortAc.cpp:107
Fw::OutputTimePort::init
void init(void)
Definition: TimePortAc.cpp:89
Fw::ObjBase::init
void init(void)
Object initializer.
Definition: ObjBase.cpp:26
Svc::HealthComponentBase::set_CmdReg_OutputPort
void set_CmdReg_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputCmdRegPort *port)
Definition: HealthComponentAc.cpp:142
Os::Queue::QueueBlocking
QueueBlocking
Definition: Queue.hpp:40
Fw::QueuedComponentBase::MSG_DISPATCH_OK
@ MSG_DISPATCH_OK
Dispatch was normal.
Definition: QueuedComponentBase.hpp:26
Svc::HealthComponentBase::isConnected_Tlm_OutputPort
bool isConnected_Tlm_OutputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:773
Svc::HealthComponentBase::log_ACTIVITY_HI_HLTH_CHECK_PING
void log_ACTIVITY_HI_HLTH_CHECK_PING(HealthPingIsEnabled enabled, Fw::LogStringArg &entry)
Definition: HealthComponentAc.cpp:1554
BYTE
U8 BYTE
byte type
Definition: BasicTypes.hpp:77
Svc::HealthComponentBase::EVENTID_HLTH_PING_UPDATED
PROTECTED EVENTID_HLTH_PING_UPDATED
Definition: HealthComponentAc.hpp:678
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::HealthComponentBase::HLTH_CHNG_PING_cmdHandlerBase
void HLTH_CHNG_PING_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: HealthComponentAc.cpp:1029
Svc::InputPingPort
Definition: PingPortAc.hpp:27
Fw::OutputTlmPort::addCallPort
void addCallPort(InputTlmPort *callPort)
Definition: TlmPortAc.cpp:105
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::InputSchedPort
Definition: SchedPortAc.hpp:27
Svc::HealthComponentBase::log_FATAL_HLTH_PING_WRONG_KEY
void log_FATAL_HLTH_PING_WRONG_KEY(Fw::LogStringArg &entry, U32 badKey)
Definition: HealthComponentAc.cpp:1339
Svc::HealthComponentBase::key
PROTECTED U32 key
Definition: HealthComponentAc.hpp:273
Svc::OutputWatchDogPort::addCallPort
void addCallPort(InputWatchDogPort *callPort)
Definition: WatchDogPortAc.cpp:93
FwOpcodeType
#define FwOpcodeType
Type representation for a command opcode.
Definition: FpConfig.hpp:62
Svc::HealthComponentBase::log_FATAL_HLTH_PING_LATE
void log_FATAL_HLTH_PING_LATE(Fw::LogStringArg &entry)
Definition: HealthComponentAc.cpp:1240
Fw::QueuedComponentBase::MsgDispatchStatus
MsgDispatchStatus
Definition: QueuedComponentBase.hpp:25
Svc::HealthComponentBase::m_p_Run_in
static void m_p_Run_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context)
Definition: HealthComponentAc.cpp:2013
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::OutputTlmPort::invoke
void invoke(FwChanIdType id, Fw::Time &timeTag, TlmBuffer &val)
Definition: TlmPortAc.cpp:115
Svc::HealthComponentBase::Run_handlerBase
void Run_handlerBase(NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context)
Definition: HealthComponentAc.cpp:2083
Fw::CmdArgBuffer
Definition: CmdArgBuffer.hpp:22
Svc::HealthComponentBase::getNum_WdogStroke_OutputPorts
NATIVE_INT_TYPE getNum_WdogStroke_OutputPorts(void)
Definition: HealthComponentAc.cpp:663
Fw::OutputCmdResponsePort::init
void init(void)
Definition: CmdResponsePortAc.cpp:101
Svc::HealthComponentBase::HLTH_PING_ENABLE_preMsgHook
virtual void HLTH_PING_ENABLE_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Definition: HealthComponentAc.cpp:1020
Svc::HealthComponentBase::isConnected_Log_OutputPort
bool isConnected_Log_OutputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:793
Fw::COMMAND_INVALID_OPCODE
@ COMMAND_INVALID_OPCODE
Definition: CmdResponsePortAc.hpp:26
Os::Queue::QUEUE_NO_MORE_MSGS
@ QUEUE_NO_MORE_MSGS
If non-blocking, all the messages have been drained.
Definition: Queue.hpp:29
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:9
Svc::OutputWatchDogPort::init
void init(void)
Definition: WatchDogPortAc.cpp:89
Fw::OutputCmdResponsePort::invoke
void invoke(FwOpcodeType opCode, U32 cmdSeq, CommandResponse response)
Definition: CmdResponsePortAc.cpp:115
Fw::TEXT_LOG_FATAL
@ TEXT_LOG_FATAL
Definition: LogTextPortAc.hpp:27
Fw::QueuedComponentBase::MSG_DISPATCH_ERROR
@ MSG_DISPATCH_ERROR
Errors dispatching messages.
Definition: QueuedComponentBase.hpp:28
Svc::HealthComponentBase::get_PingReturn_InputPort
Svc::InputPingPort * get_PingReturn_InputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:87
Fw::LOG_ACTIVITY_HI
@ LOG_ACTIVITY_HI
Definition: LogPortAc.hpp:31
Svc::HealthComponentBase::~HealthComponentBase
virtual ~HealthComponentBase(void)
Definition: HealthComponentAc.cpp:606
Svc::HealthComponentBase::set_PingSend_OutputPort
void set_PingSend_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputPingPort *port)
Definition: HealthComponentAc.cpp:112
Os::Queue::QUEUE_OK
@ QUEUE_OK
message sent/received okay
Definition: Queue.hpp:28
Svc::HealthComponentBase::m_Tlm_OutputPort
Fw::OutputTlmPort m_Tlm_OutputPort[NUM_TLM_OUTPUT_PORTS]
Definition: HealthComponentAc.hpp:854
Svc::HealthComponentBase::EVENTID_HLTH_PING_WRONG_KEY
PROTECTED EVENTID_HLTH_PING_WRONG_KEY
Definition: HealthComponentAc.hpp:674
Svc::HealthComponentBase::m_Run_InputPort
Svc::InputSchedPort m_Run_InputPort[NUM_RUN_INPUT_PORTS]
Definition: HealthComponentAc.hpp:824
Svc::HealthComponentBase::PingEnabled
PingEnabled
Definition: HealthComponentAc.hpp:538
Fw::LogStringArg::setMaxSerialize
void setMaxSerialize(NATIVE_UINT_TYPE size)
Definition: LogString.cpp:106
Fw::SerializeBufferBase::deserialize
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
Definition: Serializable.cpp:292
Fw::OutputTlmPort::init
void init(void)
Definition: TlmPortAc.cpp:101
Fw::InputCmdPort
Definition: CmdPortAc.hpp:28
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::HealthComponentBase::set_CmdStatus_OutputPort
void set_CmdStatus_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputCmdResponsePort *port)
Definition: HealthComponentAc.cpp:132
Svc::HealthComponentBase::args
PROTECTED U32 Fw::CmdArgBuffer & args
Definition: HealthComponentAc.hpp:633
port1
BYTE port1[Svc::InputPingPort::SERIALIZED_SIZE]
Definition: HealthComponentAc.cpp:41
Svc::HealthComponentBase::getNum_CmdStatus_OutputPorts
NATIVE_INT_TYPE getNum_CmdStatus_OutputPorts(void)
Definition: HealthComponentAc.cpp:679
Svc::OutputWatchDogPort::invoke
void invoke(U32 code)
Definition: WatchDogPortAc.cpp:103
Svc
Definition: ActiveLoggerComponentAc.cpp:22
Svc::HealthComponentBase::response
PROTECTED U32 Fw::CommandResponse response
Definition: HealthComponentAc.hpp:663
Fw::QueuedComponentBase::MSG_DISPATCH_EMPTY
@ MSG_DISPATCH_EMPTY
No more messages in the queue.
Definition: QueuedComponentBase.hpp:27
Svc::HealthComponentBase::log_ACTIVITY_HI_HLTH_CHECK_ENABLE
void log_ACTIVITY_HI_HLTH_CHECK_ENABLE(HealthIsEnabled enabled)
Definition: HealthComponentAc.cpp:1456
Os::Queue::QUEUE_NONBLOCKING
@ QUEUE_NONBLOCKING
Queue receive always returns even if there is no message.
Definition: Queue.hpp:42
Svc::HealthComponentBase::set_Time_OutputPort
void set_Time_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTimePort *port)
Definition: HealthComponentAc.cpp:162
Fw::InputCmdResponsePort
Definition: CmdResponsePortAc.hpp:37
Svc::HealthComponentBase::isConnected_Time_OutputPort
bool isConnected_Time_OutputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:783
Svc::HealthComponentBase::HLTH_CHNG_PING_cmdHandler
virtual void HLTH_CHNG_PING_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdStringArg &entry, U32 warningValue, U32 fatalValue)=0
Handler for command HLTH_CHNG_PING.
Svc::HealthComponentBase::Run_handler
virtual void Run_handler(NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context)=0
Handler for input port Run.
Svc::HealthComponentBase::EVENTID_HLTH_CHECK_LOOKUP_ERROR
PROTECTED EVENTID_HLTH_CHECK_LOOKUP_ERROR
Definition: HealthComponentAc.hpp:677
Fw::InputLogPort
Definition: LogPortAc.hpp:40
Svc::HealthComponentBase::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: HealthComponentAc.cpp:819
Svc::HealthComponentBase::HLTH_PING_ENABLE_cmdHandlerBase
void HLTH_PING_ENABLE_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: HealthComponentAc.cpp:959
Svc::HealthComponentBase::m_Time_OutputPort
Fw::OutputTimePort m_Time_OutputPort[NUM_TIME_OUTPUT_PORTS]
Definition: HealthComponentAc.hpp:858
Svc::HealthComponentBase::m_WdogStroke_OutputPort
Svc::OutputWatchDogPort m_WdogStroke_OutputPort[NUM_WDOGSTROKE_OUTPUT_PORTS]
Definition: HealthComponentAc.hpp:842
Svc::HealthComponentBase::get_CmdDisp_InputPort
Fw::InputCmdPort * get_CmdDisp_InputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:101
Svc::HealthComponentBase::m_CmdReg_OutputPort
Fw::OutputCmdRegPort m_CmdReg_OutputPort[NUM_CMDREG_OUTPUT_PORTS]
Definition: HealthComponentAc.hpp:850
Svc::HealthComponentBase::HealthPingIsEnabled
HealthPingIsEnabled
Definition: HealthComponentAc.hpp:694
Svc::HealthComponentBase::getNum_Log_OutputPorts
NATIVE_INT_TYPE getNum_Log_OutputPorts(void)
Definition: HealthComponentAc.cpp:711
Svc::HealthComponentBase::EVENTID_HLTH_PING_LATE
PROTECTED EVENTID_HLTH_PING_LATE
Definition: HealthComponentAc.hpp:673
Svc::HealthComponentBase::m_CmdDisp_InputPort
Fw::InputCmdPort m_CmdDisp_InputPort[NUM_CMDDISP_INPUT_PORTS]
Definition: HealthComponentAc.hpp:828
FwEventIdType
#define FwEventIdType
Type representation for a event id.
Definition: FpConfig.hpp:70
NATIVE_INT_TYPE
int NATIVE_INT_TYPE
native integer type declaration
Definition: BasicTypes.hpp:29
AssertArg
#define AssertArg
Definition: FpConfig.hpp:51
Fw::QueuedComponentBase::createQueue
Os::Queue::QueueStatus createQueue(NATIVE_INT_TYPE depth, NATIVE_INT_TYPE msgSize)
Definition: QueuedComponentBase.cpp:29
Svc::HealthComponentBase::isConnected_WdogStroke_OutputPort
bool isConnected_WdogStroke_OutputPort(NATIVE_INT_TYPE portNum)
Definition: HealthComponentAc.cpp:743
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::HealthComponentBase::getNum_Run_InputPorts
NATIVE_INT_TYPE getNum_Run_InputPorts(void)
Definition: HealthComponentAc.cpp:655
FW_LOG_TEXT_BUFFER_SIZE
#define FW_LOG_TEXT_BUFFER_SIZE
Max size of string for text log message.
Definition: FpConfig.hpp:291
Fw::InputLogTextPort
Definition: LogTextPortAc.hpp:40
Svc::HealthComponentBase::set_Tlm_OutputPort
void set_Tlm_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTlmPort *port)
Definition: HealthComponentAc.cpp:152