F´ Flight Software - C/C++ Documentation devel
A framework for building embedded system applications to NASA flight quality standards.
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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.