F´ Flight Software - C/C++ Documentation  NASA-v1.5.0
A framework for building embedded system applications to NASA flight quality standards.
BufferLoggerComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title BufferLoggerComponentAc.cpp
3 // \author Auto-generated
4 // \brief cpp file for BufferLogger 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  BUFFERLOGGER_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
32  BUFFERSENDIN_BUFFERSEND,
33  COMIN_COM,
34  PINGIN_PING,
35  SCHEDIN_SCHED,
36  CMD_BL_OPENFILE,
37  CMD_BL_CLOSEFILE,
38  CMD_BL_SETLOGGING,
39  CMD_BL_FLUSHFILE
40  } MsgTypeEnum;
41 
42  // Get the max size by doing a union of the input port serialization sizes.
43 
44  typedef union {
50  } BuffUnion;
51 
52  // Define a message buffer class large enough to handle all the
53  // asynchronous inputs to the component
54 
55  class ComponentIpcSerializableBuffer :
57  {
58 
59  public:
60 
61  enum {
62  // Max. message size = size of data + message id + port
63  SERIALIZATION_SIZE =
64  sizeof(BuffUnion) +
65  sizeof(NATIVE_INT_TYPE) +
66  sizeof(NATIVE_INT_TYPE)
67  };
68 
69  NATIVE_UINT_TYPE getBuffCapacity(void) const {
70  return sizeof(m_buff);
71  }
72 
73  U8* getBuffAddr(void) {
74  return m_buff;
75  }
76 
77  const U8* getBuffAddr(void) const {
78  return m_buff;
79  }
80 
81  private:
82  // Should be the max of all the input ports serialized sizes...
83  U8 m_buff[SERIALIZATION_SIZE];
84 
85  };
86 
87  }
88 
89  // ----------------------------------------------------------------------
90  // Getters for numbers of input ports
91  // ----------------------------------------------------------------------
92 
95  {
96  FW_ASSERT(portNum < this->getNum_bufferSendIn_InputPorts(),static_cast<AssertArg>(portNum));
97  return &this->m_bufferSendIn_InputPort[portNum];
98  }
99 
102  {
103  FW_ASSERT(portNum < this->getNum_cmdIn_InputPorts(),static_cast<AssertArg>(portNum));
104  return &this->m_cmdIn_InputPort[portNum];
105  }
106 
109  {
110  FW_ASSERT(portNum < this->getNum_comIn_InputPorts(),static_cast<AssertArg>(portNum));
111  return &this->m_comIn_InputPort[portNum];
112  }
113 
116  {
117  FW_ASSERT(portNum < this->getNum_pingIn_InputPorts(),static_cast<AssertArg>(portNum));
118  return &this->m_pingIn_InputPort[portNum];
119  }
120 
123  {
124  FW_ASSERT(portNum < this->getNum_schedIn_InputPorts(),static_cast<AssertArg>(portNum));
125  return &this->m_schedIn_InputPort[portNum];
126  }
127 
128  // ----------------------------------------------------------------------
129  // Typed connectors for output ports
130  // ----------------------------------------------------------------------
131 
134  NATIVE_INT_TYPE portNum,
136  )
137  {
138  FW_ASSERT(portNum < this->getNum_bufferSendOut_OutputPorts(),static_cast<AssertArg>(portNum));
139  this->m_bufferSendOut_OutputPort[portNum].addCallPort(port);
140  }
141 
144  NATIVE_INT_TYPE portNum,
145  Fw::InputCmdRegPort* port
146  )
147  {
148  FW_ASSERT(portNum < this->getNum_cmdRegOut_OutputPorts(),static_cast<AssertArg>(portNum));
150  }
151 
154  NATIVE_INT_TYPE portNum,
156  )
157  {
158  FW_ASSERT(portNum < this->getNum_cmdResponseOut_OutputPorts(),static_cast<AssertArg>(portNum));
160  }
161 
164  NATIVE_INT_TYPE portNum,
165  Fw::InputLogPort* port
166  )
167  {
168  FW_ASSERT(portNum < this->getNum_eventOut_OutputPorts(),static_cast<AssertArg>(portNum));
170  }
171 
172 #if FW_ENABLE_TEXT_LOGGING == 1
173  void BufferLoggerComponentBase ::
174  set_eventOutText_OutputPort(
175  NATIVE_INT_TYPE portNum,
177  )
178  {
179  FW_ASSERT(portNum < this->getNum_eventOutText_OutputPorts(),static_cast<AssertArg>(portNum));
180  this->m_eventOutText_OutputPort[portNum].addCallPort(port);
181  }
182 #endif
183 
186  NATIVE_INT_TYPE portNum,
187  Svc::InputPingPort* port
188  )
189  {
190  FW_ASSERT(portNum < this->getNum_pingOut_OutputPorts(),static_cast<AssertArg>(portNum));
192  }
193 
196  NATIVE_INT_TYPE portNum,
197  Fw::InputTimePort* port
198  )
199  {
200  FW_ASSERT(portNum < this->getNum_timeCaller_OutputPorts(),static_cast<AssertArg>(portNum));
202  }
203 
206  NATIVE_INT_TYPE portNum,
207  Fw::InputTlmPort* port
208  )
209  {
210  FW_ASSERT(portNum < this->getNum_tlmOut_OutputPorts(),static_cast<AssertArg>(portNum));
212  }
213 
214  // ----------------------------------------------------------------------
215  // Serialization connectors for output ports
216  // ----------------------------------------------------------------------
217 
218 #if FW_PORT_SERIALIZATION
219 
222  NATIVE_INT_TYPE portNum,
223  Fw::InputSerializePort *port
224  )
225  {
226  FW_ASSERT(portNum < this->getNum_bufferSendOut_OutputPorts(),static_cast<AssertArg>(portNum));
227  return this->m_bufferSendOut_OutputPort[portNum].registerSerialPort(port);
228  }
229 
232  NATIVE_INT_TYPE portNum,
233  Fw::InputSerializePort *port
234  )
235  {
236  FW_ASSERT(portNum < this->getNum_cmdRegOut_OutputPorts(),static_cast<AssertArg>(portNum));
237  return this->m_cmdRegOut_OutputPort[portNum].registerSerialPort(port);
238  }
239 
242  NATIVE_INT_TYPE portNum,
243  Fw::InputSerializePort *port
244  )
245  {
246  FW_ASSERT(portNum < this->getNum_cmdResponseOut_OutputPorts(),static_cast<AssertArg>(portNum));
247  return this->m_cmdResponseOut_OutputPort[portNum].registerSerialPort(port);
248  }
249 
252  NATIVE_INT_TYPE portNum,
253  Fw::InputSerializePort *port
254  )
255  {
256  FW_ASSERT(portNum < this->getNum_eventOut_OutputPorts(),static_cast<AssertArg>(portNum));
257  return this->m_eventOut_OutputPort[portNum].registerSerialPort(port);
258  }
259 
260 #if FW_ENABLE_TEXT_LOGGING == 1
261  void BufferLoggerComponentBase ::
262  set_eventOutText_OutputPort(
263  NATIVE_INT_TYPE portNum,
264  Fw::InputSerializePort *port
265  )
266  {
267  FW_ASSERT(portNum < this->getNum_eventOutText_OutputPorts(),static_cast<AssertArg>(portNum));
268  return this->m_eventOutText_OutputPort[portNum].registerSerialPort(port);
269  }
270 #endif
271 
274  NATIVE_INT_TYPE portNum,
275  Fw::InputSerializePort *port
276  )
277  {
278  FW_ASSERT(portNum < this->getNum_pingOut_OutputPorts(),static_cast<AssertArg>(portNum));
279  return this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
280  }
281 
284  NATIVE_INT_TYPE portNum,
285  Fw::InputSerializePort *port
286  )
287  {
288  FW_ASSERT(portNum < this->getNum_timeCaller_OutputPorts(),static_cast<AssertArg>(portNum));
289  return this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
290  }
291 
294  NATIVE_INT_TYPE portNum,
295  Fw::InputSerializePort *port
296  )
297  {
298  FW_ASSERT(portNum < this->getNum_tlmOut_OutputPorts(),static_cast<AssertArg>(portNum));
299  return this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
300  }
301 
302 #endif
303 
304  // ----------------------------------------------------------------------
305  // Command registration
306  // ----------------------------------------------------------------------
307 
309  regCommands(void)
310  {
311  FW_ASSERT(this->m_cmdRegOut_OutputPort[0].isConnected());
313  this->getIdBase() + OPCODE_BL_OPENFILE
314  );
317  );
320  );
323  );
324  }
325 
326  // ----------------------------------------------------------------------
327  // Component construction, initialization, and destruction
328  // ----------------------------------------------------------------------
329 
331 #if FW_OBJECT_NAMES == 1
332  BufferLoggerComponentBase(const char* compName) :
333  Fw::ActiveComponentBase(compName)
334 #else
336  Fw::ActiveComponentBase()
337 #endif
338  {
339 
340 
341 
342  }
343 
345  init(
346  NATIVE_INT_TYPE queueDepth,
347  NATIVE_INT_TYPE instance
348  )
349  {
350 
351  // Initialize base class
353 
354  // Connect input port bufferSendIn
355  for (
356  NATIVE_INT_TYPE port = 0;
357  port < this->getNum_bufferSendIn_InputPorts();
358  port++
359  ) {
360 
361  this->m_bufferSendIn_InputPort[port].init();
362  this->m_bufferSendIn_InputPort[port].addCallComp(
363  this,
364  m_p_bufferSendIn_in
365  );
366  this->m_bufferSendIn_InputPort[port].setPortNum(port);
367 
368 #if FW_OBJECT_NAMES == 1
369  char portName[120];
370  (void) snprintf(
371  portName,
372  sizeof(portName),
373  "%s_bufferSendIn_InputPort[%d]",
374  this->m_objName,
375  port
376  );
377  this->m_bufferSendIn_InputPort[port].setObjName(portName);
378 #endif
379 
380  }
381 
382  // Connect input port cmdIn
383  for (
384  NATIVE_INT_TYPE port = 0;
385  port < this->getNum_cmdIn_InputPorts();
386  port++
387  ) {
388 
389  this->m_cmdIn_InputPort[port].init();
390  this->m_cmdIn_InputPort[port].addCallComp(
391  this,
393  );
394  this->m_cmdIn_InputPort[port].setPortNum(port);
395 
396 #if FW_OBJECT_NAMES == 1
397  char portName[120];
398  (void) snprintf(
399  portName,
400  sizeof(portName),
401  "%s_cmdIn_InputPort[%d]",
402  this->m_objName,
403  port
404  );
405  this->m_cmdIn_InputPort[port].setObjName(portName);
406 #endif
407 
408  }
409 
410  // Connect input port comIn
411  for (
412  NATIVE_INT_TYPE port = 0;
413  port < this->getNum_comIn_InputPorts();
414  port++
415  ) {
416 
417  this->m_comIn_InputPort[port].init();
418  this->m_comIn_InputPort[port].addCallComp(
419  this,
421  );
422  this->m_comIn_InputPort[port].setPortNum(port);
423 
424 #if FW_OBJECT_NAMES == 1
425  char portName[120];
426  (void) snprintf(
427  portName,
428  sizeof(portName),
429  "%s_comIn_InputPort[%d]",
430  this->m_objName,
431  port
432  );
433  this->m_comIn_InputPort[port].setObjName(portName);
434 #endif
435 
436  }
437 
438  // Connect input port pingIn
439  for (
440  NATIVE_INT_TYPE port = 0;
441  port < this->getNum_pingIn_InputPorts();
442  port++
443  ) {
444 
445  this->m_pingIn_InputPort[port].init();
446  this->m_pingIn_InputPort[port].addCallComp(
447  this,
449  );
450  this->m_pingIn_InputPort[port].setPortNum(port);
451 
452 #if FW_OBJECT_NAMES == 1
453  char portName[120];
454  (void) snprintf(
455  portName,
456  sizeof(portName),
457  "%s_pingIn_InputPort[%d]",
458  this->m_objName,
459  port
460  );
461  this->m_pingIn_InputPort[port].setObjName(portName);
462 #endif
463 
464  }
465 
466  // Connect input port schedIn
467  for (
468  NATIVE_INT_TYPE port = 0;
469  port < this->getNum_schedIn_InputPorts();
470  port++
471  ) {
472 
473  this->m_schedIn_InputPort[port].init();
474  this->m_schedIn_InputPort[port].addCallComp(
475  this,
477  );
478  this->m_schedIn_InputPort[port].setPortNum(port);
479 
480 #if FW_OBJECT_NAMES == 1
481  char portName[120];
482  (void) snprintf(
483  portName,
484  sizeof(portName),
485  "%s_schedIn_InputPort[%d]",
486  this->m_objName,
487  port
488  );
489  this->m_schedIn_InputPort[port].setObjName(portName);
490 #endif
491 
492  }
493 
494  // Initialize output port bufferSendOut
495  for (
496  NATIVE_INT_TYPE port = 0;
497  port < this->getNum_bufferSendOut_OutputPorts();
498  port++
499  ) {
500  this->m_bufferSendOut_OutputPort[port].init();
501 
502 #if FW_OBJECT_NAMES == 1
503  char portName[120];
504  (void) snprintf(
505  portName,
506  sizeof(portName),
507  "%s_bufferSendOut_OutputPort[%d]",
508  this->m_objName,
509  port
510  );
511  this->m_bufferSendOut_OutputPort[port].setObjName(portName);
512 #endif
513 
514  }
515 
516  // Initialize output port cmdRegOut
517  for (
518  NATIVE_INT_TYPE port = 0;
519  port < this->getNum_cmdRegOut_OutputPorts();
520  port++
521  ) {
522  this->m_cmdRegOut_OutputPort[port].init();
523 
524 #if FW_OBJECT_NAMES == 1
525  char portName[120];
526  (void) snprintf(
527  portName,
528  sizeof(portName),
529  "%s_cmdRegOut_OutputPort[%d]",
530  this->m_objName,
531  port
532  );
533  this->m_cmdRegOut_OutputPort[port].setObjName(portName);
534 #endif
535 
536  }
537 
538  // Initialize output port cmdResponseOut
539  for (
540  NATIVE_INT_TYPE port = 0;
541  port < this->getNum_cmdResponseOut_OutputPorts();
542  port++
543  ) {
544  this->m_cmdResponseOut_OutputPort[port].init();
545 
546 #if FW_OBJECT_NAMES == 1
547  char portName[120];
548  (void) snprintf(
549  portName,
550  sizeof(portName),
551  "%s_cmdResponseOut_OutputPort[%d]",
552  this->m_objName,
553  port
554  );
555  this->m_cmdResponseOut_OutputPort[port].setObjName(portName);
556 #endif
557 
558  }
559 
560  // Initialize output port eventOut
561  for (
562  NATIVE_INT_TYPE port = 0;
563  port < this->getNum_eventOut_OutputPorts();
564  port++
565  ) {
566  this->m_eventOut_OutputPort[port].init();
567 
568 #if FW_OBJECT_NAMES == 1
569  char portName[120];
570  (void) snprintf(
571  portName,
572  sizeof(portName),
573  "%s_eventOut_OutputPort[%d]",
574  this->m_objName,
575  port
576  );
577  this->m_eventOut_OutputPort[port].setObjName(portName);
578 #endif
579 
580  }
581 
582  // Initialize output port eventOutText
583 #if FW_ENABLE_TEXT_LOGGING == 1
584  for (
585  NATIVE_INT_TYPE port = 0;
586  port < this->getNum_eventOutText_OutputPorts();
587  port++
588  ) {
589  this->m_eventOutText_OutputPort[port].init();
590 
591 #if FW_OBJECT_NAMES == 1
592  char portName[120];
593  (void) snprintf(
594  portName,
595  sizeof(portName),
596  "%s_eventOutText_OutputPort[%d]",
597  this->m_objName,
598  port
599  );
600  this->m_eventOutText_OutputPort[port].setObjName(portName);
601 #endif
602 
603  }
604 #endif
605 
606  // Initialize output port pingOut
607  for (
608  NATIVE_INT_TYPE port = 0;
609  port < this->getNum_pingOut_OutputPorts();
610  port++
611  ) {
612  this->m_pingOut_OutputPort[port].init();
613 
614 #if FW_OBJECT_NAMES == 1
615  char portName[120];
616  (void) snprintf(
617  portName,
618  sizeof(portName),
619  "%s_pingOut_OutputPort[%d]",
620  this->m_objName,
621  port
622  );
623  this->m_pingOut_OutputPort[port].setObjName(portName);
624 #endif
625 
626  }
627 
628  // Initialize output port timeCaller
629  for (
630  NATIVE_INT_TYPE port = 0;
631  port < this->getNum_timeCaller_OutputPorts();
632  port++
633  ) {
634  this->m_timeCaller_OutputPort[port].init();
635 
636 #if FW_OBJECT_NAMES == 1
637  char portName[120];
638  (void) snprintf(
639  portName,
640  sizeof(portName),
641  "%s_timeCaller_OutputPort[%d]",
642  this->m_objName,
643  port
644  );
645  this->m_timeCaller_OutputPort[port].setObjName(portName);
646 #endif
647 
648  }
649 
650  // Initialize output port tlmOut
651  for (
652  NATIVE_INT_TYPE port = 0;
653  port < this->getNum_tlmOut_OutputPorts();
654  port++
655  ) {
656  this->m_tlmOut_OutputPort[port].init();
657 
658 #if FW_OBJECT_NAMES == 1
659  char portName[120];
660  (void) snprintf(
661  portName,
662  sizeof(portName),
663  "%s_tlmOut_OutputPort[%d]",
664  this->m_objName,
665  port
666  );
667  this->m_tlmOut_OutputPort[port].setObjName(portName);
668 #endif
669 
670  }
671 
672  Os::Queue::QueueStatus qStat =
673  this->createQueue(
674  queueDepth,
675  ComponentIpcSerializableBuffer::SERIALIZATION_SIZE
676  );
677  FW_ASSERT(
678  Os::Queue::QUEUE_OK == qStat,
679  static_cast<AssertArg>(qStat)
680  );
681 
682  }
683 
686 
687  }
688 
689  // ----------------------------------------------------------------------
690  // Invocation functions for output ports
691  // ----------------------------------------------------------------------
692 
693  void BufferLoggerComponentBase ::
694  bufferSendOut_out(
695  NATIVE_INT_TYPE portNum,
696  Fw::Buffer &fwBuffer
697  )
698  {
699  FW_ASSERT(portNum < this->getNum_bufferSendOut_OutputPorts(),static_cast<AssertArg>(portNum));
700  this->m_bufferSendOut_OutputPort[portNum].invoke(fwBuffer);
701  }
702 
705  NATIVE_INT_TYPE portNum,
706  U32 key
707  )
708  {
709  FW_ASSERT(portNum < this->getNum_pingOut_OutputPorts(),static_cast<AssertArg>(portNum));
710  this->m_pingOut_OutputPort[portNum].invoke(key);
711  }
712 
713  // ----------------------------------------------------------------------
714  // Getters for numbers of ports
715  // ----------------------------------------------------------------------
716 
717  NATIVE_INT_TYPE BufferLoggerComponentBase ::
718  getNum_bufferSendIn_InputPorts(void)
719  {
721  this->m_bufferSendIn_InputPort
722  );
723  }
724 
725  NATIVE_INT_TYPE BufferLoggerComponentBase ::
726  getNum_bufferSendOut_OutputPorts(void)
727  {
729  this->m_bufferSendOut_OutputPort
730  );
731  }
732 
735  {
737  this->m_cmdIn_InputPort
738  );
739  }
740 
743  {
746  );
747  }
748 
751  {
754  );
755  }
756 
759  {
761  this->m_comIn_InputPort
762  );
763  }
764 
767  {
770  );
771  }
772 
773 #if FW_ENABLE_TEXT_LOGGING == 1
774  NATIVE_INT_TYPE BufferLoggerComponentBase ::
775  getNum_eventOutText_OutputPorts(void)
776  {
778  this->m_eventOutText_OutputPort
779  );
780  }
781 #endif
782 
785  {
787  this->m_pingIn_InputPort
788  );
789  }
790 
793  {
796  );
797  }
798 
801  {
804  );
805  }
806 
809  {
811  this->m_schedIn_InputPort
812  );
813  }
814 
817  {
819  this->m_tlmOut_OutputPort
820  );
821  }
822 
823  // ----------------------------------------------------------------------
824  // Port connection status queries
825  // ----------------------------------------------------------------------
826 
827  bool BufferLoggerComponentBase ::
828  isConnected_bufferSendOut_OutputPort(NATIVE_INT_TYPE portNum)
829  {
830  FW_ASSERT(
831  portNum < this->getNum_bufferSendOut_OutputPorts(),
832  static_cast<AssertArg>(portNum)
833  );
834  return this->m_bufferSendOut_OutputPort[portNum].isConnected();
835  }
836 
839  {
840  FW_ASSERT(
841  portNum < this->getNum_cmdRegOut_OutputPorts(),
842  static_cast<AssertArg>(portNum)
843  );
845  }
846 
849  {
850  FW_ASSERT(
851  portNum < this->getNum_cmdResponseOut_OutputPorts(),
852  static_cast<AssertArg>(portNum)
853  );
855  }
856 
859  {
860  FW_ASSERT(
861  portNum < this->getNum_eventOut_OutputPorts(),
862  static_cast<AssertArg>(portNum)
863  );
864  return this->m_eventOut_OutputPort[portNum].isConnected();
865  }
866 
867 #if FW_ENABLE_TEXT_LOGGING == 1
868  bool BufferLoggerComponentBase ::
869  isConnected_eventOutText_OutputPort(NATIVE_INT_TYPE portNum)
870  {
871  FW_ASSERT(
872  portNum < this->getNum_eventOutText_OutputPorts(),
873  static_cast<AssertArg>(portNum)
874  );
875  return this->m_eventOutText_OutputPort[portNum].isConnected();
876  }
877 #endif
878 
881  {
882  FW_ASSERT(
883  portNum < this->getNum_pingOut_OutputPorts(),
884  static_cast<AssertArg>(portNum)
885  );
886  return this->m_pingOut_OutputPort[portNum].isConnected();
887  }
888 
891  {
892  FW_ASSERT(
893  portNum < this->getNum_timeCaller_OutputPorts(),
894  static_cast<AssertArg>(portNum)
895  );
897  }
898 
901  {
902  FW_ASSERT(
903  portNum < this->getNum_tlmOut_OutputPorts(),
904  static_cast<AssertArg>(portNum)
905  );
906  return this->m_tlmOut_OutputPort[portNum].isConnected();
907  }
908 
909  // ----------------------------------------------------------------------
910  // Calls for messages received on command input ports
911  // ----------------------------------------------------------------------
912 
915  Fw::PassiveComponentBase* callComp,
916  NATIVE_INT_TYPE portNum,
917  FwOpcodeType opCode,
918  U32 cmdSeq,
919  Fw::CmdArgBuffer &args
920  )
921  {
922 
923  // Select base class function based on opcode
924  FW_ASSERT(callComp);
925  BufferLoggerComponentBase* compPtr =
926  (BufferLoggerComponentBase*) callComp;
927 
928  const U32 idBase = callComp->getIdBase();
929  FW_ASSERT(opCode >= idBase, opCode, idBase);
930  switch (opCode - idBase) {
931 
932  case OPCODE_BL_OPENFILE:
933  compPtr->BL_OpenFile_cmdHandlerBase(
934  opCode,
935  cmdSeq,
936  args
937  );
938  break;
939 
940  case OPCODE_BL_CLOSEFILE:
942  opCode,
943  cmdSeq,
944  args
945  );
946  break;
947 
948  case OPCODE_BL_SETLOGGING:
950  opCode,
951  cmdSeq,
952  args
953  );
954  break;
955 
956  case OPCODE_BL_FLUSHFILE:
958  opCode,
959  cmdSeq,
960  args
961  );
962  break;
963 
964  default: {
965  compPtr->cmdResponse_out(
966  opCode,cmdSeq,
968  );
969  break;
970  }
971 
972  }
973 
974  }
975 
976  void BufferLoggerComponentBase ::
977  cmdResponse_out(
978  FwOpcodeType opCode,
979  U32 cmdSeq,
980  Fw::CommandResponse response
981  )
982  {
983  FW_ASSERT(this->m_cmdResponseOut_OutputPort[0].isConnected());
985  }
986 
987  // ----------------------------------------------------------------------
988  // Base class command functions
989  // ----------------------------------------------------------------------
990 
991  void BufferLoggerComponentBase ::
992  BL_OpenFile_cmdHandlerBase(
993  FwOpcodeType opCode,
994  U32 cmdSeq,
995  Fw::CmdArgBuffer &args
996  )
997  {
998 
999  // Call pre-message hook
1000  this->BL_OpenFile_preMsgHook(opCode,cmdSeq);
1001 
1002  // Defer deserializing arguments to the message dispatcher
1003  // to avoid deserializing and reserializing just for IPC
1004  ComponentIpcSerializableBuffer msg;
1006 
1007  // Serialize for IPC
1008  _status = msg.serialize((NATIVE_INT_TYPE)CMD_BL_OPENFILE);
1009  FW_ASSERT (
1010  _status == Fw::FW_SERIALIZE_OK,
1011  static_cast<AssertArg>(_status)
1012  );
1013 
1014  // Fake port number to make message dequeue work
1015  NATIVE_INT_TYPE port = 0;
1016  _status = msg.serialize(port);
1017  FW_ASSERT (
1018  _status == Fw::FW_SERIALIZE_OK,
1019  static_cast<AssertArg>(_status)
1020  );
1021 
1022  _status = msg.serialize(opCode);
1023  FW_ASSERT (
1024  _status == Fw::FW_SERIALIZE_OK,
1025  static_cast<AssertArg>(_status)
1026  );
1027 
1028  _status = msg.serialize(cmdSeq);
1029  FW_ASSERT (
1030  _status == Fw::FW_SERIALIZE_OK,
1031  static_cast<AssertArg>(_status)
1032  );
1033 
1034  _status = msg.serialize(args);
1035  FW_ASSERT (
1036  _status == Fw::FW_SERIALIZE_OK,
1037  static_cast<AssertArg>(_status)
1038  );
1039 
1040  // send message
1041  Os::Queue::QueueBlocking _block =
1043  Os::Queue::QueueStatus qStatus =
1044  this->m_queue.send(msg, 0,_block);
1045  FW_ASSERT(
1046  qStatus == Os::Queue::QUEUE_OK,
1047  static_cast<AssertArg>(qStatus)
1048  );
1049 
1050  }
1051 
1052  void BufferLoggerComponentBase::
1053  BL_OpenFile_preMsgHook(
1054  FwOpcodeType opCode,
1055  U32 cmdSeq
1056  )
1057  {
1058  // Defaults to no-op; can be overridden
1059  }
1060 
1063  FwOpcodeType opCode,
1064  U32 cmdSeq,
1065  Fw::CmdArgBuffer &args
1066  )
1067  {
1068 
1069  // Call pre-message hook
1070  this->BL_CloseFile_preMsgHook(opCode,cmdSeq);
1071 
1072  // Defer deserializing arguments to the message dispatcher
1073  // to avoid deserializing and reserializing just for IPC
1074  ComponentIpcSerializableBuffer msg;
1076 
1077  // Serialize for IPC
1078  _status = msg.serialize((NATIVE_INT_TYPE)CMD_BL_CLOSEFILE);
1079  FW_ASSERT (
1080  _status == Fw::FW_SERIALIZE_OK,
1081  static_cast<AssertArg>(_status)
1082  );
1083 
1084  // Fake port number to make message dequeue work
1085  NATIVE_INT_TYPE port = 0;
1086  _status = msg.serialize(port);
1087  FW_ASSERT (
1088  _status == Fw::FW_SERIALIZE_OK,
1089  static_cast<AssertArg>(_status)
1090  );
1091 
1092  _status = msg.serialize(opCode);
1093  FW_ASSERT (
1094  _status == Fw::FW_SERIALIZE_OK,
1095  static_cast<AssertArg>(_status)
1096  );
1097 
1098  _status = msg.serialize(cmdSeq);
1099  FW_ASSERT (
1100  _status == Fw::FW_SERIALIZE_OK,
1101  static_cast<AssertArg>(_status)
1102  );
1103 
1104  _status = msg.serialize(args);
1105  FW_ASSERT (
1106  _status == Fw::FW_SERIALIZE_OK,
1107  static_cast<AssertArg>(_status)
1108  );
1109 
1110  // send message
1111  Os::Queue::QueueBlocking _block =
1113  Os::Queue::QueueStatus qStatus =
1114  this->m_queue.send(msg, 0,_block);
1115  FW_ASSERT(
1116  qStatus == Os::Queue::QUEUE_OK,
1117  static_cast<AssertArg>(qStatus)
1118  );
1119 
1120  }
1121 
1124  FwOpcodeType opCode,
1125  U32 cmdSeq
1126  )
1127  {
1128  // Defaults to no-op; can be overridden
1129  }
1130 
1133  FwOpcodeType opCode,
1134  U32 cmdSeq,
1135  Fw::CmdArgBuffer &args
1136  )
1137  {
1138 
1139  // Call pre-message hook
1140  this->BL_SetLogging_preMsgHook(opCode,cmdSeq);
1141 
1142  // Defer deserializing arguments to the message dispatcher
1143  // to avoid deserializing and reserializing just for IPC
1144  ComponentIpcSerializableBuffer msg;
1146 
1147  // Serialize for IPC
1148  _status = msg.serialize((NATIVE_INT_TYPE)CMD_BL_SETLOGGING);
1149  FW_ASSERT (
1150  _status == Fw::FW_SERIALIZE_OK,
1151  static_cast<AssertArg>(_status)
1152  );
1153 
1154  // Fake port number to make message dequeue work
1155  NATIVE_INT_TYPE port = 0;
1156  _status = msg.serialize(port);
1157  FW_ASSERT (
1158  _status == Fw::FW_SERIALIZE_OK,
1159  static_cast<AssertArg>(_status)
1160  );
1161 
1162  _status = msg.serialize(opCode);
1163  FW_ASSERT (
1164  _status == Fw::FW_SERIALIZE_OK,
1165  static_cast<AssertArg>(_status)
1166  );
1167 
1168  _status = msg.serialize(cmdSeq);
1169  FW_ASSERT (
1170  _status == Fw::FW_SERIALIZE_OK,
1171  static_cast<AssertArg>(_status)
1172  );
1173 
1174  _status = msg.serialize(args);
1175  FW_ASSERT (
1176  _status == Fw::FW_SERIALIZE_OK,
1177  static_cast<AssertArg>(_status)
1178  );
1179 
1180  // send message
1181  Os::Queue::QueueBlocking _block =
1183  Os::Queue::QueueStatus qStatus =
1184  this->m_queue.send(msg, 0,_block);
1185  FW_ASSERT(
1186  qStatus == Os::Queue::QUEUE_OK,
1187  static_cast<AssertArg>(qStatus)
1188  );
1189 
1190  }
1191 
1194  FwOpcodeType opCode,
1195  U32 cmdSeq
1196  )
1197  {
1198  // Defaults to no-op; can be overridden
1199  }
1200 
1203  FwOpcodeType opCode,
1204  U32 cmdSeq,
1205  Fw::CmdArgBuffer &args
1206  )
1207  {
1208 
1209  // Call pre-message hook
1210  this->BL_FlushFile_preMsgHook(opCode,cmdSeq);
1211 
1212  // Defer deserializing arguments to the message dispatcher
1213  // to avoid deserializing and reserializing just for IPC
1214  ComponentIpcSerializableBuffer msg;
1216 
1217  // Serialize for IPC
1218  _status = msg.serialize((NATIVE_INT_TYPE)CMD_BL_FLUSHFILE);
1219  FW_ASSERT (
1220  _status == Fw::FW_SERIALIZE_OK,
1221  static_cast<AssertArg>(_status)
1222  );
1223 
1224  // Fake port number to make message dequeue work
1225  NATIVE_INT_TYPE port = 0;
1226  _status = msg.serialize(port);
1227  FW_ASSERT (
1228  _status == Fw::FW_SERIALIZE_OK,
1229  static_cast<AssertArg>(_status)
1230  );
1231 
1232  _status = msg.serialize(opCode);
1233  FW_ASSERT (
1234  _status == Fw::FW_SERIALIZE_OK,
1235  static_cast<AssertArg>(_status)
1236  );
1237 
1238  _status = msg.serialize(cmdSeq);
1239  FW_ASSERT (
1240  _status == Fw::FW_SERIALIZE_OK,
1241  static_cast<AssertArg>(_status)
1242  );
1243 
1244  _status = msg.serialize(args);
1245  FW_ASSERT (
1246  _status == Fw::FW_SERIALIZE_OK,
1247  static_cast<AssertArg>(_status)
1248  );
1249 
1250  // send message
1251  Os::Queue::QueueBlocking _block =
1253  Os::Queue::QueueStatus qStatus =
1254  this->m_queue.send(msg, 0,_block);
1255  FW_ASSERT(
1256  qStatus == Os::Queue::QUEUE_OK,
1257  static_cast<AssertArg>(qStatus)
1258  );
1259 
1260  }
1261 
1264  FwOpcodeType opCode,
1265  U32 cmdSeq
1266  )
1267  {
1268  // Defaults to no-op; can be overridden
1269  }
1270 
1271  // ----------------------------------------------------------------------
1272  // Telemetry write functions
1273  // ----------------------------------------------------------------------
1274 
1275  void BufferLoggerComponentBase ::
1276  tlmWrite_BufferLogger_NumLoggedBuffers(U32 arg)
1277  {
1278 
1279  if (this->m_tlmOut_OutputPort[0].isConnected()) {
1280  Fw::Time _tlmTime;
1281  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1282  this->m_timeCaller_OutputPort[0].invoke( _tlmTime);
1283  }
1284  Fw::TlmBuffer _tlmBuff;
1285  Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
1286  FW_ASSERT(
1287  _stat == Fw::FW_SERIALIZE_OK,
1288  static_cast<AssertArg>(_stat)
1289  );
1290 
1291  FwChanIdType _id;
1292 
1293  _id = this->getIdBase() + CHANNELID_BUFFERLOGGER_NUMLOGGEDBUFFERS;
1294 
1295  this->m_tlmOut_OutputPort[0].invoke(
1296  _id,
1297  _tlmTime,
1298  _tlmBuff
1299  );
1300  }
1301 
1302  }
1303 
1304  // ----------------------------------------------------------------------
1305  // Time
1306  // ----------------------------------------------------------------------
1307 
1308  Fw::Time BufferLoggerComponentBase ::
1309  getTime(void)
1310  {
1311  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1312  Fw::Time _time;
1313  this->m_timeCaller_OutputPort[0].invoke(_time);
1314  return _time;
1315  } else {
1316  return Fw::Time(TB_NONE,0,0);
1317  }
1318  }
1319 
1320  // ----------------------------------------------------------------------
1321  // Event handling functions
1322  // ----------------------------------------------------------------------
1323 
1324  void BufferLoggerComponentBase ::
1325  log_DIAGNOSTIC_BL_LogFileClosed(
1326  Fw::LogStringArg& file
1327  )
1328  {
1329 
1330 
1331  // Get the time
1332  Fw::Time _logTime;
1333  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1334  this->m_timeCaller_OutputPort[0].invoke( _logTime);
1335  }
1336 
1337  FwEventIdType _id = static_cast<FwEventIdType>(0);
1338 
1339  _id = this->getIdBase() + EVENTID_BL_LOGFILECLOSED;
1340 
1341  // Emit the event on the log port
1342  if (this->m_eventOut_OutputPort[0].isConnected()) {
1343 
1344  Fw::LogBuffer _logBuff;
1346 
1347 #if FW_AMPCS_COMPATIBLE
1348  // Serialize the number of arguments
1349  _status = _logBuff.serialize(static_cast<U8>(1));
1350  FW_ASSERT(
1351  _status == Fw::FW_SERIALIZE_OK,
1352  static_cast<AssertArg>(_status)
1353  );
1354 #endif
1355 
1356  file.setMaxSerialize(256);
1357  _status = _logBuff.serialize(file);
1358  FW_ASSERT(
1359  _status == Fw::FW_SERIALIZE_OK,
1360  static_cast<AssertArg>(_status)
1361  );
1362 
1363 
1364  this->m_eventOut_OutputPort[0].invoke(
1365  _id,
1366  _logTime,Fw::LOG_DIAGNOSTIC,
1367  _logBuff
1368  );
1369 
1370  }
1371 
1372  // Emit the event on the text log port
1373 #if FW_ENABLE_TEXT_LOGGING
1374  if (this->m_eventOutText_OutputPort[0].isConnected()) {
1375 
1376 #if FW_OBJECT_NAMES == 1
1377  const char* _formatString =
1378  "(%s) %s: File %s closed";
1379 #else
1380  const char* _formatString =
1381  "%s: File %s closed";
1382 #endif
1383 
1384  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1385 
1386  (void) snprintf(
1387  _textBuffer,
1389  _formatString,
1390 #if FW_OBJECT_NAMES == 1
1391  this->m_objName,
1392 #endif
1393  "BL_LogFileClosed "
1394  , file.toChar()
1395  );
1396 
1397  // Null terminate
1398  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1399  Fw::TextLogString _logString = _textBuffer;
1400  this->m_eventOutText_OutputPort[0].invoke(
1401  _id,
1402  _logTime,Fw::TEXT_LOG_DIAGNOSTIC,
1403  _logString
1404  );
1405 
1406  }
1407 #endif
1408 
1409  }
1410 
1411 
1414  U32 errornum, Fw::LogStringArg& file
1415  )
1416  {
1417 
1418 
1419  // Get the time
1420  Fw::Time _logTime;
1421  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1422  this->m_timeCaller_OutputPort[0].invoke( _logTime);
1423  }
1424 
1425  FwEventIdType _id = static_cast<FwEventIdType>(0);
1426 
1427  _id = this->getIdBase() + EVENTID_BL_LOGFILEOPENERROR;
1428 
1429  // Emit the event on the log port
1430  if (this->m_eventOut_OutputPort[0].isConnected()) {
1431 
1432  Fw::LogBuffer _logBuff;
1434 
1435 #if FW_AMPCS_COMPATIBLE
1436  // Serialize the number of arguments
1437  _status = _logBuff.serialize(static_cast<U8>(2));
1438  FW_ASSERT(
1439  _status == Fw::FW_SERIALIZE_OK,
1440  static_cast<AssertArg>(_status)
1441  );
1442 #endif
1443 
1444 #if FW_AMPCS_COMPATIBLE
1445  // Serialize the argument size
1446  _status = _logBuff.serialize(
1447  static_cast<U8>(sizeof(errornum))
1448  );
1449  FW_ASSERT(
1450  _status == Fw::FW_SERIALIZE_OK,
1451  static_cast<AssertArg>(_status)
1452  );
1453 #endif
1454 
1455  _status = _logBuff.serialize(errornum);
1456  FW_ASSERT(
1457  _status == Fw::FW_SERIALIZE_OK,
1458  static_cast<AssertArg>(_status)
1459  );
1460 
1461  file.setMaxSerialize(256);
1462  _status = _logBuff.serialize(file);
1463  FW_ASSERT(
1464  _status == Fw::FW_SERIALIZE_OK,
1465  static_cast<AssertArg>(_status)
1466  );
1467 
1468 
1469  this->m_eventOut_OutputPort[0].invoke(
1470  _id,
1471  _logTime,Fw::LOG_WARNING_HI,
1472  _logBuff
1473  );
1474 
1475  }
1476 
1477  // Emit the event on the text log port
1478 #if FW_ENABLE_TEXT_LOGGING
1479  if (this->m_eventOutText_OutputPort[0].isConnected()) {
1480 
1481 #if FW_OBJECT_NAMES == 1
1482  const char* _formatString =
1483  "(%s) %s: Error %d opening file %s";
1484 #else
1485  const char* _formatString =
1486  "%s: Error %d opening file %s";
1487 #endif
1488 
1489  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1490 
1491  (void) snprintf(
1492  _textBuffer,
1494  _formatString,
1495 #if FW_OBJECT_NAMES == 1
1496  this->m_objName,
1497 #endif
1498  "BL_LogFileOpenError "
1499  , errornum
1500  , file.toChar()
1501  );
1502 
1503  // Null terminate
1504  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1505  Fw::TextLogString _logString = _textBuffer;
1506  this->m_eventOutText_OutputPort[0].invoke(
1507  _id,
1508  _logTime,Fw::TEXT_LOG_WARNING_HI,
1509  _logString
1510  );
1511 
1512  }
1513 #endif
1514 
1515  }
1516 
1517 
1520  Fw::LogStringArg& validationFile, U32 status
1521  )
1522  {
1523 
1524 
1525  // Get the time
1526  Fw::Time _logTime;
1527  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1528  this->m_timeCaller_OutputPort[0].invoke( _logTime);
1529  }
1530 
1531  FwEventIdType _id = static_cast<FwEventIdType>(0);
1532 
1534 
1535  // Emit the event on the log port
1536  if (this->m_eventOut_OutputPort[0].isConnected()) {
1537 
1538  Fw::LogBuffer _logBuff;
1540 
1541 #if FW_AMPCS_COMPATIBLE
1542  // Serialize the number of arguments
1543  _status = _logBuff.serialize(static_cast<U8>(2));
1544  FW_ASSERT(
1545  _status == Fw::FW_SERIALIZE_OK,
1546  static_cast<AssertArg>(_status)
1547  );
1548 #endif
1549 
1550  validationFile.setMaxSerialize(256);
1551  _status = _logBuff.serialize(validationFile);
1552  FW_ASSERT(
1553  _status == Fw::FW_SERIALIZE_OK,
1554  static_cast<AssertArg>(_status)
1555  );
1556 
1557 #if FW_AMPCS_COMPATIBLE
1558  // Serialize the argument size
1559  _status = _logBuff.serialize(
1560  static_cast<U8>(sizeof(status))
1561  );
1562  FW_ASSERT(
1563  _status == Fw::FW_SERIALIZE_OK,
1564  static_cast<AssertArg>(_status)
1565  );
1566 #endif
1567 
1568  _status = _logBuff.serialize(status);
1569  FW_ASSERT(
1570  _status == Fw::FW_SERIALIZE_OK,
1571  static_cast<AssertArg>(_status)
1572  );
1573 
1574 
1575  this->m_eventOut_OutputPort[0].invoke(
1576  _id,
1577  _logTime,Fw::LOG_WARNING_HI,
1578  _logBuff
1579  );
1580 
1581  }
1582 
1583  // Emit the event on the text log port
1584 #if FW_ENABLE_TEXT_LOGGING
1585  if (this->m_eventOutText_OutputPort[0].isConnected()) {
1586 
1587 #if FW_OBJECT_NAMES == 1
1588  const char* _formatString =
1589  "(%s) %s: Failed creating validation file %s with status %d";
1590 #else
1591  const char* _formatString =
1592  "%s: Failed creating validation file %s with status %d";
1593 #endif
1594 
1595  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1596 
1597  (void) snprintf(
1598  _textBuffer,
1600  _formatString,
1601 #if FW_OBJECT_NAMES == 1
1602  this->m_objName,
1603 #endif
1604  "BL_LogFileValidationError "
1605  , validationFile.toChar()
1606  , status
1607  );
1608 
1609  // Null terminate
1610  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1611  Fw::TextLogString _logString = _textBuffer;
1612  this->m_eventOutText_OutputPort[0].invoke(
1613  _id,
1614  _logTime,Fw::TEXT_LOG_WARNING_HI,
1615  _logString
1616  );
1617 
1618  }
1619 #endif
1620 
1621  }
1622 
1623 
1626  U32 errornum, U32 bytesWritten, U32 bytesToWrite, Fw::LogStringArg& file
1627  )
1628  {
1629 
1630 
1631  // Get the time
1632  Fw::Time _logTime;
1633  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1634  this->m_timeCaller_OutputPort[0].invoke( _logTime);
1635  }
1636 
1637  FwEventIdType _id = static_cast<FwEventIdType>(0);
1638 
1639  _id = this->getIdBase() + EVENTID_BL_LOGFILEWRITEERROR;
1640 
1641  // Emit the event on the log port
1642  if (this->m_eventOut_OutputPort[0].isConnected()) {
1643 
1644  Fw::LogBuffer _logBuff;
1646 
1647 #if FW_AMPCS_COMPATIBLE
1648  // Serialize the number of arguments
1649  _status = _logBuff.serialize(static_cast<U8>(4));
1650  FW_ASSERT(
1651  _status == Fw::FW_SERIALIZE_OK,
1652  static_cast<AssertArg>(_status)
1653  );
1654 #endif
1655 
1656 #if FW_AMPCS_COMPATIBLE
1657  // Serialize the argument size
1658  _status = _logBuff.serialize(
1659  static_cast<U8>(sizeof(errornum))
1660  );
1661  FW_ASSERT(
1662  _status == Fw::FW_SERIALIZE_OK,
1663  static_cast<AssertArg>(_status)
1664  );
1665 #endif
1666 
1667  _status = _logBuff.serialize(errornum);
1668  FW_ASSERT(
1669  _status == Fw::FW_SERIALIZE_OK,
1670  static_cast<AssertArg>(_status)
1671  );
1672 
1673 #if FW_AMPCS_COMPATIBLE
1674  // Serialize the argument size
1675  _status = _logBuff.serialize(
1676  static_cast<U8>(sizeof(bytesWritten))
1677  );
1678  FW_ASSERT(
1679  _status == Fw::FW_SERIALIZE_OK,
1680  static_cast<AssertArg>(_status)
1681  );
1682 #endif
1683 
1684  _status = _logBuff.serialize(bytesWritten);
1685  FW_ASSERT(
1686  _status == Fw::FW_SERIALIZE_OK,
1687  static_cast<AssertArg>(_status)
1688  );
1689 
1690 #if FW_AMPCS_COMPATIBLE
1691  // Serialize the argument size
1692  _status = _logBuff.serialize(
1693  static_cast<U8>(sizeof(bytesToWrite))
1694  );
1695  FW_ASSERT(
1696  _status == Fw::FW_SERIALIZE_OK,
1697  static_cast<AssertArg>(_status)
1698  );
1699 #endif
1700 
1701  _status = _logBuff.serialize(bytesToWrite);
1702  FW_ASSERT(
1703  _status == Fw::FW_SERIALIZE_OK,
1704  static_cast<AssertArg>(_status)
1705  );
1706 
1707  file.setMaxSerialize(256);
1708  _status = _logBuff.serialize(file);
1709  FW_ASSERT(
1710  _status == Fw::FW_SERIALIZE_OK,
1711  static_cast<AssertArg>(_status)
1712  );
1713 
1714 
1715  this->m_eventOut_OutputPort[0].invoke(
1716  _id,
1717  _logTime,Fw::LOG_WARNING_HI,
1718  _logBuff
1719  );
1720 
1721  }
1722 
1723  // Emit the event on the text log port
1724 #if FW_ENABLE_TEXT_LOGGING
1725  if (this->m_eventOutText_OutputPort[0].isConnected()) {
1726 
1727 #if FW_OBJECT_NAMES == 1
1728  const char* _formatString =
1729  "(%s) %s: Error %d while writing %d of %d bytes to %s";
1730 #else
1731  const char* _formatString =
1732  "%s: Error %d while writing %d of %d bytes to %s";
1733 #endif
1734 
1735  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1736 
1737  (void) snprintf(
1738  _textBuffer,
1740  _formatString,
1741 #if FW_OBJECT_NAMES == 1
1742  this->m_objName,
1743 #endif
1744  "BL_LogFileWriteError "
1745  , errornum
1746  , bytesWritten
1747  , bytesToWrite
1748  , file.toChar()
1749  );
1750 
1751  // Null terminate
1752  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1753  Fw::TextLogString _logString = _textBuffer;
1754  this->m_eventOutText_OutputPort[0].invoke(
1755  _id,
1756  _logTime,Fw::TEXT_LOG_WARNING_HI,
1757  _logString
1758  );
1759 
1760  }
1761 #endif
1762 
1763  }
1764 
1765 
1768  void
1769  )
1770  {
1771 
1772 
1773  // Get the time
1774  Fw::Time _logTime;
1775  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1776  this->m_timeCaller_OutputPort[0].invoke( _logTime);
1777  }
1778 
1779  FwEventIdType _id = static_cast<FwEventIdType>(0);
1780 
1781  _id = this->getIdBase() + EVENTID_BL_ACTIVATED;
1782 
1783  // Emit the event on the log port
1784  if (this->m_eventOut_OutputPort[0].isConnected()) {
1785 
1786  Fw::LogBuffer _logBuff;
1787 #if FW_AMPCS_COMPATIBLE
1788  // for AMPCS, need to encode zero arguments
1790  _zero_status = _logBuff.serialize(static_cast<U8>(0));
1791  FW_ASSERT(
1792  _zero_status == Fw::FW_SERIALIZE_OK,
1793  static_cast<AssertArg>(_zero_status)
1794  );
1795 #endif
1796 
1797 
1798  this->m_eventOut_OutputPort[0].invoke(
1799  _id,
1800  _logTime,Fw::LOG_ACTIVITY_LO,
1801  _logBuff
1802  );
1803 
1804  }
1805 
1806  // Emit the event on the text log port
1807 #if FW_ENABLE_TEXT_LOGGING
1808  if (this->m_eventOutText_OutputPort[0].isConnected()) {
1809 
1810 #if FW_OBJECT_NAMES == 1
1811  const char* _formatString =
1812  "(%s) %s: Buffer logger was activated";
1813 #else
1814  const char* _formatString =
1815  "%s: Buffer logger was activated";
1816 #endif
1817 
1818  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1819 
1820  (void) snprintf(
1821  _textBuffer,
1823  _formatString,
1824 #if FW_OBJECT_NAMES == 1
1825  this->m_objName,
1826 #endif
1827  "BL_Activated "
1828  );
1829 
1830  // Null terminate
1831  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1832  Fw::TextLogString _logString = _textBuffer;
1833  this->m_eventOutText_OutputPort[0].invoke(
1834  _id,
1835  _logTime,Fw::TEXT_LOG_ACTIVITY_LO,
1836  _logString
1837  );
1838 
1839  }
1840 #endif
1841 
1842  }
1843 
1844 
1847  void
1848  )
1849  {
1850 
1851 
1852  // Get the time
1853  Fw::Time _logTime;
1854  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1855  this->m_timeCaller_OutputPort[0].invoke( _logTime);
1856  }
1857 
1858  FwEventIdType _id = static_cast<FwEventIdType>(0);
1859 
1860  _id = this->getIdBase() + EVENTID_BL_DEATIVATED;
1861 
1862  // Emit the event on the log port
1863  if (this->m_eventOut_OutputPort[0].isConnected()) {
1864 
1865  Fw::LogBuffer _logBuff;
1866 #if FW_AMPCS_COMPATIBLE
1867  // for AMPCS, need to encode zero arguments
1869  _zero_status = _logBuff.serialize(static_cast<U8>(0));
1870  FW_ASSERT(
1871  _zero_status == Fw::FW_SERIALIZE_OK,
1872  static_cast<AssertArg>(_zero_status)
1873  );
1874 #endif
1875 
1876 
1877  this->m_eventOut_OutputPort[0].invoke(
1878  _id,
1879  _logTime,Fw::LOG_ACTIVITY_LO,
1880  _logBuff
1881  );
1882 
1883  }
1884 
1885  // Emit the event on the text log port
1886 #if FW_ENABLE_TEXT_LOGGING
1887  if (this->m_eventOutText_OutputPort[0].isConnected()) {
1888 
1889 #if FW_OBJECT_NAMES == 1
1890  const char* _formatString =
1891  "(%s) %s: Buffer logger was deactivated";
1892 #else
1893  const char* _formatString =
1894  "%s: Buffer logger was deactivated";
1895 #endif
1896 
1897  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1898 
1899  (void) snprintf(
1900  _textBuffer,
1902  _formatString,
1903 #if FW_OBJECT_NAMES == 1
1904  this->m_objName,
1905 #endif
1906  "BL_Deativated "
1907  );
1908 
1909  // Null terminate
1910  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1911  Fw::TextLogString _logString = _textBuffer;
1912  this->m_eventOutText_OutputPort[0].invoke(
1913  _id,
1914  _logTime,Fw::TEXT_LOG_ACTIVITY_LO,
1915  _logString
1916  );
1917 
1918  }
1919 #endif
1920 
1921  }
1922 
1923 
1926  void
1927  )
1928  {
1929 
1930 
1931  // Get the time
1932  Fw::Time _logTime;
1933  if (this->m_timeCaller_OutputPort[0].isConnected()) {
1934  this->m_timeCaller_OutputPort[0].invoke( _logTime);
1935  }
1936 
1937  FwEventIdType _id = static_cast<FwEventIdType>(0);
1938 
1940 
1941  // Emit the event on the log port
1942  if (this->m_eventOut_OutputPort[0].isConnected()) {
1943 
1944  Fw::LogBuffer _logBuff;
1945 #if FW_AMPCS_COMPATIBLE
1946  // for AMPCS, need to encode zero arguments
1948  _zero_status = _logBuff.serialize(static_cast<U8>(0));
1949  FW_ASSERT(
1950  _zero_status == Fw::FW_SERIALIZE_OK,
1951  static_cast<AssertArg>(_zero_status)
1952  );
1953 #endif
1954 
1955 
1956  this->m_eventOut_OutputPort[0].invoke(
1957  _id,
1958  _logTime,Fw::LOG_WARNING_HI,
1959  _logBuff
1960  );
1961 
1962  }
1963 
1964  // Emit the event on the text log port
1965 #if FW_ENABLE_TEXT_LOGGING
1966  if (this->m_eventOutText_OutputPort[0].isConnected()) {
1967 
1968 #if FW_OBJECT_NAMES == 1
1969  const char* _formatString =
1970  "(%s) %s: No log file open command";
1971 #else
1972  const char* _formatString =
1973  "%s: No log file open command";
1974 #endif
1975 
1976  char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1977 
1978  (void) snprintf(
1979  _textBuffer,
1981  _formatString,
1982 #if FW_OBJECT_NAMES == 1
1983  this->m_objName,
1984 #endif
1985  "BL_NoLogFileOpenInitError "
1986  );
1987 
1988  // Null terminate
1989  _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1990  Fw::TextLogString _logString = _textBuffer;
1991  this->m_eventOutText_OutputPort[0].invoke(
1992  _id,
1993  _logTime,Fw::TEXT_LOG_WARNING_HI,
1994  _logString
1995  );
1996 
1997  }
1998 #endif
1999 
2000  }
2001 
2002 
2003  // ----------------------------------------------------------------------
2004  // Calls for invocations received on typed input ports
2005  // ----------------------------------------------------------------------
2006 
2007  void BufferLoggerComponentBase ::
2008  m_p_bufferSendIn_in(
2009  Fw::PassiveComponentBase* callComp,
2010  NATIVE_INT_TYPE portNum,
2011  Fw::Buffer &fwBuffer
2012  )
2013  {
2014  FW_ASSERT(callComp);
2015  BufferLoggerComponentBase* compPtr =
2016  (BufferLoggerComponentBase*) callComp;
2017  compPtr->bufferSendIn_handlerBase(portNum, fwBuffer);
2018  }
2019 
2022  Fw::PassiveComponentBase* callComp,
2023  NATIVE_INT_TYPE portNum,
2024  Fw::ComBuffer &data, U32 context
2025  )
2026  {
2027  FW_ASSERT(callComp);
2028  BufferLoggerComponentBase* compPtr =
2029  (BufferLoggerComponentBase*) callComp;
2030  compPtr->comIn_handlerBase(portNum, data, context);
2031  }
2032 
2035  Fw::PassiveComponentBase* callComp,
2036  NATIVE_INT_TYPE portNum,
2037  U32 key
2038  )
2039  {
2040  FW_ASSERT(callComp);
2041  BufferLoggerComponentBase* compPtr =
2042  (BufferLoggerComponentBase*) callComp;
2043  compPtr->pingIn_handlerBase(portNum, key);
2044  }
2045 
2048  Fw::PassiveComponentBase* callComp,
2049  NATIVE_INT_TYPE portNum,
2050  NATIVE_UINT_TYPE context
2051  )
2052  {
2053  FW_ASSERT(callComp);
2054  BufferLoggerComponentBase* compPtr =
2055  (BufferLoggerComponentBase*) callComp;
2056  compPtr->schedIn_handlerBase(portNum, context);
2057  }
2058 
2059  // ----------------------------------------------------------------------
2060  // Port handler base-class functions for typed input ports
2061  // ----------------------------------------------------------------------
2062 
2063  void BufferLoggerComponentBase ::
2064  bufferSendIn_handlerBase(
2065  NATIVE_INT_TYPE portNum,
2066  Fw::Buffer &fwBuffer
2067  )
2068  {
2069 
2070  // Make sure port number is valid
2071  FW_ASSERT(portNum < this->getNum_bufferSendIn_InputPorts(),static_cast<AssertArg>(portNum));
2072 
2073  // Call pre-message hook
2074  bufferSendIn_preMsgHook(
2075  portNum,
2076  fwBuffer
2077  );
2078 
2079  ComponentIpcSerializableBuffer msg;
2081 
2082  _status = msg.serialize(
2083  static_cast<NATIVE_INT_TYPE>(BUFFERSENDIN_BUFFERSEND)
2084  );
2085  FW_ASSERT (
2086  _status == Fw::FW_SERIALIZE_OK,
2087  static_cast<AssertArg>(_status)
2088  );
2089 
2090  _status = msg.serialize(portNum);
2091  FW_ASSERT (
2092  _status == Fw::FW_SERIALIZE_OK,
2093  static_cast<AssertArg>(_status)
2094  );
2095 
2096  // Serialize argument fwBuffer
2097  _status = msg.serialize(fwBuffer);
2098  FW_ASSERT(
2099  _status == Fw::FW_SERIALIZE_OK,
2100  static_cast<AssertArg>(_status)
2101  );
2102 
2103 
2104  // send message
2105  Os::Queue::QueueBlocking _block =
2107  Os::Queue::QueueStatus qStatus =
2108  this->m_queue.send(msg, 0,_block);
2109  FW_ASSERT(
2110  qStatus == Os::Queue::QUEUE_OK,
2111  static_cast<AssertArg>(qStatus)
2112  );
2113 
2114  }
2115 
2118  NATIVE_INT_TYPE portNum,
2119  Fw::ComBuffer &data, U32 context
2120  )
2121  {
2122 
2123  // Make sure port number is valid
2124  FW_ASSERT(portNum < this->getNum_comIn_InputPorts(),static_cast<AssertArg>(portNum));
2125 
2126  // Call pre-message hook
2128  portNum,
2129  data, context
2130  );
2131 
2132  ComponentIpcSerializableBuffer msg;
2134 
2135  _status = msg.serialize(
2136  static_cast<NATIVE_INT_TYPE>(COMIN_COM)
2137  );
2138  FW_ASSERT (
2139  _status == Fw::FW_SERIALIZE_OK,
2140  static_cast<AssertArg>(_status)
2141  );
2142 
2143  _status = msg.serialize(portNum);
2144  FW_ASSERT (
2145  _status == Fw::FW_SERIALIZE_OK,
2146  static_cast<AssertArg>(_status)
2147  );
2148 
2149  // Serialize argument data
2150  _status = msg.serialize(data);
2151  FW_ASSERT(
2152  _status == Fw::FW_SERIALIZE_OK,
2153  static_cast<AssertArg>(_status)
2154  );
2155 
2156  // Serialize argument context
2157  _status = msg.serialize(context);
2158  FW_ASSERT(
2159  _status == Fw::FW_SERIALIZE_OK,
2160  static_cast<AssertArg>(_status)
2161  );
2162 
2163 
2164  // send message
2165  Os::Queue::QueueBlocking _block =
2167  Os::Queue::QueueStatus qStatus =
2168  this->m_queue.send(msg, 0,_block);
2169  FW_ASSERT(
2170  qStatus == Os::Queue::QUEUE_OK,
2171  static_cast<AssertArg>(qStatus)
2172  );
2173 
2174  }
2175 
2178  NATIVE_INT_TYPE portNum,
2179  U32 key
2180  )
2181  {
2182 
2183  // Make sure port number is valid
2184  FW_ASSERT(portNum < this->getNum_pingIn_InputPorts(),static_cast<AssertArg>(portNum));
2185 
2186  // Call pre-message hook
2188  portNum,
2189  key
2190  );
2191 
2192  ComponentIpcSerializableBuffer msg;
2194 
2195  _status = msg.serialize(
2196  static_cast<NATIVE_INT_TYPE>(PINGIN_PING)
2197  );
2198  FW_ASSERT (
2199  _status == Fw::FW_SERIALIZE_OK,
2200  static_cast<AssertArg>(_status)
2201  );
2202 
2203  _status = msg.serialize(portNum);
2204  FW_ASSERT (
2205  _status == Fw::FW_SERIALIZE_OK,
2206  static_cast<AssertArg>(_status)
2207  );
2208 
2209  // Serialize argument key
2210  _status = msg.serialize(key);
2211  FW_ASSERT(
2212  _status == Fw::FW_SERIALIZE_OK,
2213  static_cast<AssertArg>(_status)
2214  );
2215 
2216 
2217  // send message
2218  Os::Queue::QueueBlocking _block =
2220  Os::Queue::QueueStatus qStatus =
2221  this->m_queue.send(msg, 0,_block);
2222  FW_ASSERT(
2223  qStatus == Os::Queue::QUEUE_OK,
2224  static_cast<AssertArg>(qStatus)
2225  );
2226 
2227  }
2228 
2231  NATIVE_INT_TYPE portNum,
2232  NATIVE_UINT_TYPE context
2233  )
2234  {
2235 
2236  // Make sure port number is valid
2237  FW_ASSERT(portNum < this->getNum_schedIn_InputPorts(),static_cast<AssertArg>(portNum));
2238 
2239  // Call pre-message hook
2241  portNum,
2242  context
2243  );
2244 
2245  ComponentIpcSerializableBuffer msg;
2247 
2248  _status = msg.serialize(
2249  static_cast<NATIVE_INT_TYPE>(SCHEDIN_SCHED)
2250  );
2251  FW_ASSERT (
2252  _status == Fw::FW_SERIALIZE_OK,
2253  static_cast<AssertArg>(_status)
2254  );
2255 
2256  _status = msg.serialize(portNum);
2257  FW_ASSERT (
2258  _status == Fw::FW_SERIALIZE_OK,
2259  static_cast<AssertArg>(_status)
2260  );
2261 
2262  // Serialize argument context
2263  _status = msg.serialize(context);
2264  FW_ASSERT(
2265  _status == Fw::FW_SERIALIZE_OK,
2266  static_cast<AssertArg>(_status)
2267  );
2268 
2269 
2270  // send message
2271  Os::Queue::QueueBlocking _block =
2273  Os::Queue::QueueStatus qStatus =
2274  this->m_queue.send(msg, 0,_block);
2275  FW_ASSERT(
2276  qStatus == Os::Queue::QUEUE_OK,
2277  static_cast<AssertArg>(qStatus)
2278  );
2279 
2280  }
2281 
2282  // ----------------------------------------------------------------------
2283  // Pre-message hooks for async input ports
2284  // ----------------------------------------------------------------------
2285 
2286  void BufferLoggerComponentBase ::
2287  bufferSendIn_preMsgHook(
2288  NATIVE_INT_TYPE portNum,
2289  Fw::Buffer &fwBuffer
2290  )
2291  {
2292  // Default: no-op
2293  }
2294 
2297  NATIVE_INT_TYPE portNum,
2298  Fw::ComBuffer &data, U32 context
2299  )
2300  {
2301  // Default: no-op
2302  }
2303 
2306  NATIVE_INT_TYPE portNum,
2307  U32 key
2308  )
2309  {
2310  // Default: no-op
2311  }
2312 
2315  NATIVE_INT_TYPE portNum,
2316  NATIVE_UINT_TYPE context
2317  )
2318  {
2319  // Default: no-op
2320  }
2321 
2322  // ----------------------------------------------------------------------
2323  // Message dispatch method for active and queued components. Called
2324  // by active component thread or implementation code for queued components
2325  // ----------------------------------------------------------------------
2326 
2328  doDispatch(void)
2329  {
2330  ComponentIpcSerializableBuffer msg;
2331  NATIVE_INT_TYPE priority;
2332 
2333  Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_BLOCKING);
2334  FW_ASSERT(
2335  msgStatus == Os::Queue::QUEUE_OK,
2336  static_cast<AssertArg>(msgStatus)
2337  );
2338 
2339  // Reset to beginning of buffer
2340  msg.resetDeser();
2341 
2342  NATIVE_INT_TYPE desMsg;
2343  Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
2344  FW_ASSERT(
2345  deserStatus == Fw::FW_SERIALIZE_OK,
2346  static_cast<AssertArg>(deserStatus)
2347  );
2348 
2349  MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
2350 
2351  if (msgType == BUFFERLOGGER_COMPONENT_EXIT) {
2352  return MSG_DISPATCH_EXIT;
2353  }
2354 
2356  deserStatus = msg.deserialize(portNum);
2357  FW_ASSERT(
2358  deserStatus == Fw::FW_SERIALIZE_OK,
2359  static_cast<AssertArg>(deserStatus)
2360  );
2361 
2362  switch (msgType) {
2363 
2364  // Handle async input port bufferSendIn
2365  case BUFFERSENDIN_BUFFERSEND: {
2366 
2367  // Deserialize argument fwBuffer
2369  deserStatus = msg.deserialize(fwBuffer);
2370  FW_ASSERT(
2371  deserStatus == Fw::FW_SERIALIZE_OK,
2372  static_cast<AssertArg>(deserStatus)
2373  );
2374 
2375  // Call handler function
2376  this->bufferSendIn_handler(
2377  portNum,
2378  fwBuffer
2379  );
2380 
2381  break;
2382 
2383  }
2384 
2385  // Handle async input port comIn
2386  case COMIN_COM: {
2387 
2388  // Deserialize argument data
2389  Fw::ComBuffer data;
2390  deserStatus = msg.deserialize(data);
2391  FW_ASSERT(
2392  deserStatus == Fw::FW_SERIALIZE_OK,
2393  static_cast<AssertArg>(deserStatus)
2394  );
2395 
2396  // Deserialize argument context
2397  U32 context;
2398  deserStatus = msg.deserialize(context);
2399  FW_ASSERT(
2400  deserStatus == Fw::FW_SERIALIZE_OK,
2401  static_cast<AssertArg>(deserStatus)
2402  );
2403 
2404  // Call handler function
2405  this->comIn_handler(
2406  portNum,
2407  data, context
2408  );
2409 
2410  break;
2411 
2412  }
2413 
2414  // Handle async input port pingIn
2415  case PINGIN_PING: {
2416 
2417  // Deserialize argument key
2418  U32 key;
2419  deserStatus = msg.deserialize(key);
2420  FW_ASSERT(
2421  deserStatus == Fw::FW_SERIALIZE_OK,
2422  static_cast<AssertArg>(deserStatus)
2423  );
2424 
2425  // Call handler function
2426  this->pingIn_handler(
2427  portNum,
2428  key
2429  );
2430 
2431  break;
2432 
2433  }
2434 
2435  // Handle async input port schedIn
2436  case SCHEDIN_SCHED: {
2437 
2438  // Deserialize argument context
2439  NATIVE_UINT_TYPE context;
2440  deserStatus = msg.deserialize(context);
2441  FW_ASSERT(
2442  deserStatus == Fw::FW_SERIALIZE_OK,
2443  static_cast<AssertArg>(deserStatus)
2444  );
2445 
2446  // Call handler function
2447  this->schedIn_handler(
2448  portNum,
2449  context
2450  );
2451 
2452  break;
2453 
2454  }
2455 
2456  // Handle command BL_OpenFile
2457  case CMD_BL_OPENFILE: {
2458  // Deserialize opcode
2459  FwOpcodeType opCode;
2460  deserStatus = msg.deserialize(opCode);
2461  FW_ASSERT (
2462  deserStatus == Fw::FW_SERIALIZE_OK,
2463  static_cast<AssertArg>(deserStatus)
2464  );
2465 
2466  // Deserialize command sequence
2467  U32 cmdSeq;
2468  deserStatus = msg.deserialize(cmdSeq);
2469  FW_ASSERT (
2470  deserStatus == Fw::FW_SERIALIZE_OK,
2471  static_cast<AssertArg>(deserStatus)
2472  );
2473 
2474  // Deserialize command argument buffer
2476  deserStatus = msg.deserialize(args);
2477  FW_ASSERT (
2478  deserStatus == Fw::FW_SERIALIZE_OK,
2479  static_cast<AssertArg>(deserStatus)
2480  );
2481 
2482  // Reset buffer
2483  args.resetDeser();
2484 
2485  // Deserialize argument file
2487  deserStatus = args.deserialize(file);
2488  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2489  if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2490  this->cmdResponse_out(
2491  opCode,
2492  cmdSeq,
2494  );
2495  }
2496  // Don't crash the task if bad arguments were passed from the ground
2497  break;
2498  }
2499 
2500  // Make sure there was no data left over.
2501  // That means the argument buffer size was incorrect.
2502 #if FW_CMD_CHECK_RESIDUAL
2503  if (args.getBuffLeft() != 0) {
2504  if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2505  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2506  }
2507  // Don't crash the task if bad arguments were passed from the ground
2508  break;
2509  }
2510 #endif
2511  // Call handler function
2512  this->BL_OpenFile_cmdHandler(
2513  opCode,
2514  cmdSeq,
2515  file
2516  );
2517 
2518  break;
2519 
2520  }
2521 
2522  // Handle command BL_CloseFile
2523  case CMD_BL_CLOSEFILE: {
2524  // Deserialize opcode
2525  FwOpcodeType opCode;
2526  deserStatus = msg.deserialize(opCode);
2527  FW_ASSERT (
2528  deserStatus == Fw::FW_SERIALIZE_OK,
2529  static_cast<AssertArg>(deserStatus)
2530  );
2531 
2532  // Deserialize command sequence
2533  U32 cmdSeq;
2534  deserStatus = msg.deserialize(cmdSeq);
2535  FW_ASSERT (
2536  deserStatus == Fw::FW_SERIALIZE_OK,
2537  static_cast<AssertArg>(deserStatus)
2538  );
2539 
2540  // Deserialize command argument buffer
2542  deserStatus = msg.deserialize(args);
2543  FW_ASSERT (
2544  deserStatus == Fw::FW_SERIALIZE_OK,
2545  static_cast<AssertArg>(deserStatus)
2546  );
2547 
2548  // Reset buffer
2549  args.resetDeser();
2550 
2551  // Make sure there was no data left over.
2552  // That means the argument buffer size was incorrect.
2553 #if FW_CMD_CHECK_RESIDUAL
2554  if (args.getBuffLeft() != 0) {
2555  if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2556  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2557  }
2558  // Don't crash the task if bad arguments were passed from the ground
2559  break;
2560  }
2561 #endif
2562  // Call handler function
2563  this->BL_CloseFile_cmdHandler(opCode, cmdSeq);
2564 
2565  break;
2566 
2567  }
2568 
2569  // Handle command BL_SetLogging
2570  case CMD_BL_SETLOGGING: {
2571  // Deserialize opcode
2572  FwOpcodeType opCode;
2573  deserStatus = msg.deserialize(opCode);
2574  FW_ASSERT (
2575  deserStatus == Fw::FW_SERIALIZE_OK,
2576  static_cast<AssertArg>(deserStatus)
2577  );
2578 
2579  // Deserialize command sequence
2580  U32 cmdSeq;
2581  deserStatus = msg.deserialize(cmdSeq);
2582  FW_ASSERT (
2583  deserStatus == Fw::FW_SERIALIZE_OK,
2584  static_cast<AssertArg>(deserStatus)
2585  );
2586 
2587  // Deserialize command argument buffer
2589  deserStatus = msg.deserialize(args);
2590  FW_ASSERT (
2591  deserStatus == Fw::FW_SERIALIZE_OK,
2592  static_cast<AssertArg>(deserStatus)
2593  );
2594 
2595  // Reset buffer
2596  args.resetDeser();
2597 
2598  // Deserialize argument state
2599  LogState state;
2600  FwEnumStoreType stateInt;
2601  deserStatus = args.deserialize(stateInt);
2602  state = (LogState)stateInt;
2603  if (deserStatus != Fw::FW_SERIALIZE_OK) {
2604  if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2605  this->cmdResponse_out(
2606  opCode,
2607  cmdSeq,
2609  );
2610  }
2611  // Don't crash the task if bad arguments were passed from the ground
2612  break;
2613  }
2614 
2615  // Make sure there was no data left over.
2616  // That means the argument buffer size was incorrect.
2617 #if FW_CMD_CHECK_RESIDUAL
2618  if (args.getBuffLeft() != 0) {
2619  if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2620  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2621  }
2622  // Don't crash the task if bad arguments were passed from the ground
2623  break;
2624  }
2625 #endif
2626  // Call handler function
2628  opCode,
2629  cmdSeq,
2630  state
2631  );
2632 
2633  break;
2634 
2635  }
2636 
2637  // Handle command BL_FlushFile
2638  case CMD_BL_FLUSHFILE: {
2639  // Deserialize opcode
2640  FwOpcodeType opCode;
2641  deserStatus = msg.deserialize(opCode);
2642  FW_ASSERT (
2643  deserStatus == Fw::FW_SERIALIZE_OK,
2644  static_cast<AssertArg>(deserStatus)
2645  );
2646 
2647  // Deserialize command sequence
2648  U32 cmdSeq;
2649  deserStatus = msg.deserialize(cmdSeq);
2650  FW_ASSERT (
2651  deserStatus == Fw::FW_SERIALIZE_OK,
2652  static_cast<AssertArg>(deserStatus)
2653  );
2654 
2655  // Deserialize command argument buffer
2657  deserStatus = msg.deserialize(args);
2658  FW_ASSERT (
2659  deserStatus == Fw::FW_SERIALIZE_OK,
2660  static_cast<AssertArg>(deserStatus)
2661  );
2662 
2663  // Reset buffer
2664  args.resetDeser();
2665 
2666  // Make sure there was no data left over.
2667  // That means the argument buffer size was incorrect.
2668 #if FW_CMD_CHECK_RESIDUAL
2669  if (args.getBuffLeft() != 0) {
2670  if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2671  this->cmdResponse_out(opCode,cmdSeq,Fw::COMMAND_FORMAT_ERROR);
2672  }
2673  // Don't crash the task if bad arguments were passed from the ground
2674  break;
2675  }
2676 #endif
2677  // Call handler function
2678  this->BL_FlushFile_cmdHandler(opCode, cmdSeq);
2679 
2680  break;
2681 
2682  }
2683 
2684  default:
2685  return MSG_DISPATCH_ERROR;
2686 
2687  }
2688 
2689  return MSG_DISPATCH_OK;
2690 
2691  }
2692 
2693 } // end namespace Svc
Svc::BufferLoggerComponentBase::set_bufferSendOut_OutputPort
void set_bufferSendOut_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputBufferSendPort *port)
Definition: BufferLoggerComponentAc.cpp:133
Fw::OutputCmdRegPort::init
void init(void)
Definition: CmdRegPortAc.cpp:89
Svc::BufferLoggerComponentBase::set_eventOut_OutputPort
void set_eventOut_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputLogPort *port)
Definition: BufferLoggerComponentAc.cpp:163
Svc::BufferLoggerComponentBase::BL_CloseFile_preMsgHook
virtual void BL_CloseFile_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Definition: BufferLoggerComponentAc.cpp:1123
Fw::TextLogString
Definition: TextLogString.hpp:11
Fw::InputTimePort
Definition: TimePortAc.hpp:28
Svc::InputPingPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: PingPortAc.hpp:30
Svc::BufferLoggerComponentBase::log_WARNING_HI_BL_LogFileOpenError
void log_WARNING_HI_BL_LogFileOpenError(U32 errornum, Fw::LogStringArg &file)
Definition: BufferLoggerComponentAc.cpp:1413
Fw::InputTlmPort
Definition: TlmPortAc.hpp:29
Fw::PassiveComponentBase::getIdBase
U32 getIdBase(void) const
Definition: PassiveComponentBase.cpp:40
Svc::BufferLoggerComponentBase::m_pingOut_OutputPort
Svc::OutputPingPort m_pingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:927
Svc::BufferLoggerComponentBase::m_p_schedIn_in
static void m_p_schedIn_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context)
Definition: BufferLoggerComponentAc.cpp:2047
Svc::BufferLoggerComponentBase::isConnected_tlmOut_OutputPort
bool isConnected_tlmOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:900
Svc::BufferLoggerComponentBase::response
PROTECTED U32 Fw::CommandResponse response
Definition: BufferLoggerComponentAc.hpp:750
Svc::BufferLoggerComponentBase::EVENTID_BL_LOGFILEWRITEERROR
PROTECTED EVENTID_BL_LOGFILEWRITEERROR
Definition: BufferLoggerComponentAc.hpp:762
Fw::Time
Definition: Time.hpp:10
Svc::BufferLoggerComponentBase::BL_FlushFile_cmdHandler
virtual void BL_FlushFile_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
Handler for command BL_FlushFile.
Fw::QueuedComponentBase::doDispatch
virtual MsgDispatchStatus doDispatch(void)=0
method to dispatch a single message in the queue.
port4
BYTE port4[Svc::InputSchedPort::SERIALIZED_SIZE]
Definition: BufferLoggerComponentAc.cpp:48
Svc::BufferLoggerComponentBase::OPCODE_BL_FLUSHFILE
PROTECTED OPCODE_BL_FLUSHFILE
Definition: BufferLoggerComponentAc.hpp:622
Svc::BufferLoggerComponentBase::m_p_comIn_in
static void m_p_comIn_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, Fw::ComBuffer &data, U32 context)
Definition: BufferLoggerComponentAc.cpp:2021
Svc::BufferLoggerComponentBase::getNum_timeCaller_OutputPorts
NATIVE_INT_TYPE getNum_timeCaller_OutputPorts(void)
Definition: BufferLoggerComponentAc.cpp:800
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::InputComPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: ComPortAc.hpp:31
Svc::BufferLoggerComponentBase::getNum_cmdResponseOut_OutputPorts
NATIVE_INT_TYPE getNum_cmdResponseOut_OutputPorts(void)
Definition: BufferLoggerComponentAc.cpp:750
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::CmdStringArg::toChar
const char * toChar(void) const
Definition: CmdString.cpp:34
Svc::BufferLoggerComponentBase::pingIn_preMsgHook
virtual void pingIn_preMsgHook(NATIVE_INT_TYPE portNum, U32 key)
Definition: BufferLoggerComponentAc.cpp:2305
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::BufferLoggerComponentBase::isConnected_cmdResponseOut_OutputPort
bool isConnected_cmdResponseOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:848
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::BufferLoggerComponentBase::getNum_tlmOut_OutputPorts
NATIVE_INT_TYPE getNum_tlmOut_OutputPorts(void)
Definition: BufferLoggerComponentAc.cpp:816
Fw::TEXT_LOG_DIAGNOSTIC
@ TEXT_LOG_DIAGNOSTIC
Definition: LogTextPortAc.hpp:33
FW_NUM_ARRAY_ELEMENTS
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition: BasicTypes.hpp:103
Fw::LogStringArg
Definition: LogString.hpp:11
Fw::InputBufferSendPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: BufferSendPortAc.hpp:31
port2
BYTE port2[Fw::InputComPort::SERIALIZED_SIZE]
Definition: BufferLoggerComponentAc.cpp:46
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.hpp:76
Svc::BufferLoggerComponentBase::log_WARNING_HI_BL_NoLogFileOpenInitError
void log_WARNING_HI_BL_NoLogFileOpenInitError(void)
Definition: BufferLoggerComponentAc.cpp:1925
Svc::BufferLoggerComponentBase::cmdSeq
PROTECTED U32 cmdSeq
Definition: BufferLoggerComponentAc.hpp:635
Svc::BufferLoggerComponentBase::m_eventOut_OutputPort
Fw::OutputLogPort m_eventOut_OutputPort[NUM_EVENTOUT_OUTPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:917
port1
BYTE port1[Fw::InputBufferSendPort::SERIALIZED_SIZE]
Definition: BufferLoggerComponentAc.cpp:45
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
Svc::BufferLoggerComponentBase::OPCODE_BL_CLOSEFILE
PROTECTED OPCODE_BL_CLOSEFILE
Definition: BufferLoggerComponentAc.hpp:620
Svc::BufferLoggerComponentBase::EVENTID_BL_NOLOGFILEOPENINITERROR
PROTECTED EVENTID_BL_NOLOGFILEOPENINITERROR
Definition: BufferLoggerComponentAc.hpp:765
Fw::InputCmdRegPort
Definition: CmdRegPortAc.hpp:27
Svc::BufferLoggerComponentBase::getNum_cmdRegOut_OutputPorts
NATIVE_INT_TYPE getNum_cmdRegOut_OutputPorts(void)
Definition: BufferLoggerComponentAc.cpp:742
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
Svc::BufferLoggerComponentBase::portNum
PRIVATE NATIVE_INT_TYPE portNum
Definition: BufferLoggerComponentAc.hpp:947
Svc::BufferLoggerComponentBase::BL_CloseFile_cmdHandlerBase
void BL_CloseFile_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: BufferLoggerComponentAc.cpp:1062
Fw::InputCmdPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: CmdPortAc.cpp:42
Svc::BufferLoggerComponentBase::BL_CloseFile_cmdHandler
virtual void BL_CloseFile_cmdHandler(FwOpcodeType opCode, U32 cmdSeq)=0
Handler for command BL_CloseFile.
Svc::BufferLoggerComponentBase::BL_FlushFile_cmdHandlerBase
void BL_FlushFile_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: BufferLoggerComponentAc.cpp:1202
Svc::OutputPingPort::invoke
void invoke(U32 key)
Definition: PingPortAc.cpp:103
Svc::InputSchedPort::init
void init(void)
initialization function
Definition: SchedPortAc.cpp:38
Fw::Buffer
Definition: BufferSerializableAc.hpp:24
Fw::CmdStringArg
Definition: CmdString.hpp:11
Fw::TEXT_LOG_WARNING_HI
@ TEXT_LOG_WARNING_HI
Definition: LogTextPortAc.hpp:28
Svc::BufferLoggerComponentBase::isConnected_pingOut_OutputPort
bool isConnected_pingOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:880
Svc::BufferLoggerComponentBase::EVENTID_BL_ACTIVATED
PROTECTED EVENTID_BL_ACTIVATED
Definition: BufferLoggerComponentAc.hpp:763
Svc::BufferLoggerComponentBase::m_tlmOut_OutputPort
Fw::OutputTlmPort m_tlmOut_OutputPort[NUM_TLMOUT_OUTPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:935
Svc::BufferLoggerComponentBase::getNum_comIn_InputPorts
NATIVE_INT_TYPE getNum_comIn_InputPorts(void)
Definition: BufferLoggerComponentAc.cpp:758
Svc::InputSchedPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: SchedPortAc.hpp:30
Svc::BufferLoggerComponentBase::m_cmdResponseOut_OutputPort
Fw::OutputCmdResponsePort m_cmdResponseOut_OutputPort[NUM_CMDRESPONSEOUT_OUTPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:913
Svc::BufferLoggerComponentBase::set_cmdResponseOut_OutputPort
void set_cmdResponseOut_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputCmdResponsePort *port)
Definition: BufferLoggerComponentAc.cpp:153
Assert.hpp
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
Fw::InputComPort
Definition: ComPortAc.hpp:28
Svc::BufferLoggerComponentBase::isConnected_cmdRegOut_OutputPort
bool isConnected_cmdRegOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:838
Svc::OutputPingPort::addCallPort
void addCallPort(InputPingPort *callPort)
Definition: PingPortAc.cpp:93
Svc::BufferLoggerComponentBase::comIn_preMsgHook
virtual void comIn_preMsgHook(NATIVE_INT_TYPE portNum, Fw::ComBuffer &data, U32 context)
Definition: BufferLoggerComponentAc.cpp:2296
EightyCharString.hpp
Svc::BufferLoggerComponentBase::m_comIn_InputPort
Fw::InputComPort m_comIn_InputPort[NUM_COMIN_INPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:887
Svc::BufferLoggerComponentBase::comIn_handlerBase
void comIn_handlerBase(NATIVE_INT_TYPE portNum, Fw::ComBuffer &data, U32 context)
Definition: BufferLoggerComponentAc.cpp:2117
Fw::PassiveComponentBase
Definition: PassiveComponentBase.hpp:10
Fw::OutputLogPort::init
void init(void)
Definition: LogPortAc.cpp:107
Svc::BufferLoggerComponentBase::BL_SetLogging_preMsgHook
virtual void BL_SetLogging_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Definition: BufferLoggerComponentAc.cpp:1193
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
Svc::BufferLoggerComponentBase::get_comIn_InputPort
Fw::InputComPort * get_comIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:108
Fw::QueuedComponentBase::MSG_DISPATCH_OK
@ MSG_DISPATCH_OK
Dispatch was normal.
Definition: QueuedComponentBase.hpp:26
Svc::BufferLoggerComponentBase::EVENTID_BL_DEATIVATED
PROTECTED EVENTID_BL_DEATIVATED
Definition: BufferLoggerComponentAc.hpp:764
BufferLoggerComponentAc.hpp
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
Svc::BufferLoggerComponentBase::m_p_pingIn_in
static void m_p_pingIn_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, U32 key)
Definition: BufferLoggerComponentAc.cpp:2034
Svc::BufferLoggerComponentBase::pingOut_out
void pingOut_out(NATIVE_INT_TYPE portNum, U32 key)
Definition: BufferLoggerComponentAc.cpp:704
Svc::InputPingPort
Definition: PingPortAc.hpp:27
Fw::OutputTlmPort::addCallPort
void addCallPort(InputTlmPort *callPort)
Definition: TlmPortAc.cpp:105
Fw::TEXT_LOG_ACTIVITY_LO
@ TEXT_LOG_ACTIVITY_LO
Definition: LogTextPortAc.hpp:32
Fw::OutputCmdRegPort::invoke
void invoke(FwOpcodeType opCode)
Definition: CmdRegPortAc.cpp:103
Svc::BufferLoggerComponentBase::log_ACTIVITY_LO_BL_Activated
void log_ACTIVITY_LO_BL_Activated(void)
Definition: BufferLoggerComponentAc.cpp:1767
Svc::BufferLoggerComponentBase::m_cmdRegOut_OutputPort
Fw::OutputCmdRegPort m_cmdRegOut_OutputPort[NUM_CMDREGOUT_OUTPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:909
Fw::InputComPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: ComPortAc.cpp:42
Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT
@ ACTIVE_COMPONENT_EXIT
message to exit active component task
Definition: ActiveComponentBase.hpp:27
Svc::BufferLoggerComponentBase::pingIn_handler
virtual void pingIn_handler(NATIVE_INT_TYPE portNum, U32 key)=0
Handler for input port pingIn.
Svc::InputSchedPort
Definition: SchedPortAc.hpp:27
Fw::LOG_DIAGNOSTIC
@ LOG_DIAGNOSTIC
Definition: LogPortAc.hpp:33
Svc::BufferLoggerComponentBase::get_pingIn_InputPort
Svc::InputPingPort * get_pingIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:115
FwOpcodeType
#define FwOpcodeType
Type representation for a command opcode.
Definition: FpConfig.hpp:62
Fw::QueuedComponentBase::MsgDispatchStatus
MsgDispatchStatus
Definition: QueuedComponentBase.hpp:25
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
Svc::BufferLoggerComponentBase::m_pingIn_InputPort
Svc::InputPingPort m_pingIn_InputPort[NUM_PINGIN_INPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:891
Svc::BufferLoggerComponentBase::isConnected_eventOut_OutputPort
bool isConnected_eventOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:858
Fw::OutputTlmPort::invoke
void invoke(FwChanIdType id, Fw::Time &timeTag, TlmBuffer &val)
Definition: TlmPortAc.cpp:115
Svc::BufferLoggerComponentBase::~BufferLoggerComponentBase
virtual ~BufferLoggerComponentBase(void)
Definition: BufferLoggerComponentAc.cpp:685
Svc::BufferLoggerComponentBase::getNum_cmdIn_InputPorts
NATIVE_INT_TYPE getNum_cmdIn_InputPorts(void)
Definition: BufferLoggerComponentAc.cpp:734
Fw::CmdArgBuffer
Definition: CmdArgBuffer.hpp:22
Svc::BufferLoggerComponentBase::m_cmdIn_InputPort
Fw::InputCmdPort m_cmdIn_InputPort[NUM_CMDIN_INPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:883
Svc::BufferLoggerComponentBase::m_schedIn_InputPort
Svc::InputSchedPort m_schedIn_InputPort[NUM_SCHEDIN_INPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:895
Fw::InputBufferSendPort
Definition: BufferSendPortAc.hpp:28
Fw::OutputCmdResponsePort::init
void init(void)
Definition: CmdResponsePortAc.cpp:101
Fw::COMMAND_INVALID_OPCODE
@ COMMAND_INVALID_OPCODE
Definition: CmdResponsePortAc.hpp:26
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:9
Svc::BufferLoggerComponentBase::BL_FlushFile_preMsgHook
virtual void BL_FlushFile_preMsgHook(FwOpcodeType opCode, U32 cmdSeq)
Definition: BufferLoggerComponentAc.cpp:1263
Svc::BufferLoggerComponentBase::set_tlmOut_OutputPort
void set_tlmOut_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTlmPort *port)
Definition: BufferLoggerComponentAc.cpp:205
Svc::BufferLoggerComponentBase::get_cmdIn_InputPort
Fw::InputCmdPort * get_cmdIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:101
Svc::BufferLoggerComponentBase::getNum_pingOut_OutputPorts
NATIVE_INT_TYPE getNum_pingOut_OutputPorts(void)
Definition: BufferLoggerComponentAc.cpp:792
Fw::OutputCmdResponsePort::invoke
void invoke(FwOpcodeType opCode, U32 cmdSeq, CommandResponse response)
Definition: CmdResponsePortAc.cpp:115
Svc::BufferLoggerComponentBase::schedIn_handlerBase
void schedIn_handlerBase(NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context)
Definition: BufferLoggerComponentAc.cpp:2230
Svc::BufferLoggerComponentBase::set_cmdRegOut_OutputPort
void set_cmdRegOut_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputCmdRegPort *port)
Definition: BufferLoggerComponentAc.cpp:143
Fw::QueuedComponentBase::MSG_DISPATCH_ERROR
@ MSG_DISPATCH_ERROR
Errors dispatching messages.
Definition: QueuedComponentBase.hpp:28
Os::Queue::QUEUE_OK
@ QUEUE_OK
message sent/received okay
Definition: Queue.hpp:28
Svc::BufferLoggerComponentBase::LogState
PROTECTED LogState_MAX LogState
Definition: BufferLoggerComponentAc.hpp:610
Fw::InputComPort::init
void init(void)
initialization function
Definition: ComPortAc.cpp:38
Svc::BufferLoggerComponentBase::OPCODE_BL_SETLOGGING
PROTECTED OPCODE_BL_SETLOGGING
Definition: BufferLoggerComponentAc.hpp:621
Svc::BufferLoggerComponentBase::set_timeCaller_OutputPort
void set_timeCaller_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTimePort *port)
Definition: BufferLoggerComponentAc.cpp:195
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
Svc::BufferLoggerComponentBase::regCommands
void regCommands(void)
Register commands with the Command Dispatcher.
Definition: BufferLoggerComponentAc.cpp:309
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
Svc::BufferLoggerComponentBase::get_bufferSendIn_InputPort
Fw::InputBufferSendPort * get_bufferSendIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:94
Svc::BufferLoggerComponentBase::log_WARNING_HI_BL_LogFileWriteError
void log_WARNING_HI_BL_LogFileWriteError(U32 errornum, U32 bytesWritten, U32 bytesToWrite, Fw::LogStringArg &file)
Definition: BufferLoggerComponentAc.cpp:1625
Svc::BufferLoggerComponentBase::comIn_handler
virtual void comIn_handler(NATIVE_INT_TYPE portNum, Fw::ComBuffer &data, U32 context)=0
Handler for input port comIn.
Svc::BufferLoggerComponentBase::pingIn_handlerBase
void pingIn_handlerBase(NATIVE_INT_TYPE portNum, U32 key)
Definition: BufferLoggerComponentAc.cpp:2177
Fw::QueuedComponentBase::MSG_DISPATCH_EXIT
@ MSG_DISPATCH_EXIT
A message was sent requesting an exit of the loop.
Definition: QueuedComponentBase.hpp:29
Svc::BufferLoggerComponentBase::BL_SetLogging_cmdHandlerBase
void BL_SetLogging_cmdHandlerBase(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: BufferLoggerComponentAc.cpp:1132
Svc
Definition: ActiveLoggerComponentAc.cpp:22
Svc::BufferLoggerComponentBase::getNum_pingIn_InputPorts
NATIVE_INT_TYPE getNum_pingIn_InputPorts(void)
Definition: BufferLoggerComponentAc.cpp:784
Os::Queue::QUEUE_NONBLOCKING
@ QUEUE_NONBLOCKING
Queue receive always returns even if there is no message.
Definition: Queue.hpp:42
Svc::BufferLoggerComponentBase::args
PROTECTED U32 Fw::CmdArgBuffer & args
Definition: BufferLoggerComponentAc.hpp:712
Fw::InputCmdResponsePort
Definition: CmdResponsePortAc.hpp:37
Svc::BufferLoggerComponentBase::log_WARNING_HI_BL_LogFileValidationError
void log_WARNING_HI_BL_LogFileValidationError(Fw::LogStringArg &validationFile, U32 status)
Definition: BufferLoggerComponentAc.cpp:1519
Svc::BufferLoggerComponentBase::get_schedIn_InputPort
Svc::InputSchedPort * get_schedIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:122
Fw::InputLogPort
Definition: LogPortAc.hpp:40
Svc::BufferLoggerComponentBase::file
PROTECTED U32 const Fw::CmdStringArg & file
Definition: BufferLoggerComponentAc.hpp:637
Svc::BufferLoggerComponentBase::fwBuffer
PROTECTED Fw::Buffer & fwBuffer
Definition: BufferLoggerComponentAc.hpp:291
Svc::BufferLoggerComponentBase::m_timeCaller_OutputPort
Fw::OutputTimePort m_timeCaller_OutputPort[NUM_TIMECALLER_OUTPUT_PORTS]
Definition: BufferLoggerComponentAc.hpp:931
Svc::BufferLoggerComponentBase::set_pingOut_OutputPort
void set_pingOut_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputPingPort *port)
Definition: BufferLoggerComponentAc.cpp:185
Svc::BufferLoggerComponentBase::EVENTID_BL_LOGFILEOPENERROR
PROTECTED EVENTID_BL_LOGFILEOPENERROR
Definition: BufferLoggerComponentAc.hpp:760
Svc::BufferLoggerComponentBase::m_p_cmdIn_in
static void m_p_cmdIn_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, FwOpcodeType opCode, U32 cmdSeq, Fw::CmdArgBuffer &args)
Definition: BufferLoggerComponentAc.cpp:914
FwEventIdType
#define FwEventIdType
Type representation for a event id.
Definition: FpConfig.hpp:70
Fw::LOG_ACTIVITY_LO
@ LOG_ACTIVITY_LO
Definition: LogPortAc.hpp:32
cmdPort
BYTE cmdPort[Fw::InputCmdPort::SERIALIZED_SIZE]
Definition: BufferLoggerComponentAc.cpp:49
Svc::BufferLoggerComponentBase
Auto-generated base for BufferLogger component.
Definition: BufferLoggerComponentAc.hpp:51
NATIVE_INT_TYPE
int NATIVE_INT_TYPE
native integer type declaration
Definition: BasicTypes.hpp:29
Svc::BufferLoggerComponentBase::schedIn_handler
virtual void schedIn_handler(NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context)=0
Handler for input port schedIn.
Svc::BufferLoggerComponentBase::getNum_eventOut_OutputPorts
NATIVE_INT_TYPE getNum_eventOut_OutputPorts(void)
Definition: BufferLoggerComponentAc.cpp:766
AssertArg
#define AssertArg
Definition: FpConfig.hpp:51
Fw::ComBuffer
Definition: ComBuffer.hpp:21
Svc::BufferLoggerComponentBase::log_ACTIVITY_LO_BL_Deativated
void log_ACTIVITY_LO_BL_Deativated(void)
Definition: BufferLoggerComponentAc.cpp:1846
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
Svc::BufferLoggerComponentBase::schedIn_preMsgHook
virtual void schedIn_preMsgHook(NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context)
Definition: BufferLoggerComponentAc.cpp:2314
Fw::InputCmdPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: CmdPortAc.hpp:31
Svc::BufferLoggerComponentBase::BL_SetLogging_cmdHandler
virtual void BL_SetLogging_cmdHandler(FwOpcodeType opCode, U32 cmdSeq, LogState state)=0
Handler for command BL_SetLogging.
Fw
Definition: BufferGetPortAc.cpp:6
Svc::BufferLoggerComponentBase::EVENTID_BL_LOGFILEVALIDATIONERROR
PROTECTED EVENTID_BL_LOGFILEVALIDATIONERROR
Definition: BufferLoggerComponentAc.hpp:761
Fw::OutputTimePort::addCallPort
void addCallPort(InputTimePort *callPort)
Definition: TimePortAc.cpp:93
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::BufferLoggerComponentBase::getNum_schedIn_InputPorts
NATIVE_INT_TYPE getNum_schedIn_InputPorts(void)
Definition: BufferLoggerComponentAc.cpp:808
Fw::InputLogTextPort
Definition: LogTextPortAc.hpp:40
port3
BYTE port3[Svc::InputPingPort::SERIALIZED_SIZE]
Definition: BufferLoggerComponentAc.cpp:47
Svc::BufferLoggerComponentBase::isConnected_timeCaller_OutputPort
bool isConnected_timeCaller_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BufferLoggerComponentAc.cpp:890
Svc::InputPingPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: PingPortAc.cpp:42