F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
Loading...
Searching...
No Matches
DeframerComponentAc.cpp
Go to the documentation of this file.
1// ======================================================================
2// \title DeframerComponentAc.cpp
3// \author Generated by fpp-to-cpp
4// \brief cpp file for Deframer 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
14namespace Svc {
15
16 // ----------------------------------------------------------------------
17 // Component initialization
18 // ----------------------------------------------------------------------
19
20 void DeframerComponentBase ::
21 init(FwEnumStoreType instance)
22 {
23 // Initialize base class
25
26 // Connect input port cmdResponseIn
27 for (
28 FwIndexType port = 0;
29 port < static_cast<FwIndexType>(this->getNum_cmdResponseIn_InputPorts());
30 port++
31 ) {
32 this->m_cmdResponseIn_InputPort[port].init();
33 this->m_cmdResponseIn_InputPort[port].addCallComp(
34 this,
35 m_p_cmdResponseIn_in
36 );
37 this->m_cmdResponseIn_InputPort[port].setPortNum(port);
38
39#if FW_OBJECT_NAMES == 1
40 Fw::ObjectName portName;
41 portName.format(
42 "%s_cmdResponseIn_InputPort[%" PRI_PlatformIntType "]",
43 this->m_objName.toChar(),
44 port
45 );
46 this->m_cmdResponseIn_InputPort[port].setObjName(portName.toChar());
47#endif
48 }
49
50 // Connect input port framedIn
51 for (
52 FwIndexType port = 0;
53 port < static_cast<FwIndexType>(this->getNum_framedIn_InputPorts());
54 port++
55 ) {
56 this->m_framedIn_InputPort[port].init();
57 this->m_framedIn_InputPort[port].addCallComp(
58 this,
59 m_p_framedIn_in
60 );
61 this->m_framedIn_InputPort[port].setPortNum(port);
62
63#if FW_OBJECT_NAMES == 1
64 Fw::ObjectName portName;
65 portName.format(
66 "%s_framedIn_InputPort[%" PRI_PlatformIntType "]",
67 this->m_objName.toChar(),
68 port
69 );
70 this->m_framedIn_InputPort[port].setObjName(portName.toChar());
71#endif
72 }
73
74 // Connect input port schedIn
75 for (
76 FwIndexType port = 0;
77 port < static_cast<FwIndexType>(this->getNum_schedIn_InputPorts());
78 port++
79 ) {
80 this->m_schedIn_InputPort[port].init();
81 this->m_schedIn_InputPort[port].addCallComp(
82 this,
83 m_p_schedIn_in
84 );
85 this->m_schedIn_InputPort[port].setPortNum(port);
86
87#if FW_OBJECT_NAMES == 1
88 Fw::ObjectName portName;
89 portName.format(
90 "%s_schedIn_InputPort[%" PRI_PlatformIntType "]",
91 this->m_objName.toChar(),
92 port
93 );
94 this->m_schedIn_InputPort[port].setObjName(portName.toChar());
95#endif
96 }
97
98 // Connect output port bufferAllocate
99 for (
100 FwIndexType port = 0;
101 port < static_cast<FwIndexType>(this->getNum_bufferAllocate_OutputPorts());
102 port++
103 ) {
104 this->m_bufferAllocate_OutputPort[port].init();
105
106#if FW_OBJECT_NAMES == 1
107 Fw::ObjectName portName;
108 portName.format(
109 "%s_bufferAllocate_OutputPort[%" PRI_PlatformIntType "]",
110 this->m_objName.toChar(),
111 port
112 );
113 this->m_bufferAllocate_OutputPort[port].setObjName(portName.toChar());
114#endif
115 }
116
117 // Connect output port bufferDeallocate
118 for (
119 FwIndexType port = 0;
120 port < static_cast<FwIndexType>(this->getNum_bufferDeallocate_OutputPorts());
121 port++
122 ) {
123 this->m_bufferDeallocate_OutputPort[port].init();
124
125#if FW_OBJECT_NAMES == 1
126 Fw::ObjectName portName;
127 portName.format(
128 "%s_bufferDeallocate_OutputPort[%" PRI_PlatformIntType "]",
129 this->m_objName.toChar(),
130 port
131 );
132 this->m_bufferDeallocate_OutputPort[port].setObjName(portName.toChar());
133#endif
134 }
135
136 // Connect output port bufferOut
137 for (
138 FwIndexType port = 0;
139 port < static_cast<FwIndexType>(this->getNum_bufferOut_OutputPorts());
140 port++
141 ) {
142 this->m_bufferOut_OutputPort[port].init();
143
144#if FW_OBJECT_NAMES == 1
145 Fw::ObjectName portName;
146 portName.format(
147 "%s_bufferOut_OutputPort[%" PRI_PlatformIntType "]",
148 this->m_objName.toChar(),
149 port
150 );
151 this->m_bufferOut_OutputPort[port].setObjName(portName.toChar());
152#endif
153 }
154
155 // Connect output port comOut
156 for (
157 FwIndexType port = 0;
158 port < static_cast<FwIndexType>(this->getNum_comOut_OutputPorts());
159 port++
160 ) {
161 this->m_comOut_OutputPort[port].init();
162
163#if FW_OBJECT_NAMES == 1
164 Fw::ObjectName portName;
165 portName.format(
166 "%s_comOut_OutputPort[%" PRI_PlatformIntType "]",
167 this->m_objName.toChar(),
168 port
169 );
170 this->m_comOut_OutputPort[port].setObjName(portName.toChar());
171#endif
172 }
173
174 // Connect output port framedDeallocate
175 for (
176 FwIndexType port = 0;
177 port < static_cast<FwIndexType>(this->getNum_framedDeallocate_OutputPorts());
178 port++
179 ) {
180 this->m_framedDeallocate_OutputPort[port].init();
181
182#if FW_OBJECT_NAMES == 1
183 Fw::ObjectName portName;
184 portName.format(
185 "%s_framedDeallocate_OutputPort[%" PRI_PlatformIntType "]",
186 this->m_objName.toChar(),
187 port
188 );
189 this->m_framedDeallocate_OutputPort[port].setObjName(portName.toChar());
190#endif
191 }
192
193 // Connect output port framedPoll
194 for (
195 FwIndexType port = 0;
196 port < static_cast<FwIndexType>(this->getNum_framedPoll_OutputPorts());
197 port++
198 ) {
199 this->m_framedPoll_OutputPort[port].init();
200
201#if FW_OBJECT_NAMES == 1
202 Fw::ObjectName portName;
203 portName.format(
204 "%s_framedPoll_OutputPort[%" PRI_PlatformIntType "]",
205 this->m_objName.toChar(),
206 port
207 );
208 this->m_framedPoll_OutputPort[port].setObjName(portName.toChar());
209#endif
210 }
211 }
212
213 // ----------------------------------------------------------------------
214 // Getters for typed input ports
215 // ----------------------------------------------------------------------
216
217 Fw::InputCmdResponsePort* DeframerComponentBase ::
218 get_cmdResponseIn_InputPort(FwIndexType portNum)
219 {
220 FW_ASSERT(
221 portNum < this->getNum_cmdResponseIn_InputPorts(),
222 static_cast<FwAssertArgType>(portNum)
223 );
224
225 return &this->m_cmdResponseIn_InputPort[portNum];
226 }
227
228 Drv::InputByteStreamRecvPort* DeframerComponentBase ::
229 get_framedIn_InputPort(FwIndexType portNum)
230 {
231 FW_ASSERT(
232 portNum < this->getNum_framedIn_InputPorts(),
233 static_cast<FwAssertArgType>(portNum)
234 );
235
236 return &this->m_framedIn_InputPort[portNum];
237 }
238
239 Svc::InputSchedPort* DeframerComponentBase ::
240 get_schedIn_InputPort(FwIndexType portNum)
241 {
242 FW_ASSERT(
243 portNum < this->getNum_schedIn_InputPorts(),
244 static_cast<FwAssertArgType>(portNum)
245 );
246
247 return &this->m_schedIn_InputPort[portNum];
248 }
249
250 // ----------------------------------------------------------------------
251 // Connect typed input ports to typed output ports
252 // ----------------------------------------------------------------------
253
254 void DeframerComponentBase ::
255 set_bufferAllocate_OutputPort(
256 FwIndexType portNum,
258 )
259 {
260 FW_ASSERT(
261 portNum < this->getNum_bufferAllocate_OutputPorts(),
262 static_cast<FwAssertArgType>(portNum)
263 );
264
265 this->m_bufferAllocate_OutputPort[portNum].addCallPort(port);
266 }
267
268 void DeframerComponentBase ::
269 set_bufferDeallocate_OutputPort(
270 FwIndexType portNum,
272 )
273 {
274 FW_ASSERT(
275 portNum < this->getNum_bufferDeallocate_OutputPorts(),
276 static_cast<FwAssertArgType>(portNum)
277 );
278
279 this->m_bufferDeallocate_OutputPort[portNum].addCallPort(port);
280 }
281
282 void DeframerComponentBase ::
283 set_bufferOut_OutputPort(
284 FwIndexType portNum,
286 )
287 {
288 FW_ASSERT(
289 portNum < this->getNum_bufferOut_OutputPorts(),
290 static_cast<FwAssertArgType>(portNum)
291 );
292
293 this->m_bufferOut_OutputPort[portNum].addCallPort(port);
294 }
295
296 void DeframerComponentBase ::
297 set_comOut_OutputPort(
298 FwIndexType portNum,
299 Fw::InputComPort* port
300 )
301 {
302 FW_ASSERT(
303 portNum < this->getNum_comOut_OutputPorts(),
304 static_cast<FwAssertArgType>(portNum)
305 );
306
307 this->m_comOut_OutputPort[portNum].addCallPort(port);
308 }
309
310 void DeframerComponentBase ::
311 set_framedDeallocate_OutputPort(
312 FwIndexType portNum,
314 )
315 {
316 FW_ASSERT(
317 portNum < this->getNum_framedDeallocate_OutputPorts(),
318 static_cast<FwAssertArgType>(portNum)
319 );
320
321 this->m_framedDeallocate_OutputPort[portNum].addCallPort(port);
322 }
323
324 void DeframerComponentBase ::
325 set_framedPoll_OutputPort(
326 FwIndexType portNum,
328 )
329 {
330 FW_ASSERT(
331 portNum < this->getNum_framedPoll_OutputPorts(),
332 static_cast<FwAssertArgType>(portNum)
333 );
334
335 this->m_framedPoll_OutputPort[portNum].addCallPort(port);
336 }
337
338#if FW_PORT_SERIALIZATION
339
340 // ----------------------------------------------------------------------
341 // Connect serial input ports to typed output ports
342 // ----------------------------------------------------------------------
343
344 void DeframerComponentBase ::
345 set_bufferDeallocate_OutputPort(
346 FwIndexType portNum,
347 Fw::InputSerializePort* port
348 )
349 {
350 FW_ASSERT(
351 portNum < this->getNum_bufferDeallocate_OutputPorts(),
352 static_cast<FwAssertArgType>(portNum)
353 );
354
355 this->m_bufferDeallocate_OutputPort[portNum].registerSerialPort(port);
356 }
357
358 void DeframerComponentBase ::
359 set_bufferOut_OutputPort(
360 FwIndexType portNum,
361 Fw::InputSerializePort* port
362 )
363 {
364 FW_ASSERT(
365 portNum < this->getNum_bufferOut_OutputPorts(),
366 static_cast<FwAssertArgType>(portNum)
367 );
368
369 this->m_bufferOut_OutputPort[portNum].registerSerialPort(port);
370 }
371
372 void DeframerComponentBase ::
373 set_comOut_OutputPort(
374 FwIndexType portNum,
375 Fw::InputSerializePort* port
376 )
377 {
378 FW_ASSERT(
379 portNum < this->getNum_comOut_OutputPorts(),
380 static_cast<FwAssertArgType>(portNum)
381 );
382
383 this->m_comOut_OutputPort[portNum].registerSerialPort(port);
384 }
385
386 void DeframerComponentBase ::
387 set_framedDeallocate_OutputPort(
388 FwIndexType portNum,
389 Fw::InputSerializePort* port
390 )
391 {
392 FW_ASSERT(
393 portNum < this->getNum_framedDeallocate_OutputPorts(),
394 static_cast<FwAssertArgType>(portNum)
395 );
396
397 this->m_framedDeallocate_OutputPort[portNum].registerSerialPort(port);
398 }
399
400#endif
401
402 // ----------------------------------------------------------------------
403 // Component construction and destruction
404 // ----------------------------------------------------------------------
405
406 DeframerComponentBase ::
407 DeframerComponentBase(const char* compName) :
408 Fw::PassiveComponentBase(compName)
409 {
410
411 }
412
413 DeframerComponentBase ::
414 ~DeframerComponentBase()
415 {
416
417 }
418
419 // ----------------------------------------------------------------------
420 // Getters for numbers of typed input ports
421 // ----------------------------------------------------------------------
422
423 FwIndexType DeframerComponentBase ::
424 getNum_cmdResponseIn_InputPorts() const
425 {
426 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdResponseIn_InputPort));
427 }
428
429 FwIndexType DeframerComponentBase ::
430 getNum_framedIn_InputPorts() const
431 {
432 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_framedIn_InputPort));
433 }
434
435 FwIndexType DeframerComponentBase ::
436 getNum_schedIn_InputPorts() const
437 {
438 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_schedIn_InputPort));
439 }
440
441 // ----------------------------------------------------------------------
442 // Getters for numbers of typed output ports
443 // ----------------------------------------------------------------------
444
445 FwIndexType DeframerComponentBase ::
446 getNum_bufferAllocate_OutputPorts() const
447 {
448 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_bufferAllocate_OutputPort));
449 }
450
451 FwIndexType DeframerComponentBase ::
452 getNum_bufferDeallocate_OutputPorts() const
453 {
454 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_bufferDeallocate_OutputPort));
455 }
456
457 FwIndexType DeframerComponentBase ::
458 getNum_bufferOut_OutputPorts() const
459 {
460 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_bufferOut_OutputPort));
461 }
462
463 FwIndexType DeframerComponentBase ::
464 getNum_comOut_OutputPorts() const
465 {
466 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_comOut_OutputPort));
467 }
468
469 FwIndexType DeframerComponentBase ::
470 getNum_framedDeallocate_OutputPorts() const
471 {
472 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_framedDeallocate_OutputPort));
473 }
474
475 FwIndexType DeframerComponentBase ::
476 getNum_framedPoll_OutputPorts() const
477 {
478 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_framedPoll_OutputPort));
479 }
480
481 // ----------------------------------------------------------------------
482 // Connection status queries for typed output ports
483 // ----------------------------------------------------------------------
484
485 bool DeframerComponentBase ::
486 isConnected_bufferAllocate_OutputPort(FwIndexType portNum)
487 {
488 FW_ASSERT(
489 portNum < this->getNum_bufferAllocate_OutputPorts(),
490 static_cast<FwAssertArgType>(portNum)
491 );
492
493 return this->m_bufferAllocate_OutputPort[portNum].isConnected();
494 }
495
496 bool DeframerComponentBase ::
497 isConnected_bufferDeallocate_OutputPort(FwIndexType portNum)
498 {
499 FW_ASSERT(
500 portNum < this->getNum_bufferDeallocate_OutputPorts(),
501 static_cast<FwAssertArgType>(portNum)
502 );
503
504 return this->m_bufferDeallocate_OutputPort[portNum].isConnected();
505 }
506
507 bool DeframerComponentBase ::
508 isConnected_bufferOut_OutputPort(FwIndexType portNum)
509 {
510 FW_ASSERT(
511 portNum < this->getNum_bufferOut_OutputPorts(),
512 static_cast<FwAssertArgType>(portNum)
513 );
514
515 return this->m_bufferOut_OutputPort[portNum].isConnected();
516 }
517
518 bool DeframerComponentBase ::
519 isConnected_comOut_OutputPort(FwIndexType portNum)
520 {
521 FW_ASSERT(
522 portNum < this->getNum_comOut_OutputPorts(),
523 static_cast<FwAssertArgType>(portNum)
524 );
525
526 return this->m_comOut_OutputPort[portNum].isConnected();
527 }
528
529 bool DeframerComponentBase ::
530 isConnected_framedDeallocate_OutputPort(FwIndexType portNum)
531 {
532 FW_ASSERT(
533 portNum < this->getNum_framedDeallocate_OutputPorts(),
534 static_cast<FwAssertArgType>(portNum)
535 );
536
537 return this->m_framedDeallocate_OutputPort[portNum].isConnected();
538 }
539
540 bool DeframerComponentBase ::
541 isConnected_framedPoll_OutputPort(FwIndexType portNum)
542 {
543 FW_ASSERT(
544 portNum < this->getNum_framedPoll_OutputPorts(),
545 static_cast<FwAssertArgType>(portNum)
546 );
547
548 return this->m_framedPoll_OutputPort[portNum].isConnected();
549 }
550
551 // ----------------------------------------------------------------------
552 // Port handler base-class functions for typed input ports
553 //
554 // Call these functions directly to bypass the corresponding ports
555 // ----------------------------------------------------------------------
556
557 void DeframerComponentBase ::
558 cmdResponseIn_handlerBase(
559 FwIndexType portNum,
560 FwOpcodeType opCode,
561 U32 cmdSeq,
562 const Fw::CmdResponse& response
563 )
564 {
565 // Make sure port number is valid
566 FW_ASSERT(
567 portNum < this->getNum_cmdResponseIn_InputPorts(),
568 static_cast<FwAssertArgType>(portNum)
569 );
570
571 // Call handler function
572 this->cmdResponseIn_handler(
573 portNum,
574 opCode,
575 cmdSeq,
576 response
577 );
578 }
579
580 void DeframerComponentBase ::
581 framedIn_handlerBase(
582 FwIndexType portNum,
583 Fw::Buffer& recvBuffer,
584 const Drv::RecvStatus& recvStatus
585 )
586 {
587 // Make sure port number is valid
588 FW_ASSERT(
589 portNum < this->getNum_framedIn_InputPorts(),
590 static_cast<FwAssertArgType>(portNum)
591 );
592
593 // Lock guard mutex before calling
594 this->lock();
595
596 // Call handler function
597 this->framedIn_handler(
598 portNum,
599 recvBuffer,
600 recvStatus
601 );
602
603 // Unlock guard mutex
604 this->unLock();
605 }
606
607 void DeframerComponentBase ::
608 schedIn_handlerBase(
609 FwIndexType portNum,
610 U32 context
611 )
612 {
613 // Make sure port number is valid
614 FW_ASSERT(
615 portNum < this->getNum_schedIn_InputPorts(),
616 static_cast<FwAssertArgType>(portNum)
617 );
618
619 // Lock guard mutex before calling
620 this->lock();
621
622 // Call handler function
623 this->schedIn_handler(
624 portNum,
625 context
626 );
627
628 // Unlock guard mutex
629 this->unLock();
630 }
631
632 // ----------------------------------------------------------------------
633 // Invocation functions for typed output ports
634 // ----------------------------------------------------------------------
635
636 Fw::Buffer DeframerComponentBase ::
637 bufferAllocate_out(
638 FwIndexType portNum,
639 U32 size
640 )
641 {
642 FW_ASSERT(
643 portNum < this->getNum_bufferAllocate_OutputPorts(),
644 static_cast<FwAssertArgType>(portNum)
645 );
646 return this->m_bufferAllocate_OutputPort[portNum].invoke(
647 size
648 );
649 }
650
651 void DeframerComponentBase ::
652 bufferDeallocate_out(
653 FwIndexType portNum,
654 Fw::Buffer& fwBuffer
655 )
656 {
657 FW_ASSERT(
658 portNum < this->getNum_bufferDeallocate_OutputPorts(),
659 static_cast<FwAssertArgType>(portNum)
660 );
661 this->m_bufferDeallocate_OutputPort[portNum].invoke(
662 fwBuffer
663 );
664 }
665
666 void DeframerComponentBase ::
667 bufferOut_out(
668 FwIndexType portNum,
669 Fw::Buffer& fwBuffer
670 )
671 {
672 FW_ASSERT(
673 portNum < this->getNum_bufferOut_OutputPorts(),
674 static_cast<FwAssertArgType>(portNum)
675 );
676 this->m_bufferOut_OutputPort[portNum].invoke(
677 fwBuffer
678 );
679 }
680
681 void DeframerComponentBase ::
682 comOut_out(
683 FwIndexType portNum,
684 Fw::ComBuffer& data,
685 U32 context
686 )
687 {
688 FW_ASSERT(
689 portNum < this->getNum_comOut_OutputPorts(),
690 static_cast<FwAssertArgType>(portNum)
691 );
692 this->m_comOut_OutputPort[portNum].invoke(
693 data,
694 context
695 );
696 }
697
698 void DeframerComponentBase ::
699 framedDeallocate_out(
700 FwIndexType portNum,
701 Fw::Buffer& fwBuffer
702 )
703 {
704 FW_ASSERT(
705 portNum < this->getNum_framedDeallocate_OutputPorts(),
706 static_cast<FwAssertArgType>(portNum)
707 );
708 this->m_framedDeallocate_OutputPort[portNum].invoke(
709 fwBuffer
710 );
711 }
712
713 Drv::PollStatus DeframerComponentBase ::
714 framedPoll_out(
715 FwIndexType portNum,
716 Fw::Buffer& pollBuffer
717 )
718 {
719 FW_ASSERT(
720 portNum < this->getNum_framedPoll_OutputPorts(),
721 static_cast<FwAssertArgType>(portNum)
722 );
723 return this->m_framedPoll_OutputPort[portNum].invoke(
724 pollBuffer
725 );
726 }
727
728 // ----------------------------------------------------------------------
729 // Mutex operations for guarded ports
730 //
731 // You can override these operations to provide more sophisticated
732 // synchronization
733 // ----------------------------------------------------------------------
734
735 void DeframerComponentBase ::
736 lock()
737 {
738 this->m_guardedPortMutex.lock();
739 }
740
741 void DeframerComponentBase ::
742 unLock()
743 {
744 this->m_guardedPortMutex.unLock();
745 }
746
747 // ----------------------------------------------------------------------
748 // Calls for messages received on typed input ports
749 // ----------------------------------------------------------------------
750
751 void DeframerComponentBase ::
752 m_p_cmdResponseIn_in(
753 Fw::PassiveComponentBase* callComp,
754 FwIndexType portNum,
755 FwOpcodeType opCode,
756 U32 cmdSeq,
757 const Fw::CmdResponse& response
758 )
759 {
760 FW_ASSERT(callComp);
761 DeframerComponentBase* compPtr = static_cast<DeframerComponentBase*>(callComp);
763 portNum,
764 opCode,
765 cmdSeq,
766 response
767 );
768 }
769
770 void DeframerComponentBase ::
771 m_p_framedIn_in(
772 Fw::PassiveComponentBase* callComp,
773 FwIndexType portNum,
774 Fw::Buffer& recvBuffer,
775 const Drv::RecvStatus& recvStatus
776 )
777 {
778 FW_ASSERT(callComp);
779 DeframerComponentBase* compPtr = static_cast<DeframerComponentBase*>(callComp);
780 compPtr->framedIn_handlerBase(
781 portNum,
782 recvBuffer,
783 recvStatus
784 );
785 }
786
787 void DeframerComponentBase ::
788 m_p_schedIn_in(
789 Fw::PassiveComponentBase* callComp,
790 FwIndexType portNum,
791 U32 context
792 )
793 {
794 FW_ASSERT(callComp);
795 DeframerComponentBase* compPtr = static_cast<DeframerComponentBase*>(callComp);
796 compPtr->schedIn_handlerBase(
797 portNum,
798 context
799 );
800 }
801
802}
#define FW_ASSERT(...)
Definition Assert.hpp:14
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition BasicTypes.h:70
#define PRI_PlatformIntType
I32 FwEnumStoreType
Definition FpConfig.h:64
PlatformAssertArgType FwAssertArgType
Definition FpConfig.h:39
U32 FwOpcodeType
Definition FpConfig.h:91
PlatformIndexType FwIndexType
Definition FpConfig.h:25
Input ByteStreamPoll port.
Status associated with the received data.
Enum representing a command response.
void init()
Object initializer.
Definition ObjBase.cpp:27
const char * toChar() const
void format(const CHAR *formatString,...)
write formatted string to buffer
Auto-generated base for Deframer component.
void cmdResponseIn_handlerBase(FwIndexType portNum, FwOpcodeType opCode, U32 cmdSeq, const Fw::CmdResponse &response)
Handler base-class function for input port cmdResponseIn.
void framedIn_handlerBase(FwIndexType portNum, Fw::Buffer &recvBuffer, const Drv::RecvStatus &recvStatus)
Handler base-class function for input port framedIn.