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