F´ Flight Software - C/C++ Documentation NASA-v1.6.0
A framework for building embedded system applications to NASA flight quality standards.
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
TlmChanComponentAc.cpp
Go to the documentation of this file.
1// ======================================================================
2// \title TlmChanComponentAc.cpp
3// \author Generated by fpp-to-cpp
4// \brief cpp file for TlmChan 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 Svc {
16
17 namespace {
18 enum MsgTypeEnum {
20 RUN_SCHED,
21 PINGIN_PING,
22 };
23
24 // Get the max size by doing a union of the input and internal port serialization sizes
25 union BuffUnion {
30 };
31
32 // Define a message buffer class large enough to handle all the
33 // asynchronous inputs to the component
34 class ComponentIpcSerializableBuffer :
36 {
37
38 public:
39
40 enum {
41 // Max. message size = size of data + message id + port
42 SERIALIZATION_SIZE =
43 sizeof(BuffUnion) +
44 sizeof(NATIVE_INT_TYPE) +
45 sizeof(NATIVE_INT_TYPE)
46 };
47
48 NATIVE_UINT_TYPE getBuffCapacity() const {
49 return sizeof(m_buff);
50 }
51
52 U8* getBuffAddr() {
53 return m_buff;
54 }
55
56 const U8* getBuffAddr() const {
57 return m_buff;
58 }
59
60 private:
61 // Should be the max of all the input ports serialized sizes...
62 U8 m_buff[SERIALIZATION_SIZE];
63
64 };
65 }
66
67 // ----------------------------------------------------------------------
68 // Component initialization
69 // ----------------------------------------------------------------------
70
71 void TlmChanComponentBase ::
72 init(
73 NATIVE_INT_TYPE queueDepth,
74 NATIVE_INT_TYPE instance
75 )
76 {
77 // Initialize base class
79
80 // Connect input port Run
81 for (
82 PlatformIntType port = 0;
83 port < static_cast<PlatformIntType>(this->getNum_Run_InputPorts());
84 port++
85 ) {
86 this->m_Run_InputPort[port].init();
87 this->m_Run_InputPort[port].addCallComp(
88 this,
89 m_p_Run_in
90 );
91 this->m_Run_InputPort[port].setPortNum(port);
92
93#if FW_OBJECT_NAMES == 1
94 char portName[120];
95 (void) snprintf(
96 portName,
97 sizeof(portName),
98 "%s_Run_InputPort[%" PRI_PlatformIntType "]",
99 this->m_objName,
100 port
101 );
102 this->m_Run_InputPort[port].setObjName(portName);
103#endif
104 }
105
106 // Connect input port TlmGet
107 for (
108 PlatformIntType port = 0;
109 port < static_cast<PlatformIntType>(this->getNum_TlmGet_InputPorts());
110 port++
111 ) {
112 this->m_TlmGet_InputPort[port].init();
113 this->m_TlmGet_InputPort[port].addCallComp(
114 this,
115 m_p_TlmGet_in
116 );
117 this->m_TlmGet_InputPort[port].setPortNum(port);
118
119#if FW_OBJECT_NAMES == 1
120 char portName[120];
121 (void) snprintf(
122 portName,
123 sizeof(portName),
124 "%s_TlmGet_InputPort[%" PRI_PlatformIntType "]",
125 this->m_objName,
126 port
127 );
128 this->m_TlmGet_InputPort[port].setObjName(portName);
129#endif
130 }
131
132 // Connect input port TlmRecv
133 for (
134 PlatformIntType port = 0;
135 port < static_cast<PlatformIntType>(this->getNum_TlmRecv_InputPorts());
136 port++
137 ) {
138 this->m_TlmRecv_InputPort[port].init();
139 this->m_TlmRecv_InputPort[port].addCallComp(
140 this,
141 m_p_TlmRecv_in
142 );
143 this->m_TlmRecv_InputPort[port].setPortNum(port);
144
145#if FW_OBJECT_NAMES == 1
146 char portName[120];
147 (void) snprintf(
148 portName,
149 sizeof(portName),
150 "%s_TlmRecv_InputPort[%" PRI_PlatformIntType "]",
151 this->m_objName,
152 port
153 );
154 this->m_TlmRecv_InputPort[port].setObjName(portName);
155#endif
156 }
157
158 // Connect input port pingIn
159 for (
160 PlatformIntType port = 0;
161 port < static_cast<PlatformIntType>(this->getNum_pingIn_InputPorts());
162 port++
163 ) {
164 this->m_pingIn_InputPort[port].init();
165 this->m_pingIn_InputPort[port].addCallComp(
166 this,
167 m_p_pingIn_in
168 );
169 this->m_pingIn_InputPort[port].setPortNum(port);
170
171#if FW_OBJECT_NAMES == 1
172 char portName[120];
173 (void) snprintf(
174 portName,
175 sizeof(portName),
176 "%s_pingIn_InputPort[%" PRI_PlatformIntType "]",
177 this->m_objName,
178 port
179 );
180 this->m_pingIn_InputPort[port].setObjName(portName);
181#endif
182 }
183
184 // Connect output port PktSend
185 for (
186 PlatformIntType port = 0;
187 port < static_cast<PlatformIntType>(this->getNum_PktSend_OutputPorts());
188 port++
189 ) {
190 this->m_PktSend_OutputPort[port].init();
191
192#if FW_OBJECT_NAMES == 1
193 char portName[120];
194 (void) snprintf(
195 portName,
196 sizeof(portName),
197 "%s_PktSend_OutputPort[%" PRI_PlatformIntType "]",
198 this->m_objName,
199 port
200 );
201 this->m_PktSend_OutputPort[port].setObjName(portName);
202#endif
203 }
204
205 // Connect output port pingOut
206 for (
207 PlatformIntType port = 0;
208 port < static_cast<PlatformIntType>(this->getNum_pingOut_OutputPorts());
209 port++
210 ) {
211 this->m_pingOut_OutputPort[port].init();
212
213#if FW_OBJECT_NAMES == 1
214 char portName[120];
215 (void) snprintf(
216 portName,
217 sizeof(portName),
218 "%s_pingOut_OutputPort[%" PRI_PlatformIntType "]",
219 this->m_objName,
220 port
221 );
222 this->m_pingOut_OutputPort[port].setObjName(portName);
223#endif
224 }
225
226 Os::Queue::QueueStatus qStat = this->createQueue(
227 queueDepth,
228 ComponentIpcSerializableBuffer::SERIALIZATION_SIZE
229 );
230 FW_ASSERT(
231 Os::Queue::QUEUE_OK == qStat,
232 static_cast<FwAssertArgType>(qStat)
233 );
234 }
235
236 // ----------------------------------------------------------------------
237 // Getters for typed input ports
238 // ----------------------------------------------------------------------
239
240 Svc::InputSchedPort* TlmChanComponentBase ::
241 get_Run_InputPort(NATIVE_INT_TYPE portNum)
242 {
243 FW_ASSERT(
244 portNum < this->getNum_Run_InputPorts(),
245 static_cast<FwAssertArgType>(portNum)
246 );
247
248 return &this->m_Run_InputPort[portNum];
249 }
250
251 Fw::InputTlmGetPort* TlmChanComponentBase ::
252 get_TlmGet_InputPort(NATIVE_INT_TYPE portNum)
253 {
254 FW_ASSERT(
255 portNum < this->getNum_TlmGet_InputPorts(),
256 static_cast<FwAssertArgType>(portNum)
257 );
258
259 return &this->m_TlmGet_InputPort[portNum];
260 }
261
262 Fw::InputTlmPort* TlmChanComponentBase ::
263 get_TlmRecv_InputPort(NATIVE_INT_TYPE portNum)
264 {
265 FW_ASSERT(
266 portNum < this->getNum_TlmRecv_InputPorts(),
267 static_cast<FwAssertArgType>(portNum)
268 );
269
270 return &this->m_TlmRecv_InputPort[portNum];
271 }
272
273 Svc::InputPingPort* TlmChanComponentBase ::
274 get_pingIn_InputPort(NATIVE_INT_TYPE portNum)
275 {
276 FW_ASSERT(
277 portNum < this->getNum_pingIn_InputPorts(),
278 static_cast<FwAssertArgType>(portNum)
279 );
280
281 return &this->m_pingIn_InputPort[portNum];
282 }
283
284 // ----------------------------------------------------------------------
285 // Connect typed input ports to typed output ports
286 // ----------------------------------------------------------------------
287
288 void TlmChanComponentBase ::
289 set_PktSend_OutputPort(
290 NATIVE_INT_TYPE portNum,
291 Fw::InputComPort* port
292 )
293 {
294 FW_ASSERT(
295 portNum < this->getNum_PktSend_OutputPorts(),
296 static_cast<FwAssertArgType>(portNum)
297 );
298
299 this->m_PktSend_OutputPort[portNum].addCallPort(port);
300 }
301
302 void TlmChanComponentBase ::
303 set_pingOut_OutputPort(
304 NATIVE_INT_TYPE portNum,
306 )
307 {
308 FW_ASSERT(
309 portNum < this->getNum_pingOut_OutputPorts(),
310 static_cast<FwAssertArgType>(portNum)
311 );
312
313 this->m_pingOut_OutputPort[portNum].addCallPort(port);
314 }
315
316#if FW_PORT_SERIALIZATION
317
318 // ----------------------------------------------------------------------
319 // Connect serial input ports to typed output ports
320 // ----------------------------------------------------------------------
321
322 void TlmChanComponentBase ::
323 set_PktSend_OutputPort(
324 NATIVE_INT_TYPE portNum,
325 Fw::InputSerializePort* port
326 )
327 {
328 FW_ASSERT(
329 portNum < this->getNum_PktSend_OutputPorts(),
330 static_cast<FwAssertArgType>(portNum)
331 );
332
333 this->m_PktSend_OutputPort[portNum].registerSerialPort(port);
334 }
335
336 void TlmChanComponentBase ::
337 set_pingOut_OutputPort(
338 NATIVE_INT_TYPE portNum,
339 Fw::InputSerializePort* port
340 )
341 {
342 FW_ASSERT(
343 portNum < this->getNum_pingOut_OutputPorts(),
344 static_cast<FwAssertArgType>(portNum)
345 );
346
347 this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
348 }
349
350#endif
351
352 // ----------------------------------------------------------------------
353 // Component construction and destruction
354 // ----------------------------------------------------------------------
355
356 TlmChanComponentBase ::
357 TlmChanComponentBase(const char* compName) :
358 Fw::ActiveComponentBase(compName)
359 {
360
361 }
362
363 TlmChanComponentBase ::
364 ~TlmChanComponentBase()
365 {
366
367 }
368
369 // ----------------------------------------------------------------------
370 // Getters for numbers of typed input ports
371 // ----------------------------------------------------------------------
372
373 NATIVE_INT_TYPE TlmChanComponentBase ::
374 getNum_Run_InputPorts()
375 {
376 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_Run_InputPort));
377 }
378
379 NATIVE_INT_TYPE TlmChanComponentBase ::
380 getNum_TlmGet_InputPorts()
381 {
382 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_TlmGet_InputPort));
383 }
384
385 NATIVE_INT_TYPE TlmChanComponentBase ::
386 getNum_TlmRecv_InputPorts()
387 {
388 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_TlmRecv_InputPort));
389 }
390
391 NATIVE_INT_TYPE TlmChanComponentBase ::
392 getNum_pingIn_InputPorts()
393 {
394 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_pingIn_InputPort));
395 }
396
397 // ----------------------------------------------------------------------
398 // Getters for numbers of typed output ports
399 // ----------------------------------------------------------------------
400
401 NATIVE_INT_TYPE TlmChanComponentBase ::
402 getNum_PktSend_OutputPorts()
403 {
404 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_PktSend_OutputPort));
405 }
406
407 NATIVE_INT_TYPE TlmChanComponentBase ::
408 getNum_pingOut_OutputPorts()
409 {
410 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_pingOut_OutputPort));
411 }
412
413 // ----------------------------------------------------------------------
414 // Connection status queries for typed output ports
415 // ----------------------------------------------------------------------
416
417 bool TlmChanComponentBase ::
418 isConnected_PktSend_OutputPort(NATIVE_INT_TYPE portNum)
419 {
420 FW_ASSERT(
421 portNum < this->getNum_PktSend_OutputPorts(),
422 static_cast<FwAssertArgType>(portNum)
423 );
424
425 return this->m_PktSend_OutputPort[portNum].isConnected();
426 }
427
428 bool TlmChanComponentBase ::
429 isConnected_pingOut_OutputPort(NATIVE_INT_TYPE portNum)
430 {
431 FW_ASSERT(
432 portNum < this->getNum_pingOut_OutputPorts(),
433 static_cast<FwAssertArgType>(portNum)
434 );
435
436 return this->m_pingOut_OutputPort[portNum].isConnected();
437 }
438
439 // ----------------------------------------------------------------------
440 // Port handler base-class functions for typed input ports
441 //
442 // Call these functions directly to bypass the corresponding ports
443 // ----------------------------------------------------------------------
444
445 void TlmChanComponentBase ::
446 Run_handlerBase(
447 NATIVE_INT_TYPE portNum,
448 NATIVE_UINT_TYPE context
449 )
450 {
451 // Make sure port number is valid
452 FW_ASSERT(
453 portNum < this->getNum_Run_InputPorts(),
454 static_cast<FwAssertArgType>(portNum)
455 );
456
457 // Call pre-message hook
458 Run_preMsgHook(
459 portNum,
460 context
461 );
462 ComponentIpcSerializableBuffer msg;
464
465 // Serialize message ID
466 _status = msg.serialize(
467 static_cast<NATIVE_INT_TYPE>(RUN_SCHED)
468 );
469 FW_ASSERT(
470 _status == Fw::FW_SERIALIZE_OK,
471 static_cast<FwAssertArgType>(_status)
472 );
473
474 // Serialize port number
475 _status = msg.serialize(portNum);
476 FW_ASSERT(
477 _status == Fw::FW_SERIALIZE_OK,
478 static_cast<FwAssertArgType>(_status)
479 );
480
481 // Serialize argument context
482 _status = msg.serialize(context);
483 FW_ASSERT(
484 _status == Fw::FW_SERIALIZE_OK,
485 static_cast<FwAssertArgType>(_status)
486 );
487
488 // Send message
490 Os::Queue::QueueStatus qStatus = this->m_queue.send(msg, 0, _block);
491
492 FW_ASSERT(
493 qStatus == Os::Queue::QUEUE_OK,
494 static_cast<FwAssertArgType>(qStatus)
495 );
496 }
497
498 void TlmChanComponentBase ::
499 TlmGet_handlerBase(
500 NATIVE_INT_TYPE portNum,
501 FwChanIdType id,
502 Fw::Time& timeTag,
503 Fw::TlmBuffer& val
504 )
505 {
506 // Make sure port number is valid
507 FW_ASSERT(
508 portNum < this->getNum_TlmGet_InputPorts(),
509 static_cast<FwAssertArgType>(portNum)
510 );
511
512 // Lock guard mutex before calling
513 this->lock();
514
515 // Down call to pure virtual handler method implemented in Impl class
516 this->TlmGet_handler(
517 portNum,
518 id,
519 timeTag,
520 val
521 );
522
523 // Unlock guard mutex
524 this->unLock();
525 }
526
527 void TlmChanComponentBase ::
528 TlmRecv_handlerBase(
529 NATIVE_INT_TYPE portNum,
530 FwChanIdType id,
531 Fw::Time& timeTag,
532 Fw::TlmBuffer& val
533 )
534 {
535 // Make sure port number is valid
536 FW_ASSERT(
537 portNum < this->getNum_TlmRecv_InputPorts(),
538 static_cast<FwAssertArgType>(portNum)
539 );
540
541 // Lock guard mutex before calling
542 this->lock();
543
544 // Down call to pure virtual handler method implemented in Impl class
545 this->TlmRecv_handler(
546 portNum,
547 id,
548 timeTag,
549 val
550 );
551
552 // Unlock guard mutex
553 this->unLock();
554 }
555
556 void TlmChanComponentBase ::
557 pingIn_handlerBase(
558 NATIVE_INT_TYPE portNum,
559 U32 key
560 )
561 {
562 // Make sure port number is valid
563 FW_ASSERT(
564 portNum < this->getNum_pingIn_InputPorts(),
565 static_cast<FwAssertArgType>(portNum)
566 );
567
568 // Call pre-message hook
569 pingIn_preMsgHook(
570 portNum,
571 key
572 );
573 ComponentIpcSerializableBuffer msg;
575
576 // Serialize message ID
577 _status = msg.serialize(
578 static_cast<NATIVE_INT_TYPE>(PINGIN_PING)
579 );
580 FW_ASSERT(
581 _status == Fw::FW_SERIALIZE_OK,
582 static_cast<FwAssertArgType>(_status)
583 );
584
585 // Serialize port number
586 _status = msg.serialize(portNum);
587 FW_ASSERT(
588 _status == Fw::FW_SERIALIZE_OK,
589 static_cast<FwAssertArgType>(_status)
590 );
591
592 // Serialize argument key
593 _status = msg.serialize(key);
594 FW_ASSERT(
595 _status == Fw::FW_SERIALIZE_OK,
596 static_cast<FwAssertArgType>(_status)
597 );
598
599 // Send message
601 Os::Queue::QueueStatus qStatus = this->m_queue.send(msg, 0, _block);
602
603 FW_ASSERT(
604 qStatus == Os::Queue::QUEUE_OK,
605 static_cast<FwAssertArgType>(qStatus)
606 );
607 }
608
609 // ----------------------------------------------------------------------
610 // Pre-message hooks for typed async input ports
611 //
612 // Each of these functions is invoked just before processing a message
613 // on the corresponding port. By default, they do nothing. You can
614 // override them to provide specific pre-message behavior.
615 // ----------------------------------------------------------------------
616
617 void TlmChanComponentBase ::
618 Run_preMsgHook(
619 NATIVE_INT_TYPE portNum,
620 NATIVE_UINT_TYPE context
621 )
622 {
623 // Default: no-op
624 }
625
626 void TlmChanComponentBase ::
627 pingIn_preMsgHook(
628 NATIVE_INT_TYPE portNum,
629 U32 key
630 )
631 {
632 // Default: no-op
633 }
634
635 // ----------------------------------------------------------------------
636 // Invocation functions for typed output ports
637 // ----------------------------------------------------------------------
638
639 void TlmChanComponentBase ::
640 PktSend_out(
641 NATIVE_INT_TYPE portNum,
642 Fw::ComBuffer& data,
643 U32 context
644 )
645 {
646 FW_ASSERT(
647 portNum < this->getNum_PktSend_OutputPorts(),
648 static_cast<FwAssertArgType>(portNum)
649 );
650 this->m_PktSend_OutputPort[portNum].invoke(
651 data,
652 context
653 );
654 }
655
656 void TlmChanComponentBase ::
657 pingOut_out(
658 NATIVE_INT_TYPE portNum,
659 U32 key
660 )
661 {
662 FW_ASSERT(
663 portNum < this->getNum_pingOut_OutputPorts(),
664 static_cast<FwAssertArgType>(portNum)
665 );
666 this->m_pingOut_OutputPort[portNum].invoke(
667 key
668 );
669 }
670
671 // ----------------------------------------------------------------------
672 // Mutex operations for guarded ports
673 //
674 // You can override these operations to provide more sophisticated
675 // synchronization
676 // ----------------------------------------------------------------------
677
678 void TlmChanComponentBase ::
679 lock()
680 {
681 this->m_guardedPortMutex.lock();
682 }
683
684 void TlmChanComponentBase ::
685 unLock()
686 {
687 this->m_guardedPortMutex.unLock();
688 }
689
690 // ----------------------------------------------------------------------
691 // Message dispatch functions
692 // ----------------------------------------------------------------------
693
694 Fw::QueuedComponentBase::MsgDispatchStatus TlmChanComponentBase ::
695 doDispatch()
696 {
697 ComponentIpcSerializableBuffer msg;
698 NATIVE_INT_TYPE priority = 0;
699
700 Os::Queue::QueueStatus msgStatus = this->m_queue.receive(
701 msg,
702 priority,
704 );
705 FW_ASSERT(
706 msgStatus == Os::Queue::QUEUE_OK,
707 static_cast<FwAssertArgType>(msgStatus)
708 );
709
710 // Reset to beginning of buffer
711 msg.resetDeser();
712
713 NATIVE_INT_TYPE desMsg = 0;
714 Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
715 FW_ASSERT(
716 deserStatus == Fw::FW_SERIALIZE_OK,
717 static_cast<FwAssertArgType>(deserStatus)
718 );
719
720 MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
721
722 if (msgType == TLMCHAN_COMPONENT_EXIT) {
723 return MSG_DISPATCH_EXIT;
724 }
725
726 NATIVE_INT_TYPE portNum = 0;
727 deserStatus = msg.deserialize(portNum);
728 FW_ASSERT(
729 deserStatus == Fw::FW_SERIALIZE_OK,
730 static_cast<FwAssertArgType>(deserStatus)
731 );
732
733 switch (msgType) {
734 // Handle async input port Run
735 case RUN_SCHED: {
736 // Deserialize argument context
737 NATIVE_UINT_TYPE context;
738 deserStatus = msg.deserialize(context);
739 FW_ASSERT(
740 deserStatus == Fw::FW_SERIALIZE_OK,
741 static_cast<FwAssertArgType>(deserStatus)
742 );
743 // Call handler function
744 this->Run_handler(
745 portNum,
746 context
747 );
748
749 break;
750 }
751
752 // Handle async input port pingIn
753 case PINGIN_PING: {
754 // Deserialize argument key
755 U32 key;
756 deserStatus = msg.deserialize(key);
757 FW_ASSERT(
758 deserStatus == Fw::FW_SERIALIZE_OK,
759 static_cast<FwAssertArgType>(deserStatus)
760 );
761 // Call handler function
762 this->pingIn_handler(
763 portNum,
764 key
765 );
766
767 break;
768 }
769
770 default:
771 return MSG_DISPATCH_ERROR;
772 }
773
774 return MSG_DISPATCH_OK;
775 }
776
777 // ----------------------------------------------------------------------
778 // Calls for messages received on typed input ports
779 // ----------------------------------------------------------------------
780
781 void TlmChanComponentBase ::
782 m_p_Run_in(
783 Fw::PassiveComponentBase* callComp,
784 NATIVE_INT_TYPE portNum,
785 NATIVE_UINT_TYPE context
786 )
787 {
788 FW_ASSERT(callComp);
789 TlmChanComponentBase* compPtr = static_cast<TlmChanComponentBase*>(callComp);
790 compPtr->Run_handlerBase(
791 portNum,
792 context
793 );
794 }
795
796 void TlmChanComponentBase ::
797 m_p_TlmGet_in(
798 Fw::PassiveComponentBase* callComp,
799 NATIVE_INT_TYPE portNum,
800 FwChanIdType id,
801 Fw::Time& timeTag,
802 Fw::TlmBuffer& val
803 )
804 {
805 FW_ASSERT(callComp);
806 TlmChanComponentBase* compPtr = static_cast<TlmChanComponentBase*>(callComp);
807 compPtr->TlmGet_handlerBase(
808 portNum,
809 id,
810 timeTag,
811 val
812 );
813 }
814
815 void TlmChanComponentBase ::
816 m_p_TlmRecv_in(
817 Fw::PassiveComponentBase* callComp,
818 NATIVE_INT_TYPE portNum,
819 FwChanIdType id,
820 Fw::Time& timeTag,
821 Fw::TlmBuffer& val
822 )
823 {
824 FW_ASSERT(callComp);
825 TlmChanComponentBase* compPtr = static_cast<TlmChanComponentBase*>(callComp);
826 compPtr->TlmRecv_handlerBase(
827 portNum,
828 id,
829 timeTag,
830 val
831 );
832 }
833
834 void TlmChanComponentBase ::
835 m_p_pingIn_in(
836 Fw::PassiveComponentBase* callComp,
837 NATIVE_INT_TYPE portNum,
838 U32 key
839 )
840 {
841 FW_ASSERT(callComp);
842 TlmChanComponentBase* compPtr = static_cast<TlmChanComponentBase*>(callComp);
843 compPtr->pingIn_handlerBase(
844 portNum,
845 key
846 );
847 }
848
849}
#define FW_ASSERT(...)
Definition Assert.hpp:7
PlatformIntType NATIVE_INT_TYPE
Definition BasicTypes.h:51
U8 BYTE
byte type
Definition BasicTypes.h:27
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
PlatformUIntType NATIVE_UINT_TYPE
Definition BasicTypes.h:52
int PlatformIntType
DefaultTypes.hpp provides fallback defaults for the platform types.
#define PRI_PlatformIntType
PlatformAssertArgType FwAssertArgType
Definition FpConfig.h:21
U32 FwChanIdType
Definition FpConfig.h:59
@ 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 TlmPortAc.hpp:38
void init()
Object initializer.
Definition ObjBase.cpp:27
@ QUEUE_OK
message sent/received okay
Definition Queue.hpp:28
QueueBlocking
Definition Queue.hpp:40
@ QUEUE_BLOCKING
Queue receive blocks until a message arrives.
Definition Queue.hpp:41
@ QUEUE_NONBLOCKING
Queue receive always returns even if there is no message.
Definition Queue.hpp:42
@ SERIALIZED_SIZE
The size of the serial representations of the port arguments.
@ SERIALIZED_SIZE
The size of the serial representations of the port arguments.
SerializeStatus
forward declaration for string
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.