F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
FprimeDeframerComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title FprimeDeframerComponentAc.cpp
3 // \author Generated by fpp-to-cpp
4 // \brief cpp file for FprimeDeframer component base class
5 // ======================================================================
6 
8 #include "Fw/Types/Assert.hpp"
10 #if FW_ENABLE_TEXT_LOGGING
11 #include "Fw/Types/String.hpp"
12 #endif
13 
14 namespace Svc {
15 
16  // ----------------------------------------------------------------------
17  // Component initialization
18  // ----------------------------------------------------------------------
19 
22  {
23  // Initialize base class
25 
26  // Connect input port framedIn
27  for (
28  FwIndexType port = 0;
29  port < static_cast<FwIndexType>(this->getNum_framedIn_InputPorts());
30  port++
31  ) {
32  this->m_framedIn_InputPort[port].init();
33  this->m_framedIn_InputPort[port].addCallComp(
34  this,
35  m_p_framedIn_in
36  );
37  this->m_framedIn_InputPort[port].setPortNum(port);
38 
39 #if FW_OBJECT_NAMES == 1
40  Fw::ObjectName portName;
41  portName.format(
42  "%s_framedIn_InputPort[%" PRI_PlatformIntType "]",
43  this->m_objName.toChar(),
44  port
45  );
46  this->m_framedIn_InputPort[port].setObjName(portName.toChar());
47 #endif
48  }
49 
50  // Connect output port logOut
51  for (
52  FwIndexType port = 0;
53  port < static_cast<FwIndexType>(this->getNum_logOut_OutputPorts());
54  port++
55  ) {
56  this->m_logOut_OutputPort[port].init();
57 
58 #if FW_OBJECT_NAMES == 1
59  Fw::ObjectName portName;
60  portName.format(
61  "%s_logOut_OutputPort[%" PRI_PlatformIntType "]",
62  this->m_objName.toChar(),
63  port
64  );
65  this->m_logOut_OutputPort[port].setObjName(portName.toChar());
66 #endif
67  }
68 
69 #if FW_ENABLE_TEXT_LOGGING == 1
70  // Connect output port logTextOut
71  for (
72  FwIndexType port = 0;
73  port < static_cast<FwIndexType>(this->getNum_logTextOut_OutputPorts());
74  port++
75  ) {
76  this->m_logTextOut_OutputPort[port].init();
77 
78 #if FW_OBJECT_NAMES == 1
79  Fw::ObjectName portName;
80  portName.format(
81  "%s_logTextOut_OutputPort[%" PRI_PlatformIntType "]",
82  this->m_objName.toChar(),
83  port
84  );
85  this->m_logTextOut_OutputPort[port].setObjName(portName.toChar());
86 #endif
87  }
88 #endif
89 
90  // Connect output port timeCaller
91  for (
92  FwIndexType port = 0;
93  port < static_cast<FwIndexType>(this->getNum_timeCaller_OutputPorts());
94  port++
95  ) {
96  this->m_timeCaller_OutputPort[port].init();
97 
98 #if FW_OBJECT_NAMES == 1
99  Fw::ObjectName portName;
100  portName.format(
101  "%s_timeCaller_OutputPort[%" PRI_PlatformIntType "]",
102  this->m_objName.toChar(),
103  port
104  );
105  this->m_timeCaller_OutputPort[port].setObjName(portName.toChar());
106 #endif
107  }
108 
109  // Connect output port bufferDeallocate
110  for (
111  FwIndexType port = 0;
112  port < static_cast<FwIndexType>(this->getNum_bufferDeallocate_OutputPorts());
113  port++
114  ) {
115  this->m_bufferDeallocate_OutputPort[port].init();
116 
117 #if FW_OBJECT_NAMES == 1
118  Fw::ObjectName portName;
119  portName.format(
120  "%s_bufferDeallocate_OutputPort[%" PRI_PlatformIntType "]",
121  this->m_objName.toChar(),
122  port
123  );
124  this->m_bufferDeallocate_OutputPort[port].setObjName(portName.toChar());
125 #endif
126  }
127 
128  // Connect output port deframedOut
129  for (
130  FwIndexType port = 0;
131  port < static_cast<FwIndexType>(this->getNum_deframedOut_OutputPorts());
132  port++
133  ) {
134  this->m_deframedOut_OutputPort[port].init();
135 
136 #if FW_OBJECT_NAMES == 1
137  Fw::ObjectName portName;
138  portName.format(
139  "%s_deframedOut_OutputPort[%" PRI_PlatformIntType "]",
140  this->m_objName.toChar(),
141  port
142  );
143  this->m_deframedOut_OutputPort[port].setObjName(portName.toChar());
144 #endif
145  }
146  }
147 
148  // ----------------------------------------------------------------------
149  // Getters for typed input ports
150  // ----------------------------------------------------------------------
151 
154  {
155  FW_ASSERT(
156  portNum < this->getNum_framedIn_InputPorts(),
157  static_cast<FwAssertArgType>(portNum)
158  );
159 
160  return &this->m_framedIn_InputPort[portNum];
161  }
162 
163  // ----------------------------------------------------------------------
164  // Connect input ports to special output ports
165  // ----------------------------------------------------------------------
166 
169  FwIndexType portNum,
170  Fw::InputLogPort* port
171  )
172  {
173  FW_ASSERT(
174  portNum < this->getNum_logOut_OutputPorts(),
175  static_cast<FwAssertArgType>(portNum)
176  );
177 
178  this->m_logOut_OutputPort[portNum].addCallPort(port);
179  }
180 
181 #if FW_ENABLE_TEXT_LOGGING == 1
182 
183  void FprimeDeframerComponentBase ::
184  set_logTextOut_OutputPort(
185  FwIndexType portNum,
187  )
188  {
189  FW_ASSERT(
190  portNum < this->getNum_logTextOut_OutputPorts(),
191  static_cast<FwAssertArgType>(portNum)
192  );
193 
194  this->m_logTextOut_OutputPort[portNum].addCallPort(port);
195  }
196 
197 #endif
198 
201  FwIndexType portNum,
202  Fw::InputTimePort* port
203  )
204  {
205  FW_ASSERT(
206  portNum < this->getNum_timeCaller_OutputPorts(),
207  static_cast<FwAssertArgType>(portNum)
208  );
209 
210  this->m_timeCaller_OutputPort[portNum].addCallPort(port);
211  }
212 
213  // ----------------------------------------------------------------------
214  // Connect typed input ports to typed output ports
215  // ----------------------------------------------------------------------
216 
219  FwIndexType portNum,
221  )
222  {
223  FW_ASSERT(
224  portNum < this->getNum_bufferDeallocate_OutputPorts(),
225  static_cast<FwAssertArgType>(portNum)
226  );
227 
228  this->m_bufferDeallocate_OutputPort[portNum].addCallPort(port);
229  }
230 
233  FwIndexType portNum,
235  )
236  {
237  FW_ASSERT(
238  portNum < this->getNum_deframedOut_OutputPorts(),
239  static_cast<FwAssertArgType>(portNum)
240  );
241 
242  this->m_deframedOut_OutputPort[portNum].addCallPort(port);
243  }
244 
245 #if FW_PORT_SERIALIZATION
246 
247  // ----------------------------------------------------------------------
248  // Connect serial input ports to special output ports
249  // ----------------------------------------------------------------------
250 
253  FwIndexType portNum,
254  Fw::InputSerializePort* port
255  )
256  {
257  FW_ASSERT(
258  portNum < this->getNum_logOut_OutputPorts(),
259  static_cast<FwAssertArgType>(portNum)
260  );
261 
262  this->m_logOut_OutputPort[portNum].registerSerialPort(port);
263  }
264 
265 #if FW_ENABLE_TEXT_LOGGING == 1
266 
267  void FprimeDeframerComponentBase ::
268  set_logTextOut_OutputPort(
269  FwIndexType portNum,
270  Fw::InputSerializePort* port
271  )
272  {
273  FW_ASSERT(
274  portNum < this->getNum_logTextOut_OutputPorts(),
275  static_cast<FwAssertArgType>(portNum)
276  );
277 
278  this->m_logTextOut_OutputPort[portNum].registerSerialPort(port);
279  }
280 
281 #endif
282 
285  FwIndexType portNum,
286  Fw::InputSerializePort* port
287  )
288  {
289  FW_ASSERT(
290  portNum < this->getNum_timeCaller_OutputPorts(),
291  static_cast<FwAssertArgType>(portNum)
292  );
293 
294  this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
295  }
296 
297 #endif
298 
299 #if FW_PORT_SERIALIZATION
300 
301  // ----------------------------------------------------------------------
302  // Connect serial input ports to typed output ports
303  // ----------------------------------------------------------------------
304 
307  FwIndexType portNum,
308  Fw::InputSerializePort* port
309  )
310  {
311  FW_ASSERT(
312  portNum < this->getNum_bufferDeallocate_OutputPorts(),
313  static_cast<FwAssertArgType>(portNum)
314  );
315 
316  this->m_bufferDeallocate_OutputPort[portNum].registerSerialPort(port);
317  }
318 
321  FwIndexType portNum,
322  Fw::InputSerializePort* port
323  )
324  {
325  FW_ASSERT(
326  portNum < this->getNum_deframedOut_OutputPorts(),
327  static_cast<FwAssertArgType>(portNum)
328  );
329 
330  this->m_deframedOut_OutputPort[portNum].registerSerialPort(port);
331  }
332 
333 #endif
334 
335  // ----------------------------------------------------------------------
336  // Component construction and destruction
337  // ----------------------------------------------------------------------
338 
340  FprimeDeframerComponentBase(const char* compName) :
341  Fw::PassiveComponentBase(compName)
342  {
343 
344  }
345 
348  {
349 
350  }
351 
352  // ----------------------------------------------------------------------
353  // Getters for numbers of typed input ports
354  // ----------------------------------------------------------------------
355 
358  {
359  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_framedIn_InputPort));
360  }
361 
362  // ----------------------------------------------------------------------
363  // Getters for numbers of special output ports
364  // ----------------------------------------------------------------------
365 
368  {
369  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_logOut_OutputPort));
370  }
371 
372 #if FW_ENABLE_TEXT_LOGGING == 1
373 
374  FwIndexType FprimeDeframerComponentBase ::
375  getNum_logTextOut_OutputPorts() const
376  {
377  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_logTextOut_OutputPort));
378  }
379 
380 #endif
381 
384  {
385  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_timeCaller_OutputPort));
386  }
387 
388  // ----------------------------------------------------------------------
389  // Getters for numbers of typed output ports
390  // ----------------------------------------------------------------------
391 
394  {
395  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_bufferDeallocate_OutputPort));
396  }
397 
400  {
401  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_deframedOut_OutputPort));
402  }
403 
404  // ----------------------------------------------------------------------
405  // Connection status queries for special output ports
406  // ----------------------------------------------------------------------
407 
410  {
411  FW_ASSERT(
412  portNum < this->getNum_logOut_OutputPorts(),
413  static_cast<FwAssertArgType>(portNum)
414  );
415 
416  return this->m_logOut_OutputPort[portNum].isConnected();
417  }
418 
419 #if FW_ENABLE_TEXT_LOGGING == 1
420 
421  bool FprimeDeframerComponentBase ::
422  isConnected_logTextOut_OutputPort(FwIndexType portNum)
423  {
424  FW_ASSERT(
425  portNum < this->getNum_logTextOut_OutputPorts(),
426  static_cast<FwAssertArgType>(portNum)
427  );
428 
429  return this->m_logTextOut_OutputPort[portNum].isConnected();
430  }
431 
432 #endif
433 
436  {
437  FW_ASSERT(
438  portNum < this->getNum_timeCaller_OutputPorts(),
439  static_cast<FwAssertArgType>(portNum)
440  );
441 
442  return this->m_timeCaller_OutputPort[portNum].isConnected();
443  }
444 
445  // ----------------------------------------------------------------------
446  // Connection status queries for typed output ports
447  // ----------------------------------------------------------------------
448 
451  {
452  FW_ASSERT(
453  portNum < this->getNum_bufferDeallocate_OutputPorts(),
454  static_cast<FwAssertArgType>(portNum)
455  );
456 
457  return this->m_bufferDeallocate_OutputPort[portNum].isConnected();
458  }
459 
462  {
463  FW_ASSERT(
464  portNum < this->getNum_deframedOut_OutputPorts(),
465  static_cast<FwAssertArgType>(portNum)
466  );
467 
468  return this->m_deframedOut_OutputPort[portNum].isConnected();
469  }
470 
471  // ----------------------------------------------------------------------
472  // Port handler base-class functions for typed input ports
473  //
474  // Call these functions directly to bypass the corresponding ports
475  // ----------------------------------------------------------------------
476 
479  FwIndexType portNum,
480  Fw::Buffer& data,
481  Fw::Buffer& context
482  )
483  {
484  // Make sure port number is valid
485  FW_ASSERT(
486  portNum < this->getNum_framedIn_InputPorts(),
487  static_cast<FwAssertArgType>(portNum)
488  );
489 
490  // Lock guard mutex before calling
491  this->lock();
492 
493  // Call handler function
494  this->framedIn_handler(
495  portNum,
496  data,
497  context
498  );
499 
500  // Unlock guard mutex
501  this->unLock();
502  }
503 
504  // ----------------------------------------------------------------------
505  // Invocation functions for typed output ports
506  // ----------------------------------------------------------------------
507 
510  FwIndexType portNum,
511  Fw::Buffer& fwBuffer
512  )
513  {
514  FW_ASSERT(
515  portNum < this->getNum_bufferDeallocate_OutputPorts(),
516  static_cast<FwAssertArgType>(portNum)
517  );
518 
519  FW_ASSERT(
520  this->m_bufferDeallocate_OutputPort[portNum].isConnected(),
521  static_cast<FwAssertArgType>(portNum)
522  );
523  this->m_bufferDeallocate_OutputPort[portNum].invoke(
524  fwBuffer
525  );
526  }
527 
530  FwIndexType portNum,
531  Fw::Buffer& data,
532  Fw::Buffer& context
533  )
534  {
535  FW_ASSERT(
536  portNum < this->getNum_deframedOut_OutputPorts(),
537  static_cast<FwAssertArgType>(portNum)
538  );
539 
540  FW_ASSERT(
541  this->m_deframedOut_OutputPort[portNum].isConnected(),
542  static_cast<FwAssertArgType>(portNum)
543  );
544  this->m_deframedOut_OutputPort[portNum].invoke(
545  data,
546  context
547  );
548  }
549 
550  // ----------------------------------------------------------------------
551  // Event logging functions
552  // ----------------------------------------------------------------------
553 
556  {
557  // Get the time
558  Fw::Time _logTime;
559  if (this->m_timeCaller_OutputPort[0].isConnected()) {
560  this->m_timeCaller_OutputPort[0].invoke(_logTime);
561  }
562 
563  FwEventIdType _id = static_cast<FwEventIdType>(0);
564 
566 
567  // Emit the event on the log port
568  if (this->m_logOut_OutputPort[0].isConnected()) {
569  Fw::LogBuffer _logBuff;
570 
571 #if FW_AMPCS_COMPATIBLE
573  // Serialize the number of arguments
574  _status = _logBuff.serialize(static_cast<U8>(0));
575  FW_ASSERT(
576  _status == Fw::FW_SERIALIZE_OK,
577  static_cast<FwAssertArgType>(_status)
578  );
579 #endif
580 
581  this->m_logOut_OutputPort[0].invoke(
582  _id,
583  _logTime,
585  _logBuff
586  );
587  }
588 
589  // Emit the event on the text log port
590 #if FW_ENABLE_TEXT_LOGGING
591  if (this->m_logTextOut_OutputPort[0].isConnected()) {
592 #if FW_OBJECT_NAMES == 1
593  const char* _formatString =
594  "(%s) %s: Frame dropped: The received buffer is not long enough to contain a valid frame (header + trailer)";
595 #else
596  const char* _formatString =
597  "%s: Frame dropped: The received buffer is not long enough to contain a valid frame (header + trailer)";
598 #endif
599 
600  Fw::TextLogString _logString;
601  _logString.format(
602  _formatString,
603 #if FW_OBJECT_NAMES == 1
604  this->m_objName.toChar(),
605 #endif
606  "InvalidBufferReceived "
607  );
608 
609  this->m_logTextOut_OutputPort[0].invoke(
610  _id,
611  _logTime,
613  _logString
614  );
615  }
616 #endif
617  }
618 
621  {
622  // Get the time
623  Fw::Time _logTime;
624  if (this->m_timeCaller_OutputPort[0].isConnected()) {
625  this->m_timeCaller_OutputPort[0].invoke(_logTime);
626  }
627 
628  FwEventIdType _id = static_cast<FwEventIdType>(0);
629 
630  _id = this->getIdBase() + EVENTID_INVALIDSTARTWORD;
631 
632  // Emit the event on the log port
633  if (this->m_logOut_OutputPort[0].isConnected()) {
634  Fw::LogBuffer _logBuff;
635 
636 #if FW_AMPCS_COMPATIBLE
638  // Serialize the number of arguments
639  _status = _logBuff.serialize(static_cast<U8>(0));
640  FW_ASSERT(
641  _status == Fw::FW_SERIALIZE_OK,
642  static_cast<FwAssertArgType>(_status)
643  );
644 #endif
645 
646  this->m_logOut_OutputPort[0].invoke(
647  _id,
648  _logTime,
650  _logBuff
651  );
652  }
653 
654  // Emit the event on the text log port
655 #if FW_ENABLE_TEXT_LOGGING
656  if (this->m_logTextOut_OutputPort[0].isConnected()) {
657 #if FW_OBJECT_NAMES == 1
658  const char* _formatString =
659  "(%s) %s: Frame dropped: The received buffer does not start with the F Prime start word";
660 #else
661  const char* _formatString =
662  "%s: Frame dropped: The received buffer does not start with the F Prime start word";
663 #endif
664 
665  Fw::TextLogString _logString;
666  _logString.format(
667  _formatString,
668 #if FW_OBJECT_NAMES == 1
669  this->m_objName.toChar(),
670 #endif
671  "InvalidStartWord "
672  );
673 
674  this->m_logTextOut_OutputPort[0].invoke(
675  _id,
676  _logTime,
678  _logString
679  );
680  }
681 #endif
682  }
683 
686  {
687  // Get the time
688  Fw::Time _logTime;
689  if (this->m_timeCaller_OutputPort[0].isConnected()) {
690  this->m_timeCaller_OutputPort[0].invoke(_logTime);
691  }
692 
693  FwEventIdType _id = static_cast<FwEventIdType>(0);
694 
696 
697  // Emit the event on the log port
698  if (this->m_logOut_OutputPort[0].isConnected()) {
699  Fw::LogBuffer _logBuff;
700 
701 #if FW_AMPCS_COMPATIBLE
703  // Serialize the number of arguments
704  _status = _logBuff.serialize(static_cast<U8>(0));
705  FW_ASSERT(
706  _status == Fw::FW_SERIALIZE_OK,
707  static_cast<FwAssertArgType>(_status)
708  );
709 #endif
710 
711  this->m_logOut_OutputPort[0].invoke(
712  _id,
713  _logTime,
715  _logBuff
716  );
717  }
718 
719  // Emit the event on the text log port
720 #if FW_ENABLE_TEXT_LOGGING
721  if (this->m_logTextOut_OutputPort[0].isConnected()) {
722 #if FW_OBJECT_NAMES == 1
723  const char* _formatString =
724  "(%s) %s: Frame dropped: The received buffer size cannot hold a frame of specified payload length";
725 #else
726  const char* _formatString =
727  "%s: Frame dropped: The received buffer size cannot hold a frame of specified payload length";
728 #endif
729 
730  Fw::TextLogString _logString;
731  _logString.format(
732  _formatString,
733 #if FW_OBJECT_NAMES == 1
734  this->m_objName.toChar(),
735 #endif
736  "InvalidLengthReceived "
737  );
738 
739  this->m_logTextOut_OutputPort[0].invoke(
740  _id,
741  _logTime,
743  _logString
744  );
745  }
746 #endif
747  }
748 
751  {
752  // Get the time
753  Fw::Time _logTime;
754  if (this->m_timeCaller_OutputPort[0].isConnected()) {
755  this->m_timeCaller_OutputPort[0].invoke(_logTime);
756  }
757 
758  FwEventIdType _id = static_cast<FwEventIdType>(0);
759 
760  _id = this->getIdBase() + EVENTID_INVALIDCHECKSUM;
761 
762  // Emit the event on the log port
763  if (this->m_logOut_OutputPort[0].isConnected()) {
764  Fw::LogBuffer _logBuff;
765 
766 #if FW_AMPCS_COMPATIBLE
768  // Serialize the number of arguments
769  _status = _logBuff.serialize(static_cast<U8>(0));
770  FW_ASSERT(
771  _status == Fw::FW_SERIALIZE_OK,
772  static_cast<FwAssertArgType>(_status)
773  );
774 #endif
775 
776  this->m_logOut_OutputPort[0].invoke(
777  _id,
778  _logTime,
780  _logBuff
781  );
782  }
783 
784  // Emit the event on the text log port
785 #if FW_ENABLE_TEXT_LOGGING
786  if (this->m_logTextOut_OutputPort[0].isConnected()) {
787 #if FW_OBJECT_NAMES == 1
788  const char* _formatString =
789  "(%s) %s: Frame dropped: The transmitted frame checksum does not match that computed by the receiver";
790 #else
791  const char* _formatString =
792  "%s: Frame dropped: The transmitted frame checksum does not match that computed by the receiver";
793 #endif
794 
795  Fw::TextLogString _logString;
796  _logString.format(
797  _formatString,
798 #if FW_OBJECT_NAMES == 1
799  this->m_objName.toChar(),
800 #endif
801  "InvalidChecksum "
802  );
803 
804  this->m_logTextOut_OutputPort[0].invoke(
805  _id,
806  _logTime,
808  _logString
809  );
810  }
811 #endif
812  }
813 
814  // ----------------------------------------------------------------------
815  // Time
816  // ----------------------------------------------------------------------
817 
820  {
821  if (this->m_timeCaller_OutputPort[0].isConnected()) {
822  Fw::Time _time;
823  this->m_timeCaller_OutputPort[0].invoke(_time);
824  return _time;
825  }
826  else {
827  return Fw::Time(TB_NONE, 0, 0);
828  }
829  }
830 
831  // ----------------------------------------------------------------------
832  // Mutex operations for guarded ports
833  //
834  // You can override these operations to provide more sophisticated
835  // synchronization
836  // ----------------------------------------------------------------------
837 
840  {
841  this->m_guardedPortMutex.lock();
842  }
843 
846  {
847  this->m_guardedPortMutex.unLock();
848  }
849 
850  // ----------------------------------------------------------------------
851  // Calls for messages received on typed input ports
852  // ----------------------------------------------------------------------
853 
854  void FprimeDeframerComponentBase ::
855  m_p_framedIn_in(
856  Fw::PassiveComponentBase* callComp,
857  FwIndexType portNum,
858  Fw::Buffer& data,
859  Fw::Buffer& context
860  )
861  {
862  FW_ASSERT(callComp);
863  FprimeDeframerComponentBase* compPtr = static_cast<FprimeDeframerComponentBase*>(callComp);
864  compPtr->framedIn_handlerBase(
865  portNum,
866  data,
867  context
868  );
869  }
870 
871 }
Serialization/Deserialization operation was successful.
bool isConnected_logOut_OutputPort(FwIndexType portNum)
void addCallPort(InputTimePort *callPort)
Register an input port.
Definition: TimePortAc.cpp:134
Definition: Time.hpp:9
bool isConnected_bufferDeallocate_OutputPort(FwIndexType portNum)
void addCallPort(InputDataWithContextPort *callPort)
Register an input port.
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
Register a component.
bool isConnected_deframedOut_OutputPort(FwIndexType portNum)
void framedIn_handlerBase(FwIndexType portNum, Fw::Buffer &data, Fw::Buffer &context)
Handler base-class function for input port framedIn.
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
void init()
Initialization function.
void unLock()
unlock the mutex and assert success
Definition: Mutex.cpp:40
void set_deframedOut_OutputPort(FwIndexType portNum, Fw::InputDataWithContextPort *port)
Connect port to deframedOut[portNum].
An invalid frame was received (checksum mismatch)
An invalid frame was received (too short to be a frame)
I32 FwEnumStoreType
Definition: FpConfig.h:64
PlatformIndexType FwIndexType
Definition: FpConfig.h:25
void init()
Object initializer.
Definition: ObjBase.cpp:26
SerializeStatus
forward declaration for string
void bufferDeallocate_out(FwIndexType portNum, Fw::Buffer &fwBuffer)
Invoke output port bufferDeallocate.
FprimeDeframerComponentBase(const char *compName="")
Construct FprimeDeframerComponentBase object.
void init()
Initialization function.
Definition: TimePortAc.cpp:128
void invoke(Fw::Buffer &fwBuffer) const
Invoke a port interface.
void addCallPort(InputBufferSendPort *callPort)
Register an input port.
void invoke(Fw::Time &time) const
Invoke a port interface.
Definition: TimePortAc.cpp:147
const char * toChar() const
Definition: ObjectName.hpp:50
No time base has been established.
Definition: FpConfig.h:70
void set_bufferDeallocate_OutputPort(FwIndexType portNum, Fw::InputBufferSendPort *port)
Connect port to bufferDeallocate[portNum].
Auto-generated base for FprimeDeframer component.
void invoke(Fw::Buffer &data, Fw::Buffer &context) const
Invoke a port interface.
A serious but recoverable event.
void set_timeCaller_OutputPort(FwIndexType portNum, Fw::InputTimePort *port)
Connect port to timeCaller[portNum].
bool isConnected() const
Definition: PortBase.cpp:42
U32 FwEventIdType
Definition: FpConfig.h:103
FormatStatus format(const CHAR *formatString,...)
write formatted string to buffer
Definition: StringBase.cpp:55
void init()
Initialization function.
Definition: LogPortAc.cpp:151
An invalid frame was received (start word is wrong)
void setPortNum(FwIndexType portNum)
virtual ~FprimeDeframerComponentBase()
Destroy FprimeDeframerComponentBase object.
virtual void lock()
Lock the guarded mutex.
void init()
Initialization function.
void invoke(FwEventIdType id, Fw::Time &timeTag, const Fw::LogSeverity &severity, Fw::LogBuffer &args) const
Invoke a port interface.
Definition: LogPortAc.cpp:170
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition: BasicTypes.h:85
void addCallPort(InputLogPort *callPort)
Register an input port.
Definition: LogPortAc.cpp:157
bool isConnected_timeCaller_OutputPort(FwIndexType portNum)
void deframedOut_out(FwIndexType portNum, Fw::Buffer &data, Fw::Buffer &context)
Invoke output port deframedOut.
Fw::InputDataWithContextPort * get_framedIn_InputPort(FwIndexType portNum)
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects) ...
Definition: FpConfig.h:148
#define FW_ASSERT(...)
Definition: Assert.hpp:14
void init()
Initialization function.
void set_logOut_OutputPort(FwIndexType portNum, Fw::InputLogPort *port)
Connect port to logOut[portNum].
virtual void framedIn_handler(FwIndexType portNum, Fw::Buffer &data, Fw::Buffer &context)=0
Handler for input port framedIn.
virtual void unLock()
Unlock the guarded mutex.
void lock()
lock the mutex and assert success
Definition: Mutex.cpp:34