F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
Loading...
Searching...
No Matches
ComQueueComponentAc.cpp
Go to the documentation of this file.
1// ======================================================================
2// \title ComQueueComponentAc.cpp
3// \author Generated by fpp-to-cpp
4// \brief cpp file for ComQueue 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 namespace {
17 enum MsgTypeEnum {
18 COMQUEUE_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
19 BUFFQUEUEIN_BUFFERSEND,
20 COMQUEUEIN_COM,
21 COMSTATUSIN_SUCCESSCONDITION,
22 RUN_SCHED,
23 };
24
25 // Get the max size by constructing a union of the async input, command, and
26 // internal port serialization sizes
27 union BuffUnion {
29 BYTE comQueueInPortSize[Fw::InputComPort::SERIALIZED_SIZE];
32 };
33
34 // Define a message buffer class large enough to handle all the
35 // asynchronous inputs to the component
36 class ComponentIpcSerializableBuffer :
38 {
39
40 public:
41
42 enum {
43 // Offset into data in buffer: Size of message ID and port number
44 DATA_OFFSET = sizeof(FwEnumStoreType) + sizeof(FwIndexType),
45 // Max data size
46 MAX_DATA_SIZE = sizeof(BuffUnion),
47 // Max message size: Size of message id + size of port + max data size
48 SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE
49 };
50
51 Fw::Serializable::SizeType getBuffCapacity() const {
52 return sizeof(m_buff);
53 }
54
55 U8* getBuffAddr() {
56 return m_buff;
57 }
58
59 const U8* getBuffAddr() const {
60 return m_buff;
61 }
62
63 private:
64 // Should be the max of all the input ports serialized sizes...
65 U8 m_buff[SERIALIZATION_SIZE];
66
67 };
68 }
69
70 // ----------------------------------------------------------------------
71 // Component initialization
72 // ----------------------------------------------------------------------
73
74 void ComQueueComponentBase ::
75 init(
76 FwSizeType queueDepth,
77 FwEnumStoreType instance
78 )
79 {
80 // Initialize base class
82
83 // Connect input port buffQueueIn
84 for (
85 FwIndexType port = 0;
86 port < static_cast<FwIndexType>(this->getNum_buffQueueIn_InputPorts());
87 port++
88 ) {
89 this->m_buffQueueIn_InputPort[port].init();
90 this->m_buffQueueIn_InputPort[port].addCallComp(
91 this,
92 m_p_buffQueueIn_in
93 );
94 this->m_buffQueueIn_InputPort[port].setPortNum(port);
95
96#if FW_OBJECT_NAMES == 1
97 Fw::ObjectName portName;
98 portName.format(
99 "%s_buffQueueIn_InputPort[%" PRI_PlatformIntType "]",
100 this->m_objName.toChar(),
101 port
102 );
103 this->m_buffQueueIn_InputPort[port].setObjName(portName.toChar());
104#endif
105 }
106
107 // Connect input port comQueueIn
108 for (
109 FwIndexType port = 0;
110 port < static_cast<FwIndexType>(this->getNum_comQueueIn_InputPorts());
111 port++
112 ) {
113 this->m_comQueueIn_InputPort[port].init();
114 this->m_comQueueIn_InputPort[port].addCallComp(
115 this,
116 m_p_comQueueIn_in
117 );
118 this->m_comQueueIn_InputPort[port].setPortNum(port);
119
120#if FW_OBJECT_NAMES == 1
121 Fw::ObjectName portName;
122 portName.format(
123 "%s_comQueueIn_InputPort[%" PRI_PlatformIntType "]",
124 this->m_objName.toChar(),
125 port
126 );
127 this->m_comQueueIn_InputPort[port].setObjName(portName.toChar());
128#endif
129 }
130
131 // Connect input port comStatusIn
132 for (
133 FwIndexType port = 0;
134 port < static_cast<FwIndexType>(this->getNum_comStatusIn_InputPorts());
135 port++
136 ) {
137 this->m_comStatusIn_InputPort[port].init();
138 this->m_comStatusIn_InputPort[port].addCallComp(
139 this,
140 m_p_comStatusIn_in
141 );
142 this->m_comStatusIn_InputPort[port].setPortNum(port);
143
144#if FW_OBJECT_NAMES == 1
145 Fw::ObjectName portName;
146 portName.format(
147 "%s_comStatusIn_InputPort[%" PRI_PlatformIntType "]",
148 this->m_objName.toChar(),
149 port
150 );
151 this->m_comStatusIn_InputPort[port].setObjName(portName.toChar());
152#endif
153 }
154
155 // Connect input port run
156 for (
157 FwIndexType port = 0;
158 port < static_cast<FwIndexType>(this->getNum_run_InputPorts());
159 port++
160 ) {
161 this->m_run_InputPort[port].init();
162 this->m_run_InputPort[port].addCallComp(
163 this,
164 m_p_run_in
165 );
166 this->m_run_InputPort[port].setPortNum(port);
167
168#if FW_OBJECT_NAMES == 1
169 Fw::ObjectName portName;
170 portName.format(
171 "%s_run_InputPort[%" PRI_PlatformIntType "]",
172 this->m_objName.toChar(),
173 port
174 );
175 this->m_run_InputPort[port].setObjName(portName.toChar());
176#endif
177 }
178
179 // Connect output port Log
180 for (
181 FwIndexType port = 0;
182 port < static_cast<FwIndexType>(this->getNum_Log_OutputPorts());
183 port++
184 ) {
185 this->m_Log_OutputPort[port].init();
186
187#if FW_OBJECT_NAMES == 1
188 Fw::ObjectName portName;
189 portName.format(
190 "%s_Log_OutputPort[%" PRI_PlatformIntType "]",
191 this->m_objName.toChar(),
192 port
193 );
194 this->m_Log_OutputPort[port].setObjName(portName.toChar());
195#endif
196 }
197
198#if FW_ENABLE_TEXT_LOGGING == 1
199 // Connect output port LogText
200 for (
201 FwIndexType port = 0;
202 port < static_cast<FwIndexType>(this->getNum_LogText_OutputPorts());
203 port++
204 ) {
205 this->m_LogText_OutputPort[port].init();
206
207#if FW_OBJECT_NAMES == 1
208 Fw::ObjectName portName;
209 portName.format(
210 "%s_LogText_OutputPort[%" PRI_PlatformIntType "]",
211 this->m_objName.toChar(),
212 port
213 );
214 this->m_LogText_OutputPort[port].setObjName(portName.toChar());
215#endif
216 }
217#endif
218
219 // Connect output port Time
220 for (
221 FwIndexType port = 0;
222 port < static_cast<FwIndexType>(this->getNum_Time_OutputPorts());
223 port++
224 ) {
225 this->m_Time_OutputPort[port].init();
226
227#if FW_OBJECT_NAMES == 1
228 Fw::ObjectName portName;
229 portName.format(
230 "%s_Time_OutputPort[%" PRI_PlatformIntType "]",
231 this->m_objName.toChar(),
232 port
233 );
234 this->m_Time_OutputPort[port].setObjName(portName.toChar());
235#endif
236 }
237
238 // Connect output port Tlm
239 for (
240 FwIndexType port = 0;
241 port < static_cast<FwIndexType>(this->getNum_Tlm_OutputPorts());
242 port++
243 ) {
244 this->m_Tlm_OutputPort[port].init();
245
246#if FW_OBJECT_NAMES == 1
247 Fw::ObjectName portName;
248 portName.format(
249 "%s_Tlm_OutputPort[%" PRI_PlatformIntType "]",
250 this->m_objName.toChar(),
251 port
252 );
253 this->m_Tlm_OutputPort[port].setObjName(portName.toChar());
254#endif
255 }
256
257 // Connect output port buffQueueSend
258 for (
259 FwIndexType port = 0;
260 port < static_cast<FwIndexType>(this->getNum_buffQueueSend_OutputPorts());
261 port++
262 ) {
263 this->m_buffQueueSend_OutputPort[port].init();
264
265#if FW_OBJECT_NAMES == 1
266 Fw::ObjectName portName;
267 portName.format(
268 "%s_buffQueueSend_OutputPort[%" PRI_PlatformIntType "]",
269 this->m_objName.toChar(),
270 port
271 );
272 this->m_buffQueueSend_OutputPort[port].setObjName(portName.toChar());
273#endif
274 }
275
276 // Connect output port comQueueSend
277 for (
278 FwIndexType port = 0;
279 port < static_cast<FwIndexType>(this->getNum_comQueueSend_OutputPorts());
280 port++
281 ) {
282 this->m_comQueueSend_OutputPort[port].init();
283
284#if FW_OBJECT_NAMES == 1
285 Fw::ObjectName portName;
286 portName.format(
287 "%s_comQueueSend_OutputPort[%" PRI_PlatformIntType "]",
288 this->m_objName.toChar(),
289 port
290 );
291 this->m_comQueueSend_OutputPort[port].setObjName(portName.toChar());
292#endif
293 }
294
295 // Connect output port deallocate
296 for (
297 FwIndexType port = 0;
298 port < static_cast<FwIndexType>(this->getNum_deallocate_OutputPorts());
299 port++
300 ) {
301 this->m_deallocate_OutputPort[port].init();
302
303#if FW_OBJECT_NAMES == 1
304 Fw::ObjectName portName;
305 portName.format(
306 "%s_deallocate_OutputPort[%" PRI_PlatformIntType "]",
307 this->m_objName.toChar(),
308 port
309 );
310 this->m_deallocate_OutputPort[port].setObjName(portName.toChar());
311#endif
312 }
313
314 // Create the queue
315 Os::Queue::Status qStat = this->createQueue(
316 queueDepth,
317 static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
318 );
319 FW_ASSERT(
321 static_cast<FwAssertArgType>(qStat)
322 );
323 }
324
325 // ----------------------------------------------------------------------
326 // Getters for typed input ports
327 // ----------------------------------------------------------------------
328
329 Fw::InputBufferSendPort* ComQueueComponentBase ::
330 get_buffQueueIn_InputPort(FwIndexType portNum)
331 {
332 FW_ASSERT(
333 portNum < this->getNum_buffQueueIn_InputPorts(),
334 static_cast<FwAssertArgType>(portNum)
335 );
336
337 return &this->m_buffQueueIn_InputPort[portNum];
338 }
339
340 Fw::InputComPort* ComQueueComponentBase ::
341 get_comQueueIn_InputPort(FwIndexType portNum)
342 {
343 FW_ASSERT(
344 portNum < this->getNum_comQueueIn_InputPorts(),
345 static_cast<FwAssertArgType>(portNum)
346 );
347
348 return &this->m_comQueueIn_InputPort[portNum];
349 }
350
351 Fw::InputSuccessConditionPort* ComQueueComponentBase ::
352 get_comStatusIn_InputPort(FwIndexType portNum)
353 {
354 FW_ASSERT(
355 portNum < this->getNum_comStatusIn_InputPorts(),
356 static_cast<FwAssertArgType>(portNum)
357 );
358
359 return &this->m_comStatusIn_InputPort[portNum];
360 }
361
362 Svc::InputSchedPort* ComQueueComponentBase ::
363 get_run_InputPort(FwIndexType portNum)
364 {
365 FW_ASSERT(
366 portNum < this->getNum_run_InputPorts(),
367 static_cast<FwAssertArgType>(portNum)
368 );
369
370 return &this->m_run_InputPort[portNum];
371 }
372
373 // ----------------------------------------------------------------------
374 // Connect input ports to special output ports
375 // ----------------------------------------------------------------------
376
377 void ComQueueComponentBase ::
378 set_Log_OutputPort(
379 FwIndexType portNum,
380 Fw::InputLogPort* port
381 )
382 {
383 FW_ASSERT(
384 portNum < this->getNum_Log_OutputPorts(),
385 static_cast<FwAssertArgType>(portNum)
386 );
387
388 this->m_Log_OutputPort[portNum].addCallPort(port);
389 }
390
391#if FW_ENABLE_TEXT_LOGGING == 1
392
393 void ComQueueComponentBase ::
394 set_LogText_OutputPort(
395 FwIndexType portNum,
397 )
398 {
399 FW_ASSERT(
400 portNum < this->getNum_LogText_OutputPorts(),
401 static_cast<FwAssertArgType>(portNum)
402 );
403
404 this->m_LogText_OutputPort[portNum].addCallPort(port);
405 }
406
407#endif
408
409 void ComQueueComponentBase ::
410 set_Time_OutputPort(
411 FwIndexType portNum,
413 )
414 {
415 FW_ASSERT(
416 portNum < this->getNum_Time_OutputPorts(),
417 static_cast<FwAssertArgType>(portNum)
418 );
419
420 this->m_Time_OutputPort[portNum].addCallPort(port);
421 }
422
423 void ComQueueComponentBase ::
424 set_Tlm_OutputPort(
425 FwIndexType portNum,
426 Fw::InputTlmPort* port
427 )
428 {
429 FW_ASSERT(
430 portNum < this->getNum_Tlm_OutputPorts(),
431 static_cast<FwAssertArgType>(portNum)
432 );
433
434 this->m_Tlm_OutputPort[portNum].addCallPort(port);
435 }
436
437 // ----------------------------------------------------------------------
438 // Connect typed input ports to typed output ports
439 // ----------------------------------------------------------------------
440
441 void ComQueueComponentBase ::
442 set_buffQueueSend_OutputPort(
443 FwIndexType portNum,
445 )
446 {
447 FW_ASSERT(
448 portNum < this->getNum_buffQueueSend_OutputPorts(),
449 static_cast<FwAssertArgType>(portNum)
450 );
451
452 this->m_buffQueueSend_OutputPort[portNum].addCallPort(port);
453 }
454
455 void ComQueueComponentBase ::
456 set_comQueueSend_OutputPort(
457 FwIndexType portNum,
458 Fw::InputComPort* port
459 )
460 {
461 FW_ASSERT(
462 portNum < this->getNum_comQueueSend_OutputPorts(),
463 static_cast<FwAssertArgType>(portNum)
464 );
465
466 this->m_comQueueSend_OutputPort[portNum].addCallPort(port);
467 }
468
469 void ComQueueComponentBase ::
470 set_deallocate_OutputPort(
471 FwIndexType portNum,
473 )
474 {
475 FW_ASSERT(
476 portNum < this->getNum_deallocate_OutputPorts(),
477 static_cast<FwAssertArgType>(portNum)
478 );
479
480 this->m_deallocate_OutputPort[portNum].addCallPort(port);
481 }
482
483#if FW_PORT_SERIALIZATION
484
485 // ----------------------------------------------------------------------
486 // Connect serial input ports to special output ports
487 // ----------------------------------------------------------------------
488
489 void ComQueueComponentBase ::
490 set_Log_OutputPort(
491 FwIndexType portNum,
492 Fw::InputSerializePort* port
493 )
494 {
495 FW_ASSERT(
496 portNum < this->getNum_Log_OutputPorts(),
497 static_cast<FwAssertArgType>(portNum)
498 );
499
500 this->m_Log_OutputPort[portNum].registerSerialPort(port);
501 }
502
503#if FW_ENABLE_TEXT_LOGGING == 1
504
505 void ComQueueComponentBase ::
506 set_LogText_OutputPort(
507 FwIndexType portNum,
508 Fw::InputSerializePort* port
509 )
510 {
511 FW_ASSERT(
512 portNum < this->getNum_LogText_OutputPorts(),
513 static_cast<FwAssertArgType>(portNum)
514 );
515
516 this->m_LogText_OutputPort[portNum].registerSerialPort(port);
517 }
518
519#endif
520
521 void ComQueueComponentBase ::
522 set_Time_OutputPort(
523 FwIndexType portNum,
524 Fw::InputSerializePort* port
525 )
526 {
527 FW_ASSERT(
528 portNum < this->getNum_Time_OutputPorts(),
529 static_cast<FwAssertArgType>(portNum)
530 );
531
532 this->m_Time_OutputPort[portNum].registerSerialPort(port);
533 }
534
535 void ComQueueComponentBase ::
536 set_Tlm_OutputPort(
537 FwIndexType portNum,
538 Fw::InputSerializePort* port
539 )
540 {
541 FW_ASSERT(
542 portNum < this->getNum_Tlm_OutputPorts(),
543 static_cast<FwAssertArgType>(portNum)
544 );
545
546 this->m_Tlm_OutputPort[portNum].registerSerialPort(port);
547 }
548
549#endif
550
551#if FW_PORT_SERIALIZATION
552
553 // ----------------------------------------------------------------------
554 // Connect serial input ports to typed output ports
555 // ----------------------------------------------------------------------
556
557 void ComQueueComponentBase ::
558 set_buffQueueSend_OutputPort(
559 FwIndexType portNum,
560 Fw::InputSerializePort* port
561 )
562 {
563 FW_ASSERT(
564 portNum < this->getNum_buffQueueSend_OutputPorts(),
565 static_cast<FwAssertArgType>(portNum)
566 );
567
568 this->m_buffQueueSend_OutputPort[portNum].registerSerialPort(port);
569 }
570
571 void ComQueueComponentBase ::
572 set_comQueueSend_OutputPort(
573 FwIndexType portNum,
574 Fw::InputSerializePort* port
575 )
576 {
577 FW_ASSERT(
578 portNum < this->getNum_comQueueSend_OutputPorts(),
579 static_cast<FwAssertArgType>(portNum)
580 );
581
582 this->m_comQueueSend_OutputPort[portNum].registerSerialPort(port);
583 }
584
585 void ComQueueComponentBase ::
586 set_deallocate_OutputPort(
587 FwIndexType portNum,
588 Fw::InputSerializePort* port
589 )
590 {
591 FW_ASSERT(
592 portNum < this->getNum_deallocate_OutputPorts(),
593 static_cast<FwAssertArgType>(portNum)
594 );
595
596 this->m_deallocate_OutputPort[portNum].registerSerialPort(port);
597 }
598
599#endif
600
601 // ----------------------------------------------------------------------
602 // Component construction and destruction
603 // ----------------------------------------------------------------------
604
605 ComQueueComponentBase ::
606 ComQueueComponentBase(const char* compName) :
607 Fw::ActiveComponentBase(compName)
608 {
609
610 }
611
612 ComQueueComponentBase ::
613 ~ComQueueComponentBase()
614 {
615
616 }
617
618 // ----------------------------------------------------------------------
619 // Getters for numbers of typed input ports
620 // ----------------------------------------------------------------------
621
622 FwIndexType ComQueueComponentBase ::
623 getNum_buffQueueIn_InputPorts() const
624 {
625 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_buffQueueIn_InputPort));
626 }
627
628 FwIndexType ComQueueComponentBase ::
629 getNum_comQueueIn_InputPorts() const
630 {
631 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_comQueueIn_InputPort));
632 }
633
634 FwIndexType ComQueueComponentBase ::
635 getNum_comStatusIn_InputPorts() const
636 {
637 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_comStatusIn_InputPort));
638 }
639
640 FwIndexType ComQueueComponentBase ::
641 getNum_run_InputPorts() const
642 {
643 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_run_InputPort));
644 }
645
646 // ----------------------------------------------------------------------
647 // Getters for numbers of special output ports
648 // ----------------------------------------------------------------------
649
650 FwIndexType ComQueueComponentBase ::
651 getNum_Log_OutputPorts() const
652 {
653 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_Log_OutputPort));
654 }
655
656#if FW_ENABLE_TEXT_LOGGING == 1
657
658 FwIndexType ComQueueComponentBase ::
659 getNum_LogText_OutputPorts() const
660 {
661 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_LogText_OutputPort));
662 }
663
664#endif
665
666 FwIndexType ComQueueComponentBase ::
667 getNum_Time_OutputPorts() const
668 {
669 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_Time_OutputPort));
670 }
671
672 FwIndexType ComQueueComponentBase ::
673 getNum_Tlm_OutputPorts() const
674 {
675 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_Tlm_OutputPort));
676 }
677
678 // ----------------------------------------------------------------------
679 // Getters for numbers of typed output ports
680 // ----------------------------------------------------------------------
681
682 FwIndexType ComQueueComponentBase ::
683 getNum_buffQueueSend_OutputPorts() const
684 {
685 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_buffQueueSend_OutputPort));
686 }
687
688 FwIndexType ComQueueComponentBase ::
689 getNum_comQueueSend_OutputPorts() const
690 {
691 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_comQueueSend_OutputPort));
692 }
693
694 FwIndexType ComQueueComponentBase ::
695 getNum_deallocate_OutputPorts() const
696 {
697 return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_deallocate_OutputPort));
698 }
699
700 // ----------------------------------------------------------------------
701 // Connection status queries for special output ports
702 // ----------------------------------------------------------------------
703
704 bool ComQueueComponentBase ::
705 isConnected_Log_OutputPort(FwIndexType portNum)
706 {
707 FW_ASSERT(
708 portNum < this->getNum_Log_OutputPorts(),
709 static_cast<FwAssertArgType>(portNum)
710 );
711
712 return this->m_Log_OutputPort[portNum].isConnected();
713 }
714
715#if FW_ENABLE_TEXT_LOGGING == 1
716
717 bool ComQueueComponentBase ::
718 isConnected_LogText_OutputPort(FwIndexType portNum)
719 {
720 FW_ASSERT(
721 portNum < this->getNum_LogText_OutputPorts(),
722 static_cast<FwAssertArgType>(portNum)
723 );
724
725 return this->m_LogText_OutputPort[portNum].isConnected();
726 }
727
728#endif
729
730 bool ComQueueComponentBase ::
731 isConnected_Time_OutputPort(FwIndexType portNum)
732 {
733 FW_ASSERT(
734 portNum < this->getNum_Time_OutputPorts(),
735 static_cast<FwAssertArgType>(portNum)
736 );
737
738 return this->m_Time_OutputPort[portNum].isConnected();
739 }
740
741 bool ComQueueComponentBase ::
742 isConnected_Tlm_OutputPort(FwIndexType portNum)
743 {
744 FW_ASSERT(
745 portNum < this->getNum_Tlm_OutputPorts(),
746 static_cast<FwAssertArgType>(portNum)
747 );
748
749 return this->m_Tlm_OutputPort[portNum].isConnected();
750 }
751
752 // ----------------------------------------------------------------------
753 // Connection status queries for typed output ports
754 // ----------------------------------------------------------------------
755
756 bool ComQueueComponentBase ::
757 isConnected_buffQueueSend_OutputPort(FwIndexType portNum)
758 {
759 FW_ASSERT(
760 portNum < this->getNum_buffQueueSend_OutputPorts(),
761 static_cast<FwAssertArgType>(portNum)
762 );
763
764 return this->m_buffQueueSend_OutputPort[portNum].isConnected();
765 }
766
767 bool ComQueueComponentBase ::
768 isConnected_comQueueSend_OutputPort(FwIndexType portNum)
769 {
770 FW_ASSERT(
771 portNum < this->getNum_comQueueSend_OutputPorts(),
772 static_cast<FwAssertArgType>(portNum)
773 );
774
775 return this->m_comQueueSend_OutputPort[portNum].isConnected();
776 }
777
778 bool ComQueueComponentBase ::
779 isConnected_deallocate_OutputPort(FwIndexType portNum)
780 {
781 FW_ASSERT(
782 portNum < this->getNum_deallocate_OutputPorts(),
783 static_cast<FwAssertArgType>(portNum)
784 );
785
786 return this->m_deallocate_OutputPort[portNum].isConnected();
787 }
788
789 // ----------------------------------------------------------------------
790 // Port handler base-class functions for typed input ports
791 //
792 // Call these functions directly to bypass the corresponding ports
793 // ----------------------------------------------------------------------
794
795 void ComQueueComponentBase ::
796 buffQueueIn_handlerBase(
797 FwIndexType portNum,
798 Fw::Buffer& fwBuffer
799 )
800 {
801 // Make sure port number is valid
802 FW_ASSERT(
803 portNum < this->getNum_buffQueueIn_InputPorts(),
804 static_cast<FwAssertArgType>(portNum)
805 );
806
807 // Call pre-message hook
808 buffQueueIn_preMsgHook(
809 portNum,
810 fwBuffer
811 );
812 ComponentIpcSerializableBuffer msg;
814
815 // Serialize message ID
816 _status = msg.serialize(
817 static_cast<FwEnumStoreType>(BUFFQUEUEIN_BUFFERSEND)
818 );
819 FW_ASSERT(
820 _status == Fw::FW_SERIALIZE_OK,
821 static_cast<FwAssertArgType>(_status)
822 );
823
824 // Serialize port number
825 _status = msg.serialize(portNum);
826 FW_ASSERT(
827 _status == Fw::FW_SERIALIZE_OK,
828 static_cast<FwAssertArgType>(_status)
829 );
830
831 // Serialize argument fwBuffer
832 _status = msg.serialize(fwBuffer);
833 FW_ASSERT(
834 _status == Fw::FW_SERIALIZE_OK,
835 static_cast<FwAssertArgType>(_status)
836 );
837
838 // Send message
840 Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);
841
842 if (qStatus == Os::Queue::Status::FULL) {
843 this->buffQueueIn_overflowHook(portNum, fwBuffer);
844 return;
845 }
846
847 FW_ASSERT(
848 qStatus == Os::Queue::OP_OK,
849 static_cast<FwAssertArgType>(qStatus)
850 );
851 }
852
853 void ComQueueComponentBase ::
854 comQueueIn_handlerBase(
855 FwIndexType portNum,
856 Fw::ComBuffer& data,
857 U32 context
858 )
859 {
860 // Make sure port number is valid
861 FW_ASSERT(
862 portNum < this->getNum_comQueueIn_InputPorts(),
863 static_cast<FwAssertArgType>(portNum)
864 );
865
866 // Call pre-message hook
867 comQueueIn_preMsgHook(
868 portNum,
869 data,
870 context
871 );
872 ComponentIpcSerializableBuffer msg;
874
875 // Serialize message ID
876 _status = msg.serialize(
877 static_cast<FwEnumStoreType>(COMQUEUEIN_COM)
878 );
879 FW_ASSERT(
880 _status == Fw::FW_SERIALIZE_OK,
881 static_cast<FwAssertArgType>(_status)
882 );
883
884 // Serialize port number
885 _status = msg.serialize(portNum);
886 FW_ASSERT(
887 _status == Fw::FW_SERIALIZE_OK,
888 static_cast<FwAssertArgType>(_status)
889 );
890
891 // Serialize argument data
892 _status = msg.serialize(data);
893 FW_ASSERT(
894 _status == Fw::FW_SERIALIZE_OK,
895 static_cast<FwAssertArgType>(_status)
896 );
897
898 // Serialize argument context
899 _status = msg.serialize(context);
900 FW_ASSERT(
901 _status == Fw::FW_SERIALIZE_OK,
902 static_cast<FwAssertArgType>(_status)
903 );
904
905 // Send message
907 Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);
908
909 if (qStatus == Os::Queue::Status::FULL) {
910 this->incNumMsgDropped();
911 return;
912 }
913
914 FW_ASSERT(
915 qStatus == Os::Queue::OP_OK,
916 static_cast<FwAssertArgType>(qStatus)
917 );
918 }
919
920 void ComQueueComponentBase ::
921 comStatusIn_handlerBase(
922 FwIndexType portNum,
923 Fw::Success& condition
924 )
925 {
926 // Make sure port number is valid
927 FW_ASSERT(
928 portNum < this->getNum_comStatusIn_InputPorts(),
929 static_cast<FwAssertArgType>(portNum)
930 );
931
932 // Call pre-message hook
933 comStatusIn_preMsgHook(
934 portNum,
935 condition
936 );
937 ComponentIpcSerializableBuffer msg;
939
940 // Serialize message ID
941 _status = msg.serialize(
942 static_cast<FwEnumStoreType>(COMSTATUSIN_SUCCESSCONDITION)
943 );
944 FW_ASSERT(
945 _status == Fw::FW_SERIALIZE_OK,
946 static_cast<FwAssertArgType>(_status)
947 );
948
949 // Serialize port number
950 _status = msg.serialize(portNum);
951 FW_ASSERT(
952 _status == Fw::FW_SERIALIZE_OK,
953 static_cast<FwAssertArgType>(_status)
954 );
955
956 // Serialize argument condition
957 _status = msg.serialize(condition);
958 FW_ASSERT(
959 _status == Fw::FW_SERIALIZE_OK,
960 static_cast<FwAssertArgType>(_status)
961 );
962
963 // Send message
965 Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);
966
967 FW_ASSERT(
968 qStatus == Os::Queue::OP_OK,
969 static_cast<FwAssertArgType>(qStatus)
970 );
971 }
972
973 void ComQueueComponentBase ::
974 run_handlerBase(
975 FwIndexType portNum,
976 U32 context
977 )
978 {
979 // Make sure port number is valid
980 FW_ASSERT(
981 portNum < this->getNum_run_InputPorts(),
982 static_cast<FwAssertArgType>(portNum)
983 );
984
985 // Call pre-message hook
986 run_preMsgHook(
987 portNum,
988 context
989 );
990 ComponentIpcSerializableBuffer msg;
992
993 // Serialize message ID
994 _status = msg.serialize(
995 static_cast<FwEnumStoreType>(RUN_SCHED)
996 );
997 FW_ASSERT(
998 _status == Fw::FW_SERIALIZE_OK,
999 static_cast<FwAssertArgType>(_status)
1000 );
1001
1002 // Serialize port number
1003 _status = msg.serialize(portNum);
1004 FW_ASSERT(
1005 _status == Fw::FW_SERIALIZE_OK,
1006 static_cast<FwAssertArgType>(_status)
1007 );
1008
1009 // Serialize argument context
1010 _status = msg.serialize(context);
1011 FW_ASSERT(
1012 _status == Fw::FW_SERIALIZE_OK,
1013 static_cast<FwAssertArgType>(_status)
1014 );
1015
1016 // Send message
1018 Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);
1019
1020 if (qStatus == Os::Queue::Status::FULL) {
1021 this->incNumMsgDropped();
1022 return;
1023 }
1024
1025 FW_ASSERT(
1026 qStatus == Os::Queue::OP_OK,
1027 static_cast<FwAssertArgType>(qStatus)
1028 );
1029 }
1030
1031 // ----------------------------------------------------------------------
1032 // Pre-message hooks for typed async input ports
1033 //
1034 // Each of these functions is invoked just before processing a message
1035 // on the corresponding port. By default, they do nothing. You can
1036 // override them to provide specific pre-message behavior.
1037 // ----------------------------------------------------------------------
1038
1039 void ComQueueComponentBase ::
1040 buffQueueIn_preMsgHook(
1041 FwIndexType portNum,
1042 Fw::Buffer& fwBuffer
1043 )
1044 {
1045 // Default: no-op
1046 }
1047
1048 void ComQueueComponentBase ::
1049 comQueueIn_preMsgHook(
1050 FwIndexType portNum,
1051 Fw::ComBuffer& data,
1052 U32 context
1053 )
1054 {
1055 // Default: no-op
1056 }
1057
1058 void ComQueueComponentBase ::
1059 comStatusIn_preMsgHook(
1060 FwIndexType portNum,
1061 Fw::Success& condition
1062 )
1063 {
1064 // Default: no-op
1065 }
1066
1067 void ComQueueComponentBase ::
1068 run_preMsgHook(
1069 FwIndexType portNum,
1070 U32 context
1071 )
1072 {
1073 // Default: no-op
1074 }
1075
1076 // ----------------------------------------------------------------------
1077 // Invocation functions for typed output ports
1078 // ----------------------------------------------------------------------
1079
1080 void ComQueueComponentBase ::
1081 buffQueueSend_out(
1082 FwIndexType portNum,
1083 Fw::Buffer& fwBuffer
1084 )
1085 {
1086 FW_ASSERT(
1087 portNum < this->getNum_buffQueueSend_OutputPorts(),
1088 static_cast<FwAssertArgType>(portNum)
1089 );
1090 this->m_buffQueueSend_OutputPort[portNum].invoke(
1091 fwBuffer
1092 );
1093 }
1094
1095 void ComQueueComponentBase ::
1096 comQueueSend_out(
1097 FwIndexType portNum,
1098 Fw::ComBuffer& data,
1099 U32 context
1100 )
1101 {
1102 FW_ASSERT(
1103 portNum < this->getNum_comQueueSend_OutputPorts(),
1104 static_cast<FwAssertArgType>(portNum)
1105 );
1106 this->m_comQueueSend_OutputPort[portNum].invoke(
1107 data,
1108 context
1109 );
1110 }
1111
1112 void ComQueueComponentBase ::
1113 deallocate_out(
1114 FwIndexType portNum,
1115 Fw::Buffer& fwBuffer
1116 )
1117 {
1118 FW_ASSERT(
1119 portNum < this->getNum_deallocate_OutputPorts(),
1120 static_cast<FwAssertArgType>(portNum)
1121 );
1122 this->m_deallocate_OutputPort[portNum].invoke(
1123 fwBuffer
1124 );
1125 }
1126
1127 // ----------------------------------------------------------------------
1128 // Event logging functions
1129 // ----------------------------------------------------------------------
1130
1131 void ComQueueComponentBase ::
1132 log_WARNING_HI_QueueOverflow(
1133 Svc::QueueType queueType,
1134 U32 index
1135 ) const
1136 {
1137 // Get the time
1138 Fw::Time _logTime;
1139 if (this->m_Time_OutputPort[0].isConnected()) {
1140 this->m_Time_OutputPort[0].invoke(_logTime);
1141 }
1142
1143 FwEventIdType _id = static_cast<FwEventIdType>(0);
1144
1145 _id = this->getIdBase() + EVENTID_QUEUEOVERFLOW;
1146
1147 // Emit the event on the log port
1148 if (this->m_Log_OutputPort[0].isConnected()) {
1149 Fw::LogBuffer _logBuff;
1151
1152#if FW_AMPCS_COMPATIBLE
1153 // Serialize the number of arguments
1154 _status = _logBuff.serialize(static_cast<U8>(2));
1155 FW_ASSERT(
1156 _status == Fw::FW_SERIALIZE_OK,
1157 static_cast<FwAssertArgType>(_status)
1158 );
1159#endif
1160
1161#if FW_AMPCS_COMPATIBLE
1162 // Serialize the argument size
1163 _status = _logBuff.serialize(
1165 );
1166 FW_ASSERT(
1167 _status == Fw::FW_SERIALIZE_OK,
1168 static_cast<FwAssertArgType>(_status)
1169 );
1170#endif
1171 _status = _logBuff.serialize(queueType);
1172 FW_ASSERT(
1173 _status == Fw::FW_SERIALIZE_OK,
1174 static_cast<FwAssertArgType>(_status)
1175 );
1176
1177#if FW_AMPCS_COMPATIBLE
1178 // Serialize the argument size
1179 _status = _logBuff.serialize(
1180 static_cast<U8>(sizeof(U32))
1181 );
1182 FW_ASSERT(
1183 _status == Fw::FW_SERIALIZE_OK,
1184 static_cast<FwAssertArgType>(_status)
1185 );
1186#endif
1187 _status = _logBuff.serialize(index);
1188 FW_ASSERT(
1189 _status == Fw::FW_SERIALIZE_OK,
1190 static_cast<FwAssertArgType>(_status)
1191 );
1192
1193 this->m_Log_OutputPort[0].invoke(
1194 _id,
1195 _logTime,
1197 _logBuff
1198 );
1199 }
1200
1201 // Emit the event on the text log port
1202#if FW_ENABLE_TEXT_LOGGING
1203 if (this->m_LogText_OutputPort[0].isConnected()) {
1204#if FW_OBJECT_NAMES == 1
1205 const char* _formatString =
1206 "(%s) %s: The %s queue at index %" PRIu32 " overflowed";
1207#else
1208 const char* _formatString =
1209 "%s: The %s queue at index %" PRIu32 " overflowed";
1210#endif
1211
1212 Fw::String queueTypeStr;
1213 queueType.toString(queueTypeStr);
1214
1215 Fw::TextLogString _logString;
1216 _logString.format(
1217 _formatString,
1218#if FW_OBJECT_NAMES == 1
1219 this->m_objName.toChar(),
1220#endif
1221 "QueueOverflow ",
1222 queueTypeStr.toChar(),
1223 index
1224 );
1225
1226 this->m_LogText_OutputPort[0].invoke(
1227 _id,
1228 _logTime,
1230 _logString
1231 );
1232 }
1233#endif
1234 }
1235
1236 // ----------------------------------------------------------------------
1237 // Telemetry write functions
1238 // ----------------------------------------------------------------------
1239
1240 void ComQueueComponentBase ::
1241 tlmWrite_comQueueDepth(
1242 const Svc::ComQueueDepth& arg,
1243 Fw::Time _tlmTime
1244 ) const
1245 {
1246 if (this->m_Tlm_OutputPort[0].isConnected()) {
1247 if (
1248 this->m_Time_OutputPort[0].isConnected() &&
1249 (_tlmTime == Fw::ZERO_TIME)
1250 ) {
1251 this->m_Time_OutputPort[0].invoke(_tlmTime);
1252 }
1253
1254 Fw::TlmBuffer _tlmBuff;
1255 Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
1256 FW_ASSERT(
1257 _stat == Fw::FW_SERIALIZE_OK,
1258 static_cast<FwAssertArgType>(_stat)
1259 );
1260
1261 FwChanIdType _id;
1262
1263 _id = this->getIdBase() + CHANNELID_COMQUEUEDEPTH;
1264
1265 this->m_Tlm_OutputPort[0].invoke(
1266 _id,
1267 _tlmTime,
1268 _tlmBuff
1269 );
1270 }
1271 }
1272
1273 void ComQueueComponentBase ::
1274 tlmWrite_buffQueueDepth(
1275 const Svc::BuffQueueDepth& arg,
1276 Fw::Time _tlmTime
1277 ) const
1278 {
1279 if (this->m_Tlm_OutputPort[0].isConnected()) {
1280 if (
1281 this->m_Time_OutputPort[0].isConnected() &&
1282 (_tlmTime == Fw::ZERO_TIME)
1283 ) {
1284 this->m_Time_OutputPort[0].invoke(_tlmTime);
1285 }
1286
1287 Fw::TlmBuffer _tlmBuff;
1288 Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
1289 FW_ASSERT(
1290 _stat == Fw::FW_SERIALIZE_OK,
1291 static_cast<FwAssertArgType>(_stat)
1292 );
1293
1294 FwChanIdType _id;
1295
1296 _id = this->getIdBase() + CHANNELID_BUFFQUEUEDEPTH;
1297
1298 this->m_Tlm_OutputPort[0].invoke(
1299 _id,
1300 _tlmTime,
1301 _tlmBuff
1302 );
1303 }
1304 }
1305
1306 // ----------------------------------------------------------------------
1307 // Time
1308 // ----------------------------------------------------------------------
1309
1310 Fw::Time ComQueueComponentBase ::
1311 getTime()
1312 {
1313 if (this->m_Time_OutputPort[0].isConnected()) {
1314 Fw::Time _time;
1315 this->m_Time_OutputPort[0].invoke(_time);
1316 return _time;
1317 }
1318 else {
1319 return Fw::Time(TB_NONE, 0, 0);
1320 }
1321 }
1322
1323 // ----------------------------------------------------------------------
1324 // Message dispatch functions
1325 // ----------------------------------------------------------------------
1326
1327 Fw::QueuedComponentBase::MsgDispatchStatus ComQueueComponentBase ::
1328 doDispatch()
1329 {
1330 ComponentIpcSerializableBuffer msg;
1331 FwQueuePriorityType priority = 0;
1332
1333 Os::Queue::Status msgStatus = this->m_queue.receive(
1334 msg,
1336 priority
1337 );
1338 FW_ASSERT(
1339 msgStatus == Os::Queue::OP_OK,
1340 static_cast<FwAssertArgType>(msgStatus)
1341 );
1342
1343 // Reset to beginning of buffer
1344 msg.resetDeser();
1345
1346 FwEnumStoreType desMsg = 0;
1347 Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
1348 FW_ASSERT(
1349 deserStatus == Fw::FW_SERIALIZE_OK,
1350 static_cast<FwAssertArgType>(deserStatus)
1351 );
1352
1353 MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
1354
1355 if (msgType == COMQUEUE_COMPONENT_EXIT) {
1356 return MSG_DISPATCH_EXIT;
1357 }
1358
1359 FwIndexType portNum = 0;
1360 deserStatus = msg.deserialize(portNum);
1361 FW_ASSERT(
1362 deserStatus == Fw::FW_SERIALIZE_OK,
1363 static_cast<FwAssertArgType>(deserStatus)
1364 );
1365
1366 switch (msgType) {
1367 // Handle async input port buffQueueIn
1368 case BUFFQUEUEIN_BUFFERSEND: {
1369 // Deserialize argument fwBuffer
1370 Fw::Buffer fwBuffer;
1371 deserStatus = msg.deserialize(fwBuffer);
1372 FW_ASSERT(
1373 deserStatus == Fw::FW_SERIALIZE_OK,
1374 static_cast<FwAssertArgType>(deserStatus)
1375 );
1376 // Call handler function
1377 this->buffQueueIn_handler(
1378 portNum,
1379 fwBuffer
1380 );
1381
1382 break;
1383 }
1384
1385 // Handle async input port comQueueIn
1386 case COMQUEUEIN_COM: {
1387 // Deserialize argument data
1388 Fw::ComBuffer data;
1389 deserStatus = msg.deserialize(data);
1390 FW_ASSERT(
1391 deserStatus == Fw::FW_SERIALIZE_OK,
1392 static_cast<FwAssertArgType>(deserStatus)
1393 );
1394
1395 // Deserialize argument context
1396 U32 context;
1397 deserStatus = msg.deserialize(context);
1398 FW_ASSERT(
1399 deserStatus == Fw::FW_SERIALIZE_OK,
1400 static_cast<FwAssertArgType>(deserStatus)
1401 );
1402 // Call handler function
1403 this->comQueueIn_handler(
1404 portNum,
1405 data,
1406 context
1407 );
1408
1409 break;
1410 }
1411
1412 // Handle async input port comStatusIn
1413 case COMSTATUSIN_SUCCESSCONDITION: {
1414 // Deserialize argument condition
1415 Fw::Success condition;
1416 deserStatus = msg.deserialize(condition);
1417 FW_ASSERT(
1418 deserStatus == Fw::FW_SERIALIZE_OK,
1419 static_cast<FwAssertArgType>(deserStatus)
1420 );
1421 // Call handler function
1422 this->comStatusIn_handler(
1423 portNum,
1424 condition
1425 );
1426
1427 break;
1428 }
1429
1430 // Handle async input port run
1431 case RUN_SCHED: {
1432 // Deserialize argument context
1433 U32 context;
1434 deserStatus = msg.deserialize(context);
1435 FW_ASSERT(
1436 deserStatus == Fw::FW_SERIALIZE_OK,
1437 static_cast<FwAssertArgType>(deserStatus)
1438 );
1439 // Call handler function
1440 this->run_handler(
1441 portNum,
1442 context
1443 );
1444
1445 break;
1446 }
1447
1448 default:
1449 return MSG_DISPATCH_ERROR;
1450 }
1451
1452 return MSG_DISPATCH_OK;
1453 }
1454
1455 // ----------------------------------------------------------------------
1456 // Calls for messages received on typed input ports
1457 // ----------------------------------------------------------------------
1458
1459 void ComQueueComponentBase ::
1460 m_p_buffQueueIn_in(
1461 Fw::PassiveComponentBase* callComp,
1462 FwIndexType portNum,
1463 Fw::Buffer& fwBuffer
1464 )
1465 {
1466 FW_ASSERT(callComp);
1467 ComQueueComponentBase* compPtr = static_cast<ComQueueComponentBase*>(callComp);
1468 compPtr->buffQueueIn_handlerBase(
1469 portNum,
1470 fwBuffer
1471 );
1472 }
1473
1474 void ComQueueComponentBase ::
1475 m_p_comQueueIn_in(
1476 Fw::PassiveComponentBase* callComp,
1477 FwIndexType portNum,
1478 Fw::ComBuffer& data,
1479 U32 context
1480 )
1481 {
1482 FW_ASSERT(callComp);
1483 ComQueueComponentBase* compPtr = static_cast<ComQueueComponentBase*>(callComp);
1484 compPtr->comQueueIn_handlerBase(
1485 portNum,
1486 data,
1487 context
1488 );
1489 }
1490
1491 void ComQueueComponentBase ::
1492 m_p_comStatusIn_in(
1493 Fw::PassiveComponentBase* callComp,
1494 FwIndexType portNum,
1495 Fw::Success& condition
1496 )
1497 {
1498 FW_ASSERT(callComp);
1499 ComQueueComponentBase* compPtr = static_cast<ComQueueComponentBase*>(callComp);
1500 compPtr->comStatusIn_handlerBase(
1501 portNum,
1502 condition
1503 );
1504 }
1505
1506 void ComQueueComponentBase ::
1507 m_p_run_in(
1508 Fw::PassiveComponentBase* callComp,
1509 FwIndexType portNum,
1510 U32 context
1511 )
1512 {
1513 FW_ASSERT(callComp);
1514 ComQueueComponentBase* compPtr = static_cast<ComQueueComponentBase*>(callComp);
1515 compPtr->run_handlerBase(
1516 portNum,
1517 context
1518 );
1519 }
1520
1521}
#define FW_ASSERT(...)
Definition Assert.hpp:14
U8 BYTE
byte type
Definition BasicTypes.h:31
uint8_t U8
8-bit unsigned integer
Definition BasicTypes.h:30
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition BasicTypes.h:70
#define PRI_PlatformIntType
@ TB_NONE
No time base has been established.
Definition FpConfig.h:70
I32 FwEnumStoreType
Definition FpConfig.h:64
PlatformAssertArgType FwAssertArgType
Definition FpConfig.h:39
U32 FwChanIdType
Definition FpConfig.h:95
U32 FwEventIdType
Definition FpConfig.h:103
PlatformSizeType FwSizeType
Definition FpConfig.h:35
PlatformQueuePriorityType FwQueuePriorityType
Definition FpConfig.h:55
PlatformIndexType FwIndexType
Definition FpConfig.h:25
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects)/*#en...
Definition FpConfig.h:148
@ ACTIVE_COMPONENT_EXIT
message to exit active component task
@ SERIALIZED_SIZE
The size of the serial representations of the port arguments.
@ SERIALIZED_SIZE
The size of the serial representations of the port arguments.
Definition ComPortAc.hpp:37
@ SERIALIZED_SIZE
The size of the serial representations of the port arguments.
@ WARNING_HI
A serious but recoverable event.
void init()
Object initializer.
Definition ObjBase.cpp:27
const char * toChar() const
NATIVE_UINT_TYPE SizeType
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
void format(const CHAR *formatString,...)
write formatted string to buffer
const char * toChar() const
Definition String.hpp:50
Success/Failure.
BlockingType
message type
Definition Queue.hpp:44
@ BLOCKING
Message will block until space is available.
Definition Queue.hpp:45
@ NONBLOCKING
Message will return with status when space is unavailable.
Definition Queue.hpp:46
Status
status returned from the queue send function
Definition Queue.hpp:30
@ FULL
queue was full when attempting to send a message
Definition Queue.hpp:39
@ OP_OK
message sent/received okay
Definition Queue.hpp:31
Array of queue depths for Fw::Buffer types.
Array of queue depths for Fw::Com types.
@ SERIALIZED_SIZE
The size of the serial representations of the port arguments.
An enumeration of queue data types.
@ SERIALIZED_SIZE
The size of the serial representation.
SerializeStatus
forward declaration for string
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
const Time ZERO_TIME
Definition Time.cpp:5