F´ Flight Software - C/C++ Documentation devel
A framework for building embedded system applications to NASA flight quality standards.
Loading...
Searching...
No Matches
StreamCrossoverComponentAc.cpp
Go to the documentation of this file.
1// ======================================================================
2// \title StreamCrossoverComponentAc.cpp
3// \author Generated by fpp-to-cpp
4// \brief cpp file for StreamCrossover component base class
5// ======================================================================
6
7#include <cstdio>
8
10#include "Fw/Types/Assert.hpp"
11#if FW_ENABLE_TEXT_LOGGING
12#include "Fw/Types/String.hpp"
13#endif
14
15namespace Drv {
16
17 // ----------------------------------------------------------------------
18 // Component initialization
19 // ----------------------------------------------------------------------
20
21 void StreamCrossoverComponentBase ::
22 init(NATIVE_INT_TYPE instance)
23 {
24 // Initialize base class
26
27 // Connect input port streamIn
28 for (
29 PlatformIntType port = 0;
30 port < static_cast<PlatformIntType>(this->getNum_streamIn_InputPorts());
31 port++
32 ) {
33 this->m_streamIn_InputPort[port].init();
34 this->m_streamIn_InputPort[port].addCallComp(
35 this,
36 m_p_streamIn_in
37 );
38 this->m_streamIn_InputPort[port].setPortNum(port);
39
40#if FW_OBJECT_NAMES == 1
41 // The port name consists of this->m_objName and some extra info.
42 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
43 // However, the compiler may assume that this->m_objName fills
44 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
45 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
46 // bytes to cover the extra info.
47 char portName[2*FW_OBJ_NAME_MAX_SIZE];
48 (void) snprintf(
49 portName,
50 sizeof(portName),
51 "%s_streamIn_InputPort[%" PRI_PlatformIntType "]",
52 this->m_objName,
53 port
54 );
55 this->m_streamIn_InputPort[port].setObjName(portName);
56#endif
57 }
58
59 // Connect output port logOut
60 for (
61 PlatformIntType port = 0;
62 port < static_cast<PlatformIntType>(this->getNum_logOut_OutputPorts());
63 port++
64 ) {
65 this->m_logOut_OutputPort[port].init();
66
67#if FW_OBJECT_NAMES == 1
68 // The port name consists of this->m_objName and some extra info.
69 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
70 // However, the compiler may assume that this->m_objName fills
71 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
72 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
73 // bytes to cover the extra info.
74 char portName[2*FW_OBJ_NAME_MAX_SIZE];
75 (void) snprintf(
76 portName,
77 sizeof(portName),
78 "%s_logOut_OutputPort[%" PRI_PlatformIntType "]",
79 this->m_objName,
80 port
81 );
82 this->m_logOut_OutputPort[port].setObjName(portName);
83#endif
84 }
85
86#if FW_ENABLE_TEXT_LOGGING == 1
87 // Connect output port logTextOut
88 for (
89 PlatformIntType port = 0;
90 port < static_cast<PlatformIntType>(this->getNum_logTextOut_OutputPorts());
91 port++
92 ) {
93 this->m_logTextOut_OutputPort[port].init();
94
95#if FW_OBJECT_NAMES == 1
96 // The port name consists of this->m_objName and some extra info.
97 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
98 // However, the compiler may assume that this->m_objName fills
99 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
100 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
101 // bytes to cover the extra info.
102 char portName[2*FW_OBJ_NAME_MAX_SIZE];
103 (void) snprintf(
104 portName,
105 sizeof(portName),
106 "%s_logTextOut_OutputPort[%" PRI_PlatformIntType "]",
107 this->m_objName,
108 port
109 );
110 this->m_logTextOut_OutputPort[port].setObjName(portName);
111#endif
112 }
113#endif
114
115 // Connect output port timeCaller
116 for (
117 PlatformIntType port = 0;
118 port < static_cast<PlatformIntType>(this->getNum_timeCaller_OutputPorts());
119 port++
120 ) {
121 this->m_timeCaller_OutputPort[port].init();
122
123#if FW_OBJECT_NAMES == 1
124 // The port name consists of this->m_objName and some extra info.
125 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
126 // However, the compiler may assume that this->m_objName fills
127 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
128 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
129 // bytes to cover the extra info.
130 char portName[2*FW_OBJ_NAME_MAX_SIZE];
131 (void) snprintf(
132 portName,
133 sizeof(portName),
134 "%s_timeCaller_OutputPort[%" PRI_PlatformIntType "]",
135 this->m_objName,
136 port
137 );
138 this->m_timeCaller_OutputPort[port].setObjName(portName);
139#endif
140 }
141
142 // Connect output port errorDeallocate
143 for (
144 PlatformIntType port = 0;
145 port < static_cast<PlatformIntType>(this->getNum_errorDeallocate_OutputPorts());
146 port++
147 ) {
148 this->m_errorDeallocate_OutputPort[port].init();
149
150#if FW_OBJECT_NAMES == 1
151 // The port name consists of this->m_objName and some extra info.
152 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
153 // However, the compiler may assume that this->m_objName fills
154 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
155 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
156 // bytes to cover the extra info.
157 char portName[2*FW_OBJ_NAME_MAX_SIZE];
158 (void) snprintf(
159 portName,
160 sizeof(portName),
161 "%s_errorDeallocate_OutputPort[%" PRI_PlatformIntType "]",
162 this->m_objName,
163 port
164 );
165 this->m_errorDeallocate_OutputPort[port].setObjName(portName);
166#endif
167 }
168
169 // Connect output port streamOut
170 for (
171 PlatformIntType port = 0;
172 port < static_cast<PlatformIntType>(this->getNum_streamOut_OutputPorts());
173 port++
174 ) {
175 this->m_streamOut_OutputPort[port].init();
176
177#if FW_OBJECT_NAMES == 1
178 // The port name consists of this->m_objName and some extra info.
179 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
180 // However, the compiler may assume that this->m_objName fills
181 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
182 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
183 // bytes to cover the extra info.
184 char portName[2*FW_OBJ_NAME_MAX_SIZE];
185 (void) snprintf(
186 portName,
187 sizeof(portName),
188 "%s_streamOut_OutputPort[%" PRI_PlatformIntType "]",
189 this->m_objName,
190 port
191 );
192 this->m_streamOut_OutputPort[port].setObjName(portName);
193#endif
194 }
195 }
196
197 // ----------------------------------------------------------------------
198 // Getters for typed input ports
199 // ----------------------------------------------------------------------
200
201 Drv::InputByteStreamRecvPort* StreamCrossoverComponentBase ::
202 get_streamIn_InputPort(NATIVE_INT_TYPE portNum)
203 {
204 FW_ASSERT(
205 portNum < this->getNum_streamIn_InputPorts(),
206 static_cast<FwAssertArgType>(portNum)
207 );
208
209 return &this->m_streamIn_InputPort[portNum];
210 }
211
212 // ----------------------------------------------------------------------
213 // Connect input ports to special output ports
214 // ----------------------------------------------------------------------
215
216 void StreamCrossoverComponentBase ::
217 set_logOut_OutputPort(
218 NATIVE_INT_TYPE portNum,
219 Fw::InputLogPort* port
220 )
221 {
222 FW_ASSERT(
223 portNum < this->getNum_logOut_OutputPorts(),
224 static_cast<FwAssertArgType>(portNum)
225 );
226
227 this->m_logOut_OutputPort[portNum].addCallPort(port);
228 }
229
230#if FW_ENABLE_TEXT_LOGGING == 1
231
232 void StreamCrossoverComponentBase ::
233 set_logTextOut_OutputPort(
234 NATIVE_INT_TYPE portNum,
236 )
237 {
238 FW_ASSERT(
239 portNum < this->getNum_logTextOut_OutputPorts(),
240 static_cast<FwAssertArgType>(portNum)
241 );
242
243 this->m_logTextOut_OutputPort[portNum].addCallPort(port);
244 }
245
246#endif
247
248 void StreamCrossoverComponentBase ::
249 set_timeCaller_OutputPort(
250 NATIVE_INT_TYPE portNum,
252 )
253 {
254 FW_ASSERT(
255 portNum < this->getNum_timeCaller_OutputPorts(),
256 static_cast<FwAssertArgType>(portNum)
257 );
258
259 this->m_timeCaller_OutputPort[portNum].addCallPort(port);
260 }
261
262 // ----------------------------------------------------------------------
263 // Connect typed input ports to typed output ports
264 // ----------------------------------------------------------------------
265
266 void StreamCrossoverComponentBase ::
267 set_errorDeallocate_OutputPort(
268 NATIVE_INT_TYPE portNum,
270 )
271 {
272 FW_ASSERT(
273 portNum < this->getNum_errorDeallocate_OutputPorts(),
274 static_cast<FwAssertArgType>(portNum)
275 );
276
277 this->m_errorDeallocate_OutputPort[portNum].addCallPort(port);
278 }
279
280 void StreamCrossoverComponentBase ::
281 set_streamOut_OutputPort(
282 NATIVE_INT_TYPE portNum,
284 )
285 {
286 FW_ASSERT(
287 portNum < this->getNum_streamOut_OutputPorts(),
288 static_cast<FwAssertArgType>(portNum)
289 );
290
291 this->m_streamOut_OutputPort[portNum].addCallPort(port);
292 }
293
294#if FW_PORT_SERIALIZATION
295
296 // ----------------------------------------------------------------------
297 // Connect serial input ports to special output ports
298 // ----------------------------------------------------------------------
299
300 void StreamCrossoverComponentBase ::
301 set_logOut_OutputPort(
302 NATIVE_INT_TYPE portNum,
303 Fw::InputSerializePort* port
304 )
305 {
306 FW_ASSERT(
307 portNum < this->getNum_logOut_OutputPorts(),
308 static_cast<FwAssertArgType>(portNum)
309 );
310
311 this->m_logOut_OutputPort[portNum].registerSerialPort(port);
312 }
313
314#if FW_ENABLE_TEXT_LOGGING == 1
315
316 void StreamCrossoverComponentBase ::
317 set_logTextOut_OutputPort(
318 NATIVE_INT_TYPE portNum,
319 Fw::InputSerializePort* port
320 )
321 {
322 FW_ASSERT(
323 portNum < this->getNum_logTextOut_OutputPorts(),
324 static_cast<FwAssertArgType>(portNum)
325 );
326
327 this->m_logTextOut_OutputPort[portNum].registerSerialPort(port);
328 }
329
330#endif
331
332 void StreamCrossoverComponentBase ::
333 set_timeCaller_OutputPort(
334 NATIVE_INT_TYPE portNum,
335 Fw::InputSerializePort* port
336 )
337 {
338 FW_ASSERT(
339 portNum < this->getNum_timeCaller_OutputPorts(),
340 static_cast<FwAssertArgType>(portNum)
341 );
342
343 this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
344 }
345
346#endif
347
348#if FW_PORT_SERIALIZATION
349
350 // ----------------------------------------------------------------------
351 // Connect serial input ports to typed output ports
352 // ----------------------------------------------------------------------
353
354 void StreamCrossoverComponentBase ::
355 set_errorDeallocate_OutputPort(
356 NATIVE_INT_TYPE portNum,
357 Fw::InputSerializePort* port
358 )
359 {
360 FW_ASSERT(
361 portNum < this->getNum_errorDeallocate_OutputPorts(),
362 static_cast<FwAssertArgType>(portNum)
363 );
364
365 this->m_errorDeallocate_OutputPort[portNum].registerSerialPort(port);
366 }
367
368#endif
369
370 // ----------------------------------------------------------------------
371 // Component construction and destruction
372 // ----------------------------------------------------------------------
373
374 StreamCrossoverComponentBase ::
375 StreamCrossoverComponentBase(const char* compName) :
376 Fw::PassiveComponentBase(compName)
377 {
378
379 }
380
381 StreamCrossoverComponentBase ::
382 ~StreamCrossoverComponentBase()
383 {
384
385 }
386
387 // ----------------------------------------------------------------------
388 // Getters for numbers of typed input ports
389 // ----------------------------------------------------------------------
390
391 NATIVE_INT_TYPE StreamCrossoverComponentBase ::
392 getNum_streamIn_InputPorts() const
393 {
394 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_streamIn_InputPort));
395 }
396
397 // ----------------------------------------------------------------------
398 // Getters for numbers of special output ports
399 // ----------------------------------------------------------------------
400
401 NATIVE_INT_TYPE StreamCrossoverComponentBase ::
402 getNum_logOut_OutputPorts() const
403 {
404 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_logOut_OutputPort));
405 }
406
407#if FW_ENABLE_TEXT_LOGGING == 1
408
409 NATIVE_INT_TYPE StreamCrossoverComponentBase ::
410 getNum_logTextOut_OutputPorts() const
411 {
412 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_logTextOut_OutputPort));
413 }
414
415#endif
416
417 NATIVE_INT_TYPE StreamCrossoverComponentBase ::
418 getNum_timeCaller_OutputPorts() const
419 {
420 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_timeCaller_OutputPort));
421 }
422
423 // ----------------------------------------------------------------------
424 // Getters for numbers of typed output ports
425 // ----------------------------------------------------------------------
426
427 NATIVE_INT_TYPE StreamCrossoverComponentBase ::
428 getNum_errorDeallocate_OutputPorts() const
429 {
430 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_errorDeallocate_OutputPort));
431 }
432
433 NATIVE_INT_TYPE StreamCrossoverComponentBase ::
434 getNum_streamOut_OutputPorts() const
435 {
436 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_streamOut_OutputPort));
437 }
438
439 // ----------------------------------------------------------------------
440 // Connection status queries for special output ports
441 // ----------------------------------------------------------------------
442
443 bool StreamCrossoverComponentBase ::
444 isConnected_logOut_OutputPort(NATIVE_INT_TYPE portNum)
445 {
446 FW_ASSERT(
447 portNum < this->getNum_logOut_OutputPorts(),
448 static_cast<FwAssertArgType>(portNum)
449 );
450
451 return this->m_logOut_OutputPort[portNum].isConnected();
452 }
453
454#if FW_ENABLE_TEXT_LOGGING == 1
455
456 bool StreamCrossoverComponentBase ::
457 isConnected_logTextOut_OutputPort(NATIVE_INT_TYPE portNum)
458 {
459 FW_ASSERT(
460 portNum < this->getNum_logTextOut_OutputPorts(),
461 static_cast<FwAssertArgType>(portNum)
462 );
463
464 return this->m_logTextOut_OutputPort[portNum].isConnected();
465 }
466
467#endif
468
469 bool StreamCrossoverComponentBase ::
470 isConnected_timeCaller_OutputPort(NATIVE_INT_TYPE portNum)
471 {
472 FW_ASSERT(
473 portNum < this->getNum_timeCaller_OutputPorts(),
474 static_cast<FwAssertArgType>(portNum)
475 );
476
477 return this->m_timeCaller_OutputPort[portNum].isConnected();
478 }
479
480 // ----------------------------------------------------------------------
481 // Connection status queries for typed output ports
482 // ----------------------------------------------------------------------
483
484 bool StreamCrossoverComponentBase ::
485 isConnected_errorDeallocate_OutputPort(NATIVE_INT_TYPE portNum)
486 {
487 FW_ASSERT(
488 portNum < this->getNum_errorDeallocate_OutputPorts(),
489 static_cast<FwAssertArgType>(portNum)
490 );
491
492 return this->m_errorDeallocate_OutputPort[portNum].isConnected();
493 }
494
495 bool StreamCrossoverComponentBase ::
496 isConnected_streamOut_OutputPort(NATIVE_INT_TYPE portNum)
497 {
498 FW_ASSERT(
499 portNum < this->getNum_streamOut_OutputPorts(),
500 static_cast<FwAssertArgType>(portNum)
501 );
502
503 return this->m_streamOut_OutputPort[portNum].isConnected();
504 }
505
506 // ----------------------------------------------------------------------
507 // Port handler base-class functions for typed input ports
508 //
509 // Call these functions directly to bypass the corresponding ports
510 // ----------------------------------------------------------------------
511
512 void StreamCrossoverComponentBase ::
513 streamIn_handlerBase(
514 NATIVE_INT_TYPE portNum,
515 Fw::Buffer& recvBuffer,
516 const Drv::RecvStatus& recvStatus
517 )
518 {
519 // Make sure port number is valid
520 FW_ASSERT(
521 portNum < this->getNum_streamIn_InputPorts(),
522 static_cast<FwAssertArgType>(portNum)
523 );
524
525 // Call handler function
526 this->streamIn_handler(
527 portNum,
528 recvBuffer,
529 recvStatus
530 );
531 }
532
533 // ----------------------------------------------------------------------
534 // Invocation functions for typed output ports
535 // ----------------------------------------------------------------------
536
537 void StreamCrossoverComponentBase ::
538 errorDeallocate_out(
539 NATIVE_INT_TYPE portNum,
540 Fw::Buffer& fwBuffer
541 )
542 {
543 FW_ASSERT(
544 portNum < this->getNum_errorDeallocate_OutputPorts(),
545 static_cast<FwAssertArgType>(portNum)
546 );
547 this->m_errorDeallocate_OutputPort[portNum].invoke(
548 fwBuffer
549 );
550 }
551
552 Drv::SendStatus StreamCrossoverComponentBase ::
553 streamOut_out(
554 NATIVE_INT_TYPE portNum,
555 Fw::Buffer& sendBuffer
556 )
557 {
558 FW_ASSERT(
559 portNum < this->getNum_streamOut_OutputPorts(),
560 static_cast<FwAssertArgType>(portNum)
561 );
562 return this->m_streamOut_OutputPort[portNum].invoke(
563 sendBuffer
564 );
565 }
566
567 // ----------------------------------------------------------------------
568 // Event logging functions
569 // ----------------------------------------------------------------------
570
571 void StreamCrossoverComponentBase ::
572 log_WARNING_HI_StreamOutError(Drv::SendStatus sendStatus)
573 {
574 // Get the time
575 Fw::Time _logTime;
576 if (this->m_timeCaller_OutputPort[0].isConnected()) {
577 this->m_timeCaller_OutputPort[0].invoke(_logTime);
578 }
579
580 FwEventIdType _id = static_cast<FwEventIdType>(0);
581
582 _id = this->getIdBase() + EVENTID_STREAMOUTERROR;
583
584 // Emit the event on the log port
585 if (this->m_logOut_OutputPort[0].isConnected()) {
586 Fw::LogBuffer _logBuff;
588
589#if FW_AMPCS_COMPATIBLE
590 // Serialize the number of arguments
591 _status = _logBuff.serialize(static_cast<U8>(1));
592 FW_ASSERT(
593 _status == Fw::FW_SERIALIZE_OK,
594 static_cast<FwAssertArgType>(_status)
595 );
596#endif
597
598#if FW_AMPCS_COMPATIBLE
599 // Serialize the argument size
600 _status = _logBuff.serialize(
602 );
603 FW_ASSERT(
604 _status == Fw::FW_SERIALIZE_OK,
605 static_cast<FwAssertArgType>(_status)
606 );
607#endif
608 _status = _logBuff.serialize(sendStatus);
609 FW_ASSERT(
610 _status == Fw::FW_SERIALIZE_OK,
611 static_cast<FwAssertArgType>(_status)
612 );
613
614 this->m_logOut_OutputPort[0].invoke(
615 _id,
616 _logTime,
618 _logBuff
619 );
620 }
621
622 // Emit the event on the text log port
623#if FW_ENABLE_TEXT_LOGGING
624 if (this->m_logTextOut_OutputPort[0].isConnected()) {
625#if FW_OBJECT_NAMES == 1
626 const char* _formatString =
627 "(%s) %s: StreamCrossover StreamOut Error: %s";
628#else
629 const char* _formatString =
630 "%s: StreamCrossover StreamOut Error: %s";
631#endif
632
633 char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
634
635 Fw::String sendStatusStr;
636 sendStatus.toString(sendStatusStr);
637
638 (void) snprintf(
639 _textBuffer,
641 _formatString,
642#if FW_OBJECT_NAMES == 1
643 this->m_objName,
644#endif
645 "StreamOutError ",
646 sendStatusStr.toChar()
647 );
648
649 // Null terminate
650 _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
651 Fw::TextLogString _logString = _textBuffer;
652 this->m_logTextOut_OutputPort[0].invoke(
653 _id,
654 _logTime,
656 _logString
657 );
658 }
659#endif
660 }
661
662 // ----------------------------------------------------------------------
663 // Time
664 // ----------------------------------------------------------------------
665
666 Fw::Time StreamCrossoverComponentBase ::
667 getTime()
668 {
669 if (this->m_timeCaller_OutputPort[0].isConnected()) {
670 Fw::Time _time;
671 this->m_timeCaller_OutputPort[0].invoke(_time);
672 return _time;
673 }
674 else {
675 return Fw::Time(TB_NONE, 0, 0);
676 }
677 }
678
679 // ----------------------------------------------------------------------
680 // Calls for messages received on typed input ports
681 // ----------------------------------------------------------------------
682
683 void StreamCrossoverComponentBase ::
684 m_p_streamIn_in(
685 Fw::PassiveComponentBase* callComp,
686 NATIVE_INT_TYPE portNum,
687 Fw::Buffer& recvBuffer,
688 const Drv::RecvStatus& recvStatus
689 )
690 {
691 FW_ASSERT(callComp);
692 StreamCrossoverComponentBase* compPtr = static_cast<StreamCrossoverComponentBase*>(callComp);
693 compPtr->streamIn_handlerBase(
694 portNum,
695 recvBuffer,
696 recvStatus
697 );
698 }
699
700}
#define FW_ASSERT(...)
Definition Assert.hpp:14
PlatformIntType NATIVE_INT_TYPE
Definition BasicTypes.h:51
uint8_t U8
8-bit unsigned integer
Definition BasicTypes.h:26
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition BasicTypes.h:66
int PlatformIntType
DefaultTypes.hpp provides fallback defaults for the platform types.
#define PRI_PlatformIntType
@ TB_NONE
No time base has been established.
Definition FpConfig.h:39
PlatformAssertArgType FwAssertArgType
Definition FpConfig.h:21
U32 FwEventIdType
Definition FpConfig.h:62
#define FW_LOG_TEXT_BUFFER_SIZE
Max size of string for text log message.
Definition FpConfig.h:299
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects)
Definition FpConfig.h:88
Status associated with the received data.
Status returned by the send call.
@ SERIALIZED_SIZE
The size of the serial representation.
Auto-generated base for StreamCrossover component.
void streamIn_handlerBase(NATIVE_INT_TYPE portNum, Fw::Buffer &recvBuffer, const Drv::RecvStatus &recvStatus)
Handler base-class function for input port streamIn.
@ WARNING_HI
A serious but recoverable event.
void init()
Object initializer.
Definition ObjBase.cpp:27
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
const char * toChar() const
gets char buffer
Definition String.cpp:48
SerializeStatus
forward declaration for string
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.