F´ Flight Software - C/C++ Documentation devel
A framework for building embedded system applications to NASA flight quality standards.
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
TlmPacketizerComponentAc.cpp
Go to the documentation of this file.
1// ======================================================================
2// \title TlmPacketizerComponentAc.cpp
3// \author Generated by fpp-to-cpp
4// \brief cpp file for TlmPacketizer 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 {
19 TLMPACKETIZER_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
20 RUN_SCHED,
21 PINGIN_PING,
22 CMD_SET_LEVEL,
23 CMD_SEND_PKT,
24 };
25
26 // Get the max size by constructing a union of the async input, command, and
27 // internal port serialization sizes
28 union BuffUnion {
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 // Max. message size = size of data + message id + port
44 SERIALIZATION_SIZE =
45 sizeof(BuffUnion) +
46 sizeof(NATIVE_INT_TYPE) +
47 sizeof(NATIVE_INT_TYPE)
48 };
49
50 NATIVE_UINT_TYPE getBuffCapacity() const {
51 return sizeof(m_buff);
52 }
53
54 U8* getBuffAddr() {
55 return m_buff;
56 }
57
58 const U8* getBuffAddr() const {
59 return m_buff;
60 }
61
62 private:
63 // Should be the max of all the input ports serialized sizes...
64 U8 m_buff[SERIALIZATION_SIZE];
65
66 };
67 }
68
69 // ----------------------------------------------------------------------
70 // Component initialization
71 // ----------------------------------------------------------------------
72
73 void TlmPacketizerComponentBase ::
74 init(
75 NATIVE_INT_TYPE queueDepth,
76 NATIVE_INT_TYPE instance
77 )
78 {
79 // Initialize base class
81
82 // Connect input port cmdIn
83 for (
84 PlatformIntType port = 0;
85 port < static_cast<PlatformIntType>(this->getNum_cmdIn_InputPorts());
86 port++
87 ) {
88 this->m_cmdIn_InputPort[port].init();
89 this->m_cmdIn_InputPort[port].addCallComp(
90 this,
91 m_p_cmdIn_in
92 );
93 this->m_cmdIn_InputPort[port].setPortNum(port);
94
95#if FW_OBJECT_NAMES == 1
96 // The port name consists of this->m_objName and some extra info.
97 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
98 // However, the compiler may assume that this->m_objName fills
99 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
100 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
101 // bytes to cover the extra info.
102 char portName[2*FW_OBJ_NAME_MAX_SIZE];
103 (void) snprintf(
104 portName,
105 sizeof(portName),
106 "%s_cmdIn_InputPort[%" PRI_PlatformIntType "]",
107 this->m_objName,
108 port
109 );
110 this->m_cmdIn_InputPort[port].setObjName(portName);
111#endif
112 }
113
114 // Connect input port Run
115 for (
116 PlatformIntType port = 0;
117 port < static_cast<PlatformIntType>(this->getNum_Run_InputPorts());
118 port++
119 ) {
120 this->m_Run_InputPort[port].init();
121 this->m_Run_InputPort[port].addCallComp(
122 this,
123 m_p_Run_in
124 );
125 this->m_Run_InputPort[port].setPortNum(port);
126
127#if FW_OBJECT_NAMES == 1
128 // The port name consists of this->m_objName and some extra info.
129 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
130 // However, the compiler may assume that this->m_objName fills
131 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
132 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
133 // bytes to cover the extra info.
134 char portName[2*FW_OBJ_NAME_MAX_SIZE];
135 (void) snprintf(
136 portName,
137 sizeof(portName),
138 "%s_Run_InputPort[%" PRI_PlatformIntType "]",
139 this->m_objName,
140 port
141 );
142 this->m_Run_InputPort[port].setObjName(portName);
143#endif
144 }
145
146 // Connect input port TlmRecv
147 for (
148 PlatformIntType port = 0;
149 port < static_cast<PlatformIntType>(this->getNum_TlmRecv_InputPorts());
150 port++
151 ) {
152 this->m_TlmRecv_InputPort[port].init();
153 this->m_TlmRecv_InputPort[port].addCallComp(
154 this,
155 m_p_TlmRecv_in
156 );
157 this->m_TlmRecv_InputPort[port].setPortNum(port);
158
159#if FW_OBJECT_NAMES == 1
160 // The port name consists of this->m_objName and some extra info.
161 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
162 // However, the compiler may assume that this->m_objName fills
163 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
164 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
165 // bytes to cover the extra info.
166 char portName[2*FW_OBJ_NAME_MAX_SIZE];
167 (void) snprintf(
168 portName,
169 sizeof(portName),
170 "%s_TlmRecv_InputPort[%" PRI_PlatformIntType "]",
171 this->m_objName,
172 port
173 );
174 this->m_TlmRecv_InputPort[port].setObjName(portName);
175#endif
176 }
177
178 // Connect input port pingIn
179 for (
180 PlatformIntType port = 0;
181 port < static_cast<PlatformIntType>(this->getNum_pingIn_InputPorts());
182 port++
183 ) {
184 this->m_pingIn_InputPort[port].init();
185 this->m_pingIn_InputPort[port].addCallComp(
186 this,
187 m_p_pingIn_in
188 );
189 this->m_pingIn_InputPort[port].setPortNum(port);
190
191#if FW_OBJECT_NAMES == 1
192 // The port name consists of this->m_objName and some extra info.
193 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
194 // However, the compiler may assume that this->m_objName fills
195 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
196 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
197 // bytes to cover the extra info.
198 char portName[2*FW_OBJ_NAME_MAX_SIZE];
199 (void) snprintf(
200 portName,
201 sizeof(portName),
202 "%s_pingIn_InputPort[%" PRI_PlatformIntType "]",
203 this->m_objName,
204 port
205 );
206 this->m_pingIn_InputPort[port].setObjName(portName);
207#endif
208 }
209
210 // Connect output port cmdRegOut
211 for (
212 PlatformIntType port = 0;
213 port < static_cast<PlatformIntType>(this->getNum_cmdRegOut_OutputPorts());
214 port++
215 ) {
216 this->m_cmdRegOut_OutputPort[port].init();
217
218#if FW_OBJECT_NAMES == 1
219 // The port name consists of this->m_objName and some extra info.
220 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
221 // However, the compiler may assume that this->m_objName fills
222 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
223 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
224 // bytes to cover the extra info.
225 char portName[2*FW_OBJ_NAME_MAX_SIZE];
226 (void) snprintf(
227 portName,
228 sizeof(portName),
229 "%s_cmdRegOut_OutputPort[%" PRI_PlatformIntType "]",
230 this->m_objName,
231 port
232 );
233 this->m_cmdRegOut_OutputPort[port].setObjName(portName);
234#endif
235 }
236
237 // Connect output port cmdResponseOut
238 for (
239 PlatformIntType port = 0;
240 port < static_cast<PlatformIntType>(this->getNum_cmdResponseOut_OutputPorts());
241 port++
242 ) {
243 this->m_cmdResponseOut_OutputPort[port].init();
244
245#if FW_OBJECT_NAMES == 1
246 // The port name consists of this->m_objName and some extra info.
247 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
248 // However, the compiler may assume that this->m_objName fills
249 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
250 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
251 // bytes to cover the extra info.
252 char portName[2*FW_OBJ_NAME_MAX_SIZE];
253 (void) snprintf(
254 portName,
255 sizeof(portName),
256 "%s_cmdResponseOut_OutputPort[%" PRI_PlatformIntType "]",
257 this->m_objName,
258 port
259 );
260 this->m_cmdResponseOut_OutputPort[port].setObjName(portName);
261#endif
262 }
263
264 // Connect output port eventOut
265 for (
266 PlatformIntType port = 0;
267 port < static_cast<PlatformIntType>(this->getNum_eventOut_OutputPorts());
268 port++
269 ) {
270 this->m_eventOut_OutputPort[port].init();
271
272#if FW_OBJECT_NAMES == 1
273 // The port name consists of this->m_objName and some extra info.
274 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
275 // However, the compiler may assume that this->m_objName fills
276 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
277 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
278 // bytes to cover the extra info.
279 char portName[2*FW_OBJ_NAME_MAX_SIZE];
280 (void) snprintf(
281 portName,
282 sizeof(portName),
283 "%s_eventOut_OutputPort[%" PRI_PlatformIntType "]",
284 this->m_objName,
285 port
286 );
287 this->m_eventOut_OutputPort[port].setObjName(portName);
288#endif
289 }
290
291#if FW_ENABLE_TEXT_LOGGING == 1
292 // Connect output port textEventOut
293 for (
294 PlatformIntType port = 0;
295 port < static_cast<PlatformIntType>(this->getNum_textEventOut_OutputPorts());
296 port++
297 ) {
298 this->m_textEventOut_OutputPort[port].init();
299
300#if FW_OBJECT_NAMES == 1
301 // The port name consists of this->m_objName and some extra info.
302 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
303 // However, the compiler may assume that this->m_objName fills
304 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
305 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
306 // bytes to cover the extra info.
307 char portName[2*FW_OBJ_NAME_MAX_SIZE];
308 (void) snprintf(
309 portName,
310 sizeof(portName),
311 "%s_textEventOut_OutputPort[%" PRI_PlatformIntType "]",
312 this->m_objName,
313 port
314 );
315 this->m_textEventOut_OutputPort[port].setObjName(portName);
316#endif
317 }
318#endif
319
320 // Connect output port timeGetOut
321 for (
322 PlatformIntType port = 0;
323 port < static_cast<PlatformIntType>(this->getNum_timeGetOut_OutputPorts());
324 port++
325 ) {
326 this->m_timeGetOut_OutputPort[port].init();
327
328#if FW_OBJECT_NAMES == 1
329 // The port name consists of this->m_objName and some extra info.
330 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
331 // However, the compiler may assume that this->m_objName fills
332 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
333 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
334 // bytes to cover the extra info.
335 char portName[2*FW_OBJ_NAME_MAX_SIZE];
336 (void) snprintf(
337 portName,
338 sizeof(portName),
339 "%s_timeGetOut_OutputPort[%" PRI_PlatformIntType "]",
340 this->m_objName,
341 port
342 );
343 this->m_timeGetOut_OutputPort[port].setObjName(portName);
344#endif
345 }
346
347 // Connect output port tlmOut
348 for (
349 PlatformIntType port = 0;
350 port < static_cast<PlatformIntType>(this->getNum_tlmOut_OutputPorts());
351 port++
352 ) {
353 this->m_tlmOut_OutputPort[port].init();
354
355#if FW_OBJECT_NAMES == 1
356 // The port name consists of this->m_objName and some extra info.
357 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
358 // However, the compiler may assume that this->m_objName fills
359 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
360 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
361 // bytes to cover the extra info.
362 char portName[2*FW_OBJ_NAME_MAX_SIZE];
363 (void) snprintf(
364 portName,
365 sizeof(portName),
366 "%s_tlmOut_OutputPort[%" PRI_PlatformIntType "]",
367 this->m_objName,
368 port
369 );
370 this->m_tlmOut_OutputPort[port].setObjName(portName);
371#endif
372 }
373
374 // Connect output port PktSend
375 for (
376 PlatformIntType port = 0;
377 port < static_cast<PlatformIntType>(this->getNum_PktSend_OutputPorts());
378 port++
379 ) {
380 this->m_PktSend_OutputPort[port].init();
381
382#if FW_OBJECT_NAMES == 1
383 // The port name consists of this->m_objName and some extra info.
384 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
385 // However, the compiler may assume that this->m_objName fills
386 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
387 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
388 // bytes to cover the extra info.
389 char portName[2*FW_OBJ_NAME_MAX_SIZE];
390 (void) snprintf(
391 portName,
392 sizeof(portName),
393 "%s_PktSend_OutputPort[%" PRI_PlatformIntType "]",
394 this->m_objName,
395 port
396 );
397 this->m_PktSend_OutputPort[port].setObjName(portName);
398#endif
399 }
400
401 // Connect output port pingOut
402 for (
403 PlatformIntType port = 0;
404 port < static_cast<PlatformIntType>(this->getNum_pingOut_OutputPorts());
405 port++
406 ) {
407 this->m_pingOut_OutputPort[port].init();
408
409#if FW_OBJECT_NAMES == 1
410 // The port name consists of this->m_objName and some extra info.
411 // We expect all of this to fit in FW_OBJ_NAME_MAX_SIZE bytes.
412 // However, the compiler may assume that this->m_objName fills
413 // the entire array, whose size is FW_OBJ_NAME_MAX_SIZE. So to
414 // avoid a compiler warning, we provide an extra FW_OBJ_NAME_MAX_SIZE
415 // bytes to cover the extra info.
416 char portName[2*FW_OBJ_NAME_MAX_SIZE];
417 (void) snprintf(
418 portName,
419 sizeof(portName),
420 "%s_pingOut_OutputPort[%" PRI_PlatformIntType "]",
421 this->m_objName,
422 port
423 );
424 this->m_pingOut_OutputPort[port].setObjName(portName);
425#endif
426 }
427
428 Os::Queue::QueueStatus qStat = this->createQueue(
429 queueDepth,
430 ComponentIpcSerializableBuffer::SERIALIZATION_SIZE
431 );
432 FW_ASSERT(
433 Os::Queue::QUEUE_OK == qStat,
434 static_cast<FwAssertArgType>(qStat)
435 );
436 }
437
438 // ----------------------------------------------------------------------
439 // Getters for special input ports
440 // ----------------------------------------------------------------------
441
442 Fw::InputCmdPort* TlmPacketizerComponentBase ::
443 get_cmdIn_InputPort(NATIVE_INT_TYPE portNum)
444 {
445 FW_ASSERT(
446 portNum < this->getNum_cmdIn_InputPorts(),
447 static_cast<FwAssertArgType>(portNum)
448 );
449
450 return &this->m_cmdIn_InputPort[portNum];
451 }
452
453 // ----------------------------------------------------------------------
454 // Getters for typed input ports
455 // ----------------------------------------------------------------------
456
457 Svc::InputSchedPort* TlmPacketizerComponentBase ::
458 get_Run_InputPort(NATIVE_INT_TYPE portNum)
459 {
460 FW_ASSERT(
461 portNum < this->getNum_Run_InputPorts(),
462 static_cast<FwAssertArgType>(portNum)
463 );
464
465 return &this->m_Run_InputPort[portNum];
466 }
467
468 Fw::InputTlmPort* TlmPacketizerComponentBase ::
469 get_TlmRecv_InputPort(NATIVE_INT_TYPE portNum)
470 {
471 FW_ASSERT(
472 portNum < this->getNum_TlmRecv_InputPorts(),
473 static_cast<FwAssertArgType>(portNum)
474 );
475
476 return &this->m_TlmRecv_InputPort[portNum];
477 }
478
479 Svc::InputPingPort* TlmPacketizerComponentBase ::
480 get_pingIn_InputPort(NATIVE_INT_TYPE portNum)
481 {
482 FW_ASSERT(
483 portNum < this->getNum_pingIn_InputPorts(),
484 static_cast<FwAssertArgType>(portNum)
485 );
486
487 return &this->m_pingIn_InputPort[portNum];
488 }
489
490 // ----------------------------------------------------------------------
491 // Connect input ports to special output ports
492 // ----------------------------------------------------------------------
493
494 void TlmPacketizerComponentBase ::
495 set_cmdRegOut_OutputPort(
496 NATIVE_INT_TYPE portNum,
498 )
499 {
500 FW_ASSERT(
501 portNum < this->getNum_cmdRegOut_OutputPorts(),
502 static_cast<FwAssertArgType>(portNum)
503 );
504
505 this->m_cmdRegOut_OutputPort[portNum].addCallPort(port);
506 }
507
508 void TlmPacketizerComponentBase ::
509 set_cmdResponseOut_OutputPort(
510 NATIVE_INT_TYPE portNum,
512 )
513 {
514 FW_ASSERT(
515 portNum < this->getNum_cmdResponseOut_OutputPorts(),
516 static_cast<FwAssertArgType>(portNum)
517 );
518
519 this->m_cmdResponseOut_OutputPort[portNum].addCallPort(port);
520 }
521
522 void TlmPacketizerComponentBase ::
523 set_eventOut_OutputPort(
524 NATIVE_INT_TYPE portNum,
525 Fw::InputLogPort* port
526 )
527 {
528 FW_ASSERT(
529 portNum < this->getNum_eventOut_OutputPorts(),
530 static_cast<FwAssertArgType>(portNum)
531 );
532
533 this->m_eventOut_OutputPort[portNum].addCallPort(port);
534 }
535
536#if FW_ENABLE_TEXT_LOGGING == 1
537
538 void TlmPacketizerComponentBase ::
539 set_textEventOut_OutputPort(
540 NATIVE_INT_TYPE portNum,
542 )
543 {
544 FW_ASSERT(
545 portNum < this->getNum_textEventOut_OutputPorts(),
546 static_cast<FwAssertArgType>(portNum)
547 );
548
549 this->m_textEventOut_OutputPort[portNum].addCallPort(port);
550 }
551
552#endif
553
554 void TlmPacketizerComponentBase ::
555 set_timeGetOut_OutputPort(
556 NATIVE_INT_TYPE portNum,
558 )
559 {
560 FW_ASSERT(
561 portNum < this->getNum_timeGetOut_OutputPorts(),
562 static_cast<FwAssertArgType>(portNum)
563 );
564
565 this->m_timeGetOut_OutputPort[portNum].addCallPort(port);
566 }
567
568 void TlmPacketizerComponentBase ::
569 set_tlmOut_OutputPort(
570 NATIVE_INT_TYPE portNum,
571 Fw::InputTlmPort* port
572 )
573 {
574 FW_ASSERT(
575 portNum < this->getNum_tlmOut_OutputPorts(),
576 static_cast<FwAssertArgType>(portNum)
577 );
578
579 this->m_tlmOut_OutputPort[portNum].addCallPort(port);
580 }
581
582 // ----------------------------------------------------------------------
583 // Connect typed input ports to typed output ports
584 // ----------------------------------------------------------------------
585
586 void TlmPacketizerComponentBase ::
587 set_PktSend_OutputPort(
588 NATIVE_INT_TYPE portNum,
589 Fw::InputComPort* port
590 )
591 {
592 FW_ASSERT(
593 portNum < this->getNum_PktSend_OutputPorts(),
594 static_cast<FwAssertArgType>(portNum)
595 );
596
597 this->m_PktSend_OutputPort[portNum].addCallPort(port);
598 }
599
600 void TlmPacketizerComponentBase ::
601 set_pingOut_OutputPort(
602 NATIVE_INT_TYPE portNum,
604 )
605 {
606 FW_ASSERT(
607 portNum < this->getNum_pingOut_OutputPorts(),
608 static_cast<FwAssertArgType>(portNum)
609 );
610
611 this->m_pingOut_OutputPort[portNum].addCallPort(port);
612 }
613
614#if FW_PORT_SERIALIZATION
615
616 // ----------------------------------------------------------------------
617 // Connect serial input ports to special output ports
618 // ----------------------------------------------------------------------
619
620 void TlmPacketizerComponentBase ::
621 set_cmdRegOut_OutputPort(
622 NATIVE_INT_TYPE portNum,
623 Fw::InputSerializePort* port
624 )
625 {
626 FW_ASSERT(
627 portNum < this->getNum_cmdRegOut_OutputPorts(),
628 static_cast<FwAssertArgType>(portNum)
629 );
630
631 this->m_cmdRegOut_OutputPort[portNum].registerSerialPort(port);
632 }
633
634 void TlmPacketizerComponentBase ::
635 set_cmdResponseOut_OutputPort(
636 NATIVE_INT_TYPE portNum,
637 Fw::InputSerializePort* port
638 )
639 {
640 FW_ASSERT(
641 portNum < this->getNum_cmdResponseOut_OutputPorts(),
642 static_cast<FwAssertArgType>(portNum)
643 );
644
645 this->m_cmdResponseOut_OutputPort[portNum].registerSerialPort(port);
646 }
647
648 void TlmPacketizerComponentBase ::
649 set_eventOut_OutputPort(
650 NATIVE_INT_TYPE portNum,
651 Fw::InputSerializePort* port
652 )
653 {
654 FW_ASSERT(
655 portNum < this->getNum_eventOut_OutputPorts(),
656 static_cast<FwAssertArgType>(portNum)
657 );
658
659 this->m_eventOut_OutputPort[portNum].registerSerialPort(port);
660 }
661
662#if FW_ENABLE_TEXT_LOGGING == 1
663
664 void TlmPacketizerComponentBase ::
665 set_textEventOut_OutputPort(
666 NATIVE_INT_TYPE portNum,
667 Fw::InputSerializePort* port
668 )
669 {
670 FW_ASSERT(
671 portNum < this->getNum_textEventOut_OutputPorts(),
672 static_cast<FwAssertArgType>(portNum)
673 );
674
675 this->m_textEventOut_OutputPort[portNum].registerSerialPort(port);
676 }
677
678#endif
679
680 void TlmPacketizerComponentBase ::
681 set_timeGetOut_OutputPort(
682 NATIVE_INT_TYPE portNum,
683 Fw::InputSerializePort* port
684 )
685 {
686 FW_ASSERT(
687 portNum < this->getNum_timeGetOut_OutputPorts(),
688 static_cast<FwAssertArgType>(portNum)
689 );
690
691 this->m_timeGetOut_OutputPort[portNum].registerSerialPort(port);
692 }
693
694 void TlmPacketizerComponentBase ::
695 set_tlmOut_OutputPort(
696 NATIVE_INT_TYPE portNum,
697 Fw::InputSerializePort* port
698 )
699 {
700 FW_ASSERT(
701 portNum < this->getNum_tlmOut_OutputPorts(),
702 static_cast<FwAssertArgType>(portNum)
703 );
704
705 this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
706 }
707
708#endif
709
710#if FW_PORT_SERIALIZATION
711
712 // ----------------------------------------------------------------------
713 // Connect serial input ports to typed output ports
714 // ----------------------------------------------------------------------
715
716 void TlmPacketizerComponentBase ::
717 set_PktSend_OutputPort(
718 NATIVE_INT_TYPE portNum,
719 Fw::InputSerializePort* port
720 )
721 {
722 FW_ASSERT(
723 portNum < this->getNum_PktSend_OutputPorts(),
724 static_cast<FwAssertArgType>(portNum)
725 );
726
727 this->m_PktSend_OutputPort[portNum].registerSerialPort(port);
728 }
729
730 void TlmPacketizerComponentBase ::
731 set_pingOut_OutputPort(
732 NATIVE_INT_TYPE portNum,
733 Fw::InputSerializePort* port
734 )
735 {
736 FW_ASSERT(
737 portNum < this->getNum_pingOut_OutputPorts(),
738 static_cast<FwAssertArgType>(portNum)
739 );
740
741 this->m_pingOut_OutputPort[portNum].registerSerialPort(port);
742 }
743
744#endif
745
746 // ----------------------------------------------------------------------
747 // Command registration
748 // ----------------------------------------------------------------------
749
750 void TlmPacketizerComponentBase ::
751 regCommands()
752 {
753 FW_ASSERT(this->m_cmdRegOut_OutputPort[0].isConnected());
754
755 this->m_cmdRegOut_OutputPort[0].invoke(
756 this->getIdBase() + OPCODE_SET_LEVEL
757 );
758
759 this->m_cmdRegOut_OutputPort[0].invoke(
760 this->getIdBase() + OPCODE_SEND_PKT
761 );
762 }
763
764 // ----------------------------------------------------------------------
765 // Component construction and destruction
766 // ----------------------------------------------------------------------
767
768 TlmPacketizerComponentBase ::
769 TlmPacketizerComponentBase(const char* compName) :
770 Fw::ActiveComponentBase(compName)
771 {
772
773 }
774
775 TlmPacketizerComponentBase ::
776 ~TlmPacketizerComponentBase()
777 {
778
779 }
780
781 // ----------------------------------------------------------------------
782 // Getters for numbers of special input ports
783 // ----------------------------------------------------------------------
784
785 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
786 getNum_cmdIn_InputPorts() const
787 {
788 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdIn_InputPort));
789 }
790
791 // ----------------------------------------------------------------------
792 // Getters for numbers of typed input ports
793 // ----------------------------------------------------------------------
794
795 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
796 getNum_Run_InputPorts() const
797 {
798 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_Run_InputPort));
799 }
800
801 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
802 getNum_TlmRecv_InputPorts() const
803 {
804 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_TlmRecv_InputPort));
805 }
806
807 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
808 getNum_pingIn_InputPorts() const
809 {
810 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_pingIn_InputPort));
811 }
812
813 // ----------------------------------------------------------------------
814 // Getters for numbers of special output ports
815 // ----------------------------------------------------------------------
816
817 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
818 getNum_cmdRegOut_OutputPorts() const
819 {
820 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdRegOut_OutputPort));
821 }
822
823 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
824 getNum_cmdResponseOut_OutputPorts() const
825 {
826 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdResponseOut_OutputPort));
827 }
828
829 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
830 getNum_eventOut_OutputPorts() const
831 {
832 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_eventOut_OutputPort));
833 }
834
835#if FW_ENABLE_TEXT_LOGGING == 1
836
837 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
838 getNum_textEventOut_OutputPorts() const
839 {
840 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_textEventOut_OutputPort));
841 }
842
843#endif
844
845 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
846 getNum_timeGetOut_OutputPorts() const
847 {
848 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_timeGetOut_OutputPort));
849 }
850
851 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
852 getNum_tlmOut_OutputPorts() const
853 {
854 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_tlmOut_OutputPort));
855 }
856
857 // ----------------------------------------------------------------------
858 // Getters for numbers of typed output ports
859 // ----------------------------------------------------------------------
860
861 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
862 getNum_PktSend_OutputPorts() const
863 {
864 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_PktSend_OutputPort));
865 }
866
867 NATIVE_INT_TYPE TlmPacketizerComponentBase ::
868 getNum_pingOut_OutputPorts() const
869 {
870 return static_cast<NATIVE_INT_TYPE>(FW_NUM_ARRAY_ELEMENTS(this->m_pingOut_OutputPort));
871 }
872
873 // ----------------------------------------------------------------------
874 // Connection status queries for special output ports
875 // ----------------------------------------------------------------------
876
877 bool TlmPacketizerComponentBase ::
878 isConnected_cmdRegOut_OutputPort(NATIVE_INT_TYPE portNum)
879 {
880 FW_ASSERT(
881 portNum < this->getNum_cmdRegOut_OutputPorts(),
882 static_cast<FwAssertArgType>(portNum)
883 );
884
885 return this->m_cmdRegOut_OutputPort[portNum].isConnected();
886 }
887
888 bool TlmPacketizerComponentBase ::
889 isConnected_cmdResponseOut_OutputPort(NATIVE_INT_TYPE portNum)
890 {
891 FW_ASSERT(
892 portNum < this->getNum_cmdResponseOut_OutputPorts(),
893 static_cast<FwAssertArgType>(portNum)
894 );
895
896 return this->m_cmdResponseOut_OutputPort[portNum].isConnected();
897 }
898
899 bool TlmPacketizerComponentBase ::
900 isConnected_eventOut_OutputPort(NATIVE_INT_TYPE portNum)
901 {
902 FW_ASSERT(
903 portNum < this->getNum_eventOut_OutputPorts(),
904 static_cast<FwAssertArgType>(portNum)
905 );
906
907 return this->m_eventOut_OutputPort[portNum].isConnected();
908 }
909
910#if FW_ENABLE_TEXT_LOGGING == 1
911
912 bool TlmPacketizerComponentBase ::
913 isConnected_textEventOut_OutputPort(NATIVE_INT_TYPE portNum)
914 {
915 FW_ASSERT(
916 portNum < this->getNum_textEventOut_OutputPorts(),
917 static_cast<FwAssertArgType>(portNum)
918 );
919
920 return this->m_textEventOut_OutputPort[portNum].isConnected();
921 }
922
923#endif
924
925 bool TlmPacketizerComponentBase ::
926 isConnected_timeGetOut_OutputPort(NATIVE_INT_TYPE portNum)
927 {
928 FW_ASSERT(
929 portNum < this->getNum_timeGetOut_OutputPorts(),
930 static_cast<FwAssertArgType>(portNum)
931 );
932
933 return this->m_timeGetOut_OutputPort[portNum].isConnected();
934 }
935
936 bool TlmPacketizerComponentBase ::
937 isConnected_tlmOut_OutputPort(NATIVE_INT_TYPE portNum)
938 {
939 FW_ASSERT(
940 portNum < this->getNum_tlmOut_OutputPorts(),
941 static_cast<FwAssertArgType>(portNum)
942 );
943
944 return this->m_tlmOut_OutputPort[portNum].isConnected();
945 }
946
947 // ----------------------------------------------------------------------
948 // Connection status queries for typed output ports
949 // ----------------------------------------------------------------------
950
951 bool TlmPacketizerComponentBase ::
952 isConnected_PktSend_OutputPort(NATIVE_INT_TYPE portNum)
953 {
954 FW_ASSERT(
955 portNum < this->getNum_PktSend_OutputPorts(),
956 static_cast<FwAssertArgType>(portNum)
957 );
958
959 return this->m_PktSend_OutputPort[portNum].isConnected();
960 }
961
962 bool TlmPacketizerComponentBase ::
963 isConnected_pingOut_OutputPort(NATIVE_INT_TYPE portNum)
964 {
965 FW_ASSERT(
966 portNum < this->getNum_pingOut_OutputPorts(),
967 static_cast<FwAssertArgType>(portNum)
968 );
969
970 return this->m_pingOut_OutputPort[portNum].isConnected();
971 }
972
973 // ----------------------------------------------------------------------
974 // Port handler base-class functions for typed input ports
975 //
976 // Call these functions directly to bypass the corresponding ports
977 // ----------------------------------------------------------------------
978
979 void TlmPacketizerComponentBase ::
980 Run_handlerBase(
981 NATIVE_INT_TYPE portNum,
982 NATIVE_UINT_TYPE context
983 )
984 {
985 // Make sure port number is valid
986 FW_ASSERT(
987 portNum < this->getNum_Run_InputPorts(),
988 static_cast<FwAssertArgType>(portNum)
989 );
990
991 // Call pre-message hook
992 Run_preMsgHook(
993 portNum,
994 context
995 );
996 ComponentIpcSerializableBuffer msg;
998
999 // Serialize message ID
1000 _status = msg.serialize(
1001 static_cast<NATIVE_INT_TYPE>(RUN_SCHED)
1002 );
1003 FW_ASSERT(
1004 _status == Fw::FW_SERIALIZE_OK,
1005 static_cast<FwAssertArgType>(_status)
1006 );
1007
1008 // Serialize port number
1009 _status = msg.serialize(portNum);
1010 FW_ASSERT(
1011 _status == Fw::FW_SERIALIZE_OK,
1012 static_cast<FwAssertArgType>(_status)
1013 );
1014
1015 // Serialize argument context
1016 _status = msg.serialize(context);
1017 FW_ASSERT(
1018 _status == Fw::FW_SERIALIZE_OK,
1019 static_cast<FwAssertArgType>(_status)
1020 );
1021
1022 // Send message
1024 Os::Queue::QueueStatus qStatus = this->m_queue.send(msg, 0, _block);
1025
1026 FW_ASSERT(
1027 qStatus == Os::Queue::QUEUE_OK,
1028 static_cast<FwAssertArgType>(qStatus)
1029 );
1030 }
1031
1032 void TlmPacketizerComponentBase ::
1033 TlmRecv_handlerBase(
1034 NATIVE_INT_TYPE portNum,
1035 FwChanIdType id,
1036 Fw::Time& timeTag,
1037 Fw::TlmBuffer& val
1038 )
1039 {
1040 // Make sure port number is valid
1041 FW_ASSERT(
1042 portNum < this->getNum_TlmRecv_InputPorts(),
1043 static_cast<FwAssertArgType>(portNum)
1044 );
1045
1046 // Call handler function
1047 this->TlmRecv_handler(
1048 portNum,
1049 id,
1050 timeTag,
1051 val
1052 );
1053 }
1054
1055 void TlmPacketizerComponentBase ::
1056 pingIn_handlerBase(
1057 NATIVE_INT_TYPE portNum,
1058 U32 key
1059 )
1060 {
1061 // Make sure port number is valid
1062 FW_ASSERT(
1063 portNum < this->getNum_pingIn_InputPorts(),
1064 static_cast<FwAssertArgType>(portNum)
1065 );
1066
1067 // Call pre-message hook
1068 pingIn_preMsgHook(
1069 portNum,
1070 key
1071 );
1072 ComponentIpcSerializableBuffer msg;
1074
1075 // Serialize message ID
1076 _status = msg.serialize(
1077 static_cast<NATIVE_INT_TYPE>(PINGIN_PING)
1078 );
1079 FW_ASSERT(
1080 _status == Fw::FW_SERIALIZE_OK,
1081 static_cast<FwAssertArgType>(_status)
1082 );
1083
1084 // Serialize port number
1085 _status = msg.serialize(portNum);
1086 FW_ASSERT(
1087 _status == Fw::FW_SERIALIZE_OK,
1088 static_cast<FwAssertArgType>(_status)
1089 );
1090
1091 // Serialize argument key
1092 _status = msg.serialize(key);
1093 FW_ASSERT(
1094 _status == Fw::FW_SERIALIZE_OK,
1095 static_cast<FwAssertArgType>(_status)
1096 );
1097
1098 // Send message
1100 Os::Queue::QueueStatus qStatus = this->m_queue.send(msg, 0, _block);
1101
1102 FW_ASSERT(
1103 qStatus == Os::Queue::QUEUE_OK,
1104 static_cast<FwAssertArgType>(qStatus)
1105 );
1106 }
1107
1108 // ----------------------------------------------------------------------
1109 // Pre-message hooks for typed async input ports
1110 //
1111 // Each of these functions is invoked just before processing a message
1112 // on the corresponding port. By default, they do nothing. You can
1113 // override them to provide specific pre-message behavior.
1114 // ----------------------------------------------------------------------
1115
1116 void TlmPacketizerComponentBase ::
1117 Run_preMsgHook(
1118 NATIVE_INT_TYPE portNum,
1119 NATIVE_UINT_TYPE context
1120 )
1121 {
1122 // Default: no-op
1123 }
1124
1125 void TlmPacketizerComponentBase ::
1126 pingIn_preMsgHook(
1127 NATIVE_INT_TYPE portNum,
1128 U32 key
1129 )
1130 {
1131 // Default: no-op
1132 }
1133
1134 // ----------------------------------------------------------------------
1135 // Invocation functions for typed output ports
1136 // ----------------------------------------------------------------------
1137
1138 void TlmPacketizerComponentBase ::
1139 PktSend_out(
1140 NATIVE_INT_TYPE portNum,
1141 Fw::ComBuffer& data,
1142 U32 context
1143 )
1144 {
1145 FW_ASSERT(
1146 portNum < this->getNum_PktSend_OutputPorts(),
1147 static_cast<FwAssertArgType>(portNum)
1148 );
1149 this->m_PktSend_OutputPort[portNum].invoke(
1150 data,
1151 context
1152 );
1153 }
1154
1155 void TlmPacketizerComponentBase ::
1156 pingOut_out(
1157 NATIVE_INT_TYPE portNum,
1158 U32 key
1159 )
1160 {
1161 FW_ASSERT(
1162 portNum < this->getNum_pingOut_OutputPorts(),
1163 static_cast<FwAssertArgType>(portNum)
1164 );
1165 this->m_pingOut_OutputPort[portNum].invoke(
1166 key
1167 );
1168 }
1169
1170 // ----------------------------------------------------------------------
1171 // Command response
1172 // ----------------------------------------------------------------------
1173
1174 void TlmPacketizerComponentBase ::
1175 cmdResponse_out(
1176 FwOpcodeType opCode,
1177 U32 cmdSeq,
1178 Fw::CmdResponse response
1179 )
1180 {
1181 FW_ASSERT(this->m_cmdResponseOut_OutputPort[0].isConnected());
1182 this->m_cmdResponseOut_OutputPort[0].invoke(opCode, cmdSeq, response);
1183 }
1184
1185 // ----------------------------------------------------------------------
1186 // Command handler base-class functions
1187 //
1188 // Call these functions directly to bypass the command input port
1189 // ----------------------------------------------------------------------
1190
1191 void TlmPacketizerComponentBase ::
1192 SET_LEVEL_cmdHandlerBase(
1193 FwOpcodeType opCode,
1194 U32 cmdSeq,
1195 Fw::CmdArgBuffer& args
1196 )
1197 {
1198 // Call pre-message hook
1199 this->SET_LEVEL_preMsgHook(opCode,cmdSeq);
1200
1201 // Defer deserializing arguments to the message dispatcher
1202 // to avoid deserializing and reserializing just for IPC
1203 ComponentIpcSerializableBuffer msg;
1205
1206 // Serialize for IPC
1207 _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(CMD_SET_LEVEL));
1208 FW_ASSERT (
1209 _status == Fw::FW_SERIALIZE_OK,
1210 static_cast<FwAssertArgType>(_status)
1211 );
1212
1213 // Fake port number to make message dequeue work
1214 NATIVE_INT_TYPE port = 0;
1215
1216 _status = msg.serialize(port);
1217 FW_ASSERT (
1218 _status == Fw::FW_SERIALIZE_OK,
1219 static_cast<FwAssertArgType>(_status)
1220 );
1221
1222 _status = msg.serialize(opCode);
1223 FW_ASSERT (
1224 _status == Fw::FW_SERIALIZE_OK,
1225 static_cast<FwAssertArgType>(_status)
1226 );
1227
1228 _status = msg.serialize(cmdSeq);
1229 FW_ASSERT (
1230 _status == Fw::FW_SERIALIZE_OK,
1231 static_cast<FwAssertArgType>(_status)
1232 );
1233
1234 _status = msg.serialize(args);
1235 FW_ASSERT (
1236 _status == Fw::FW_SERIALIZE_OK,
1237 static_cast<FwAssertArgType>(_status)
1238 );
1239
1240 // Send message
1242 Os::Queue::QueueStatus qStatus = this->m_queue.send(msg, 0, _block);
1243
1244 FW_ASSERT(
1245 qStatus == Os::Queue::QUEUE_OK,
1246 static_cast<FwAssertArgType>(qStatus)
1247 );
1248 }
1249
1250 void TlmPacketizerComponentBase ::
1251 SEND_PKT_cmdHandlerBase(
1252 FwOpcodeType opCode,
1253 U32 cmdSeq,
1254 Fw::CmdArgBuffer& args
1255 )
1256 {
1257 // Call pre-message hook
1258 this->SEND_PKT_preMsgHook(opCode,cmdSeq);
1259
1260 // Defer deserializing arguments to the message dispatcher
1261 // to avoid deserializing and reserializing just for IPC
1262 ComponentIpcSerializableBuffer msg;
1264
1265 // Serialize for IPC
1266 _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(CMD_SEND_PKT));
1267 FW_ASSERT (
1268 _status == Fw::FW_SERIALIZE_OK,
1269 static_cast<FwAssertArgType>(_status)
1270 );
1271
1272 // Fake port number to make message dequeue work
1273 NATIVE_INT_TYPE port = 0;
1274
1275 _status = msg.serialize(port);
1276 FW_ASSERT (
1277 _status == Fw::FW_SERIALIZE_OK,
1278 static_cast<FwAssertArgType>(_status)
1279 );
1280
1281 _status = msg.serialize(opCode);
1282 FW_ASSERT (
1283 _status == Fw::FW_SERIALIZE_OK,
1284 static_cast<FwAssertArgType>(_status)
1285 );
1286
1287 _status = msg.serialize(cmdSeq);
1288 FW_ASSERT (
1289 _status == Fw::FW_SERIALIZE_OK,
1290 static_cast<FwAssertArgType>(_status)
1291 );
1292
1293 _status = msg.serialize(args);
1294 FW_ASSERT (
1295 _status == Fw::FW_SERIALIZE_OK,
1296 static_cast<FwAssertArgType>(_status)
1297 );
1298
1299 // Send message
1301 Os::Queue::QueueStatus qStatus = this->m_queue.send(msg, 0, _block);
1302
1303 FW_ASSERT(
1304 qStatus == Os::Queue::QUEUE_OK,
1305 static_cast<FwAssertArgType>(qStatus)
1306 );
1307 }
1308
1309 // ----------------------------------------------------------------------
1310 // Pre-message hooks for async commands
1311 //
1312 // Each of these functions is invoked just before processing the
1313 // corresponding command. By default they do nothing. You can
1314 // override them to provide specific pre-command behavior.
1315 // ----------------------------------------------------------------------
1316
1317 void TlmPacketizerComponentBase ::
1318 SET_LEVEL_preMsgHook(
1319 FwOpcodeType opCode,
1320 U32 cmdSeq
1321 )
1322 {
1323 // Defaults to no-op; can be overridden
1324 (void) opCode;
1325 (void) cmdSeq;
1326 }
1327
1328 void TlmPacketizerComponentBase ::
1329 SEND_PKT_preMsgHook(
1330 FwOpcodeType opCode,
1331 U32 cmdSeq
1332 )
1333 {
1334 // Defaults to no-op; can be overridden
1335 (void) opCode;
1336 (void) cmdSeq;
1337 }
1338
1339 // ----------------------------------------------------------------------
1340 // Event logging functions
1341 // ----------------------------------------------------------------------
1342
1343 void TlmPacketizerComponentBase ::
1344 log_WARNING_LO_NoChan(U32 Id)
1345 {
1346 // Get the time
1347 Fw::Time _logTime;
1348 if (this->m_timeGetOut_OutputPort[0].isConnected()) {
1349 this->m_timeGetOut_OutputPort[0].invoke(_logTime);
1350 }
1351
1352 FwEventIdType _id = static_cast<FwEventIdType>(0);
1353
1354 _id = this->getIdBase() + EVENTID_NOCHAN;
1355
1356 // Emit the event on the log port
1357 if (this->m_eventOut_OutputPort[0].isConnected()) {
1358 Fw::LogBuffer _logBuff;
1360
1361#if FW_AMPCS_COMPATIBLE
1362 // Serialize the number of arguments
1363 _status = _logBuff.serialize(static_cast<U8>(1));
1364 FW_ASSERT(
1365 _status == Fw::FW_SERIALIZE_OK,
1366 static_cast<FwAssertArgType>(_status)
1367 );
1368#endif
1369
1370#if FW_AMPCS_COMPATIBLE
1371 // Serialize the argument size
1372 _status = _logBuff.serialize(
1373 static_cast<U8>(sizeof(U32))
1374 );
1375 FW_ASSERT(
1376 _status == Fw::FW_SERIALIZE_OK,
1377 static_cast<FwAssertArgType>(_status)
1378 );
1379#endif
1380 _status = _logBuff.serialize(Id);
1381 FW_ASSERT(
1382 _status == Fw::FW_SERIALIZE_OK,
1383 static_cast<FwAssertArgType>(_status)
1384 );
1385
1386 this->m_eventOut_OutputPort[0].invoke(
1387 _id,
1388 _logTime,
1390 _logBuff
1391 );
1392 }
1393
1394 // Emit the event on the text log port
1395#if FW_ENABLE_TEXT_LOGGING
1396 if (this->m_textEventOut_OutputPort[0].isConnected()) {
1397#if FW_OBJECT_NAMES == 1
1398 const char* _formatString =
1399 "(%s) %s: Telemetry ID 0x%" PRIx32 " not packetized";
1400#else
1401 const char* _formatString =
1402 "%s: Telemetry ID 0x%" PRIx32 " not packetized";
1403#endif
1404
1405 char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1406
1407 (void) snprintf(
1408 _textBuffer,
1410 _formatString,
1411#if FW_OBJECT_NAMES == 1
1412 this->m_objName,
1413#endif
1414 "NoChan ",
1415 Id
1416 );
1417
1418 // Null terminate
1419 _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1420 Fw::TextLogString _logString = _textBuffer;
1421 this->m_textEventOut_OutputPort[0].invoke(
1422 _id,
1423 _logTime,
1425 _logString
1426 );
1427 }
1428#endif
1429 }
1430
1431 void TlmPacketizerComponentBase ::
1432 log_ACTIVITY_HI_LevelSet(U32 id)
1433 {
1434 // Get the time
1435 Fw::Time _logTime;
1436 if (this->m_timeGetOut_OutputPort[0].isConnected()) {
1437 this->m_timeGetOut_OutputPort[0].invoke(_logTime);
1438 }
1439
1440 FwEventIdType _id = static_cast<FwEventIdType>(0);
1441
1442 _id = this->getIdBase() + EVENTID_LEVELSET;
1443
1444 // Emit the event on the log port
1445 if (this->m_eventOut_OutputPort[0].isConnected()) {
1446 Fw::LogBuffer _logBuff;
1448
1449#if FW_AMPCS_COMPATIBLE
1450 // Serialize the number of arguments
1451 _status = _logBuff.serialize(static_cast<U8>(1));
1452 FW_ASSERT(
1453 _status == Fw::FW_SERIALIZE_OK,
1454 static_cast<FwAssertArgType>(_status)
1455 );
1456#endif
1457
1458#if FW_AMPCS_COMPATIBLE
1459 // Serialize the argument size
1460 _status = _logBuff.serialize(
1461 static_cast<U8>(sizeof(U32))
1462 );
1463 FW_ASSERT(
1464 _status == Fw::FW_SERIALIZE_OK,
1465 static_cast<FwAssertArgType>(_status)
1466 );
1467#endif
1468 _status = _logBuff.serialize(id);
1469 FW_ASSERT(
1470 _status == Fw::FW_SERIALIZE_OK,
1471 static_cast<FwAssertArgType>(_status)
1472 );
1473
1474 this->m_eventOut_OutputPort[0].invoke(
1475 _id,
1476 _logTime,
1478 _logBuff
1479 );
1480 }
1481
1482 // Emit the event on the text log port
1483#if FW_ENABLE_TEXT_LOGGING
1484 if (this->m_textEventOut_OutputPort[0].isConnected()) {
1485#if FW_OBJECT_NAMES == 1
1486 const char* _formatString =
1487 "(%s) %s: Telemetry send level to %" PRIu32 "";
1488#else
1489 const char* _formatString =
1490 "%s: Telemetry send level to %" PRIu32 "";
1491#endif
1492
1493 char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1494
1495 (void) snprintf(
1496 _textBuffer,
1498 _formatString,
1499#if FW_OBJECT_NAMES == 1
1500 this->m_objName,
1501#endif
1502 "LevelSet ",
1503 id
1504 );
1505
1506 // Null terminate
1507 _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1508 Fw::TextLogString _logString = _textBuffer;
1509 this->m_textEventOut_OutputPort[0].invoke(
1510 _id,
1511 _logTime,
1513 _logString
1514 );
1515 }
1516#endif
1517 }
1518
1519 void TlmPacketizerComponentBase ::
1520 log_WARNING_LO_MaxLevelExceed(
1521 U32 level,
1522 U32 max
1523 )
1524 {
1525 // Get the time
1526 Fw::Time _logTime;
1527 if (this->m_timeGetOut_OutputPort[0].isConnected()) {
1528 this->m_timeGetOut_OutputPort[0].invoke(_logTime);
1529 }
1530
1531 FwEventIdType _id = static_cast<FwEventIdType>(0);
1532
1533 _id = this->getIdBase() + EVENTID_MAXLEVELEXCEED;
1534
1535 // Emit the event on the log port
1536 if (this->m_eventOut_OutputPort[0].isConnected()) {
1537 Fw::LogBuffer _logBuff;
1539
1540#if FW_AMPCS_COMPATIBLE
1541 // Serialize the number of arguments
1542 _status = _logBuff.serialize(static_cast<U8>(2));
1543 FW_ASSERT(
1544 _status == Fw::FW_SERIALIZE_OK,
1545 static_cast<FwAssertArgType>(_status)
1546 );
1547#endif
1548
1549#if FW_AMPCS_COMPATIBLE
1550 // Serialize the argument size
1551 _status = _logBuff.serialize(
1552 static_cast<U8>(sizeof(U32))
1553 );
1554 FW_ASSERT(
1555 _status == Fw::FW_SERIALIZE_OK,
1556 static_cast<FwAssertArgType>(_status)
1557 );
1558#endif
1559 _status = _logBuff.serialize(level);
1560 FW_ASSERT(
1561 _status == Fw::FW_SERIALIZE_OK,
1562 static_cast<FwAssertArgType>(_status)
1563 );
1564
1565#if FW_AMPCS_COMPATIBLE
1566 // Serialize the argument size
1567 _status = _logBuff.serialize(
1568 static_cast<U8>(sizeof(U32))
1569 );
1570 FW_ASSERT(
1571 _status == Fw::FW_SERIALIZE_OK,
1572 static_cast<FwAssertArgType>(_status)
1573 );
1574#endif
1575 _status = _logBuff.serialize(max);
1576 FW_ASSERT(
1577 _status == Fw::FW_SERIALIZE_OK,
1578 static_cast<FwAssertArgType>(_status)
1579 );
1580
1581 this->m_eventOut_OutputPort[0].invoke(
1582 _id,
1583 _logTime,
1585 _logBuff
1586 );
1587 }
1588
1589 // Emit the event on the text log port
1590#if FW_ENABLE_TEXT_LOGGING
1591 if (this->m_textEventOut_OutputPort[0].isConnected()) {
1592#if FW_OBJECT_NAMES == 1
1593 const char* _formatString =
1594 "(%s) %s: Requested send level %" PRIu32 " higher than max packet level of %" PRIu32 "";
1595#else
1596 const char* _formatString =
1597 "%s: Requested send level %" PRIu32 " higher than max packet level of %" PRIu32 "";
1598#endif
1599
1600 char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1601
1602 (void) snprintf(
1603 _textBuffer,
1605 _formatString,
1606#if FW_OBJECT_NAMES == 1
1607 this->m_objName,
1608#endif
1609 "MaxLevelExceed ",
1610 level,
1611 max
1612 );
1613
1614 // Null terminate
1615 _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1616 Fw::TextLogString _logString = _textBuffer;
1617 this->m_textEventOut_OutputPort[0].invoke(
1618 _id,
1619 _logTime,
1621 _logString
1622 );
1623 }
1624#endif
1625 }
1626
1627 void TlmPacketizerComponentBase ::
1628 log_ACTIVITY_LO_PacketSent(U32 id)
1629 {
1630 // Get the time
1631 Fw::Time _logTime;
1632 if (this->m_timeGetOut_OutputPort[0].isConnected()) {
1633 this->m_timeGetOut_OutputPort[0].invoke(_logTime);
1634 }
1635
1636 FwEventIdType _id = static_cast<FwEventIdType>(0);
1637
1638 _id = this->getIdBase() + EVENTID_PACKETSENT;
1639
1640 // Emit the event on the log port
1641 if (this->m_eventOut_OutputPort[0].isConnected()) {
1642 Fw::LogBuffer _logBuff;
1644
1645#if FW_AMPCS_COMPATIBLE
1646 // Serialize the number of arguments
1647 _status = _logBuff.serialize(static_cast<U8>(1));
1648 FW_ASSERT(
1649 _status == Fw::FW_SERIALIZE_OK,
1650 static_cast<FwAssertArgType>(_status)
1651 );
1652#endif
1653
1654#if FW_AMPCS_COMPATIBLE
1655 // Serialize the argument size
1656 _status = _logBuff.serialize(
1657 static_cast<U8>(sizeof(U32))
1658 );
1659 FW_ASSERT(
1660 _status == Fw::FW_SERIALIZE_OK,
1661 static_cast<FwAssertArgType>(_status)
1662 );
1663#endif
1664 _status = _logBuff.serialize(id);
1665 FW_ASSERT(
1666 _status == Fw::FW_SERIALIZE_OK,
1667 static_cast<FwAssertArgType>(_status)
1668 );
1669
1670 this->m_eventOut_OutputPort[0].invoke(
1671 _id,
1672 _logTime,
1674 _logBuff
1675 );
1676 }
1677
1678 // Emit the event on the text log port
1679#if FW_ENABLE_TEXT_LOGGING
1680 if (this->m_textEventOut_OutputPort[0].isConnected()) {
1681#if FW_OBJECT_NAMES == 1
1682 const char* _formatString =
1683 "(%s) %s: Sent packet ID %" PRIu32 "";
1684#else
1685 const char* _formatString =
1686 "%s: Sent packet ID %" PRIu32 "";
1687#endif
1688
1689 char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1690
1691 (void) snprintf(
1692 _textBuffer,
1694 _formatString,
1695#if FW_OBJECT_NAMES == 1
1696 this->m_objName,
1697#endif
1698 "PacketSent ",
1699 id
1700 );
1701
1702 // Null terminate
1703 _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1704 Fw::TextLogString _logString = _textBuffer;
1705 this->m_textEventOut_OutputPort[0].invoke(
1706 _id,
1707 _logTime,
1709 _logString
1710 );
1711 }
1712#endif
1713 }
1714
1715 void TlmPacketizerComponentBase ::
1716 log_WARNING_LO_PacketNotFound(U32 id)
1717 {
1718 // Get the time
1719 Fw::Time _logTime;
1720 if (this->m_timeGetOut_OutputPort[0].isConnected()) {
1721 this->m_timeGetOut_OutputPort[0].invoke(_logTime);
1722 }
1723
1724 FwEventIdType _id = static_cast<FwEventIdType>(0);
1725
1726 _id = this->getIdBase() + EVENTID_PACKETNOTFOUND;
1727
1728 // Emit the event on the log port
1729 if (this->m_eventOut_OutputPort[0].isConnected()) {
1730 Fw::LogBuffer _logBuff;
1732
1733#if FW_AMPCS_COMPATIBLE
1734 // Serialize the number of arguments
1735 _status = _logBuff.serialize(static_cast<U8>(1));
1736 FW_ASSERT(
1737 _status == Fw::FW_SERIALIZE_OK,
1738 static_cast<FwAssertArgType>(_status)
1739 );
1740#endif
1741
1742#if FW_AMPCS_COMPATIBLE
1743 // Serialize the argument size
1744 _status = _logBuff.serialize(
1745 static_cast<U8>(sizeof(U32))
1746 );
1747 FW_ASSERT(
1748 _status == Fw::FW_SERIALIZE_OK,
1749 static_cast<FwAssertArgType>(_status)
1750 );
1751#endif
1752 _status = _logBuff.serialize(id);
1753 FW_ASSERT(
1754 _status == Fw::FW_SERIALIZE_OK,
1755 static_cast<FwAssertArgType>(_status)
1756 );
1757
1758 this->m_eventOut_OutputPort[0].invoke(
1759 _id,
1760 _logTime,
1762 _logBuff
1763 );
1764 }
1765
1766 // Emit the event on the text log port
1767#if FW_ENABLE_TEXT_LOGGING
1768 if (this->m_textEventOut_OutputPort[0].isConnected()) {
1769#if FW_OBJECT_NAMES == 1
1770 const char* _formatString =
1771 "(%s) %s: Could not find packet ID %" PRIu32 "";
1772#else
1773 const char* _formatString =
1774 "%s: Could not find packet ID %" PRIu32 "";
1775#endif
1776
1777 char _textBuffer[FW_LOG_TEXT_BUFFER_SIZE];
1778
1779 (void) snprintf(
1780 _textBuffer,
1782 _formatString,
1783#if FW_OBJECT_NAMES == 1
1784 this->m_objName,
1785#endif
1786 "PacketNotFound ",
1787 id
1788 );
1789
1790 // Null terminate
1791 _textBuffer[FW_LOG_TEXT_BUFFER_SIZE-1] = 0;
1792 Fw::TextLogString _logString = _textBuffer;
1793 this->m_textEventOut_OutputPort[0].invoke(
1794 _id,
1795 _logTime,
1797 _logString
1798 );
1799 }
1800#endif
1801 }
1802
1803 // ----------------------------------------------------------------------
1804 // Telemetry write functions
1805 // ----------------------------------------------------------------------
1806
1807 void TlmPacketizerComponentBase ::
1808 tlmWrite_SendLevel(
1809 U32 arg,
1810 Fw::Time _tlmTime
1811 )
1812 {
1813 if (this->m_tlmOut_OutputPort[0].isConnected()) {
1814 if (
1815 this->m_timeGetOut_OutputPort[0].isConnected() &&
1816 (_tlmTime == Fw::ZERO_TIME)
1817 ) {
1818 this->m_timeGetOut_OutputPort[0].invoke(_tlmTime);
1819 }
1820
1821 Fw::TlmBuffer _tlmBuff;
1822 Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
1823 FW_ASSERT(
1824 _stat == Fw::FW_SERIALIZE_OK,
1825 static_cast<FwAssertArgType>(_stat)
1826 );
1827
1828 FwChanIdType _id;
1829
1830 _id = this->getIdBase() + CHANNELID_SENDLEVEL;
1831
1832 this->m_tlmOut_OutputPort[0].invoke(
1833 _id,
1834 _tlmTime,
1835 _tlmBuff
1836 );
1837 }
1838 }
1839
1840 // ----------------------------------------------------------------------
1841 // Time
1842 // ----------------------------------------------------------------------
1843
1844 Fw::Time TlmPacketizerComponentBase ::
1845 getTime()
1846 {
1847 if (this->m_timeGetOut_OutputPort[0].isConnected()) {
1848 Fw::Time _time;
1849 this->m_timeGetOut_OutputPort[0].invoke(_time);
1850 return _time;
1851 }
1852 else {
1853 return Fw::Time(TB_NONE, 0, 0);
1854 }
1855 }
1856
1857 // ----------------------------------------------------------------------
1858 // Message dispatch functions
1859 // ----------------------------------------------------------------------
1860
1861 Fw::QueuedComponentBase::MsgDispatchStatus TlmPacketizerComponentBase ::
1862 doDispatch()
1863 {
1864 ComponentIpcSerializableBuffer msg;
1865 NATIVE_INT_TYPE priority = 0;
1866
1867 Os::Queue::QueueStatus msgStatus = this->m_queue.receive(
1868 msg,
1869 priority,
1871 );
1872 FW_ASSERT(
1873 msgStatus == Os::Queue::QUEUE_OK,
1874 static_cast<FwAssertArgType>(msgStatus)
1875 );
1876
1877 // Reset to beginning of buffer
1878 msg.resetDeser();
1879
1880 NATIVE_INT_TYPE desMsg = 0;
1881 Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
1882 FW_ASSERT(
1883 deserStatus == Fw::FW_SERIALIZE_OK,
1884 static_cast<FwAssertArgType>(deserStatus)
1885 );
1886
1887 MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
1888
1889 if (msgType == TLMPACKETIZER_COMPONENT_EXIT) {
1890 return MSG_DISPATCH_EXIT;
1891 }
1892
1893 NATIVE_INT_TYPE portNum = 0;
1894 deserStatus = msg.deserialize(portNum);
1895 FW_ASSERT(
1896 deserStatus == Fw::FW_SERIALIZE_OK,
1897 static_cast<FwAssertArgType>(deserStatus)
1898 );
1899
1900 switch (msgType) {
1901 // Handle async input port Run
1902 case RUN_SCHED: {
1903 // Deserialize argument context
1904 NATIVE_UINT_TYPE context;
1905 deserStatus = msg.deserialize(context);
1906 FW_ASSERT(
1907 deserStatus == Fw::FW_SERIALIZE_OK,
1908 static_cast<FwAssertArgType>(deserStatus)
1909 );
1910 // Call handler function
1911 this->Run_handler(
1912 portNum,
1913 context
1914 );
1915
1916 break;
1917 }
1918
1919 // Handle async input port pingIn
1920 case PINGIN_PING: {
1921 // Deserialize argument key
1922 U32 key;
1923 deserStatus = msg.deserialize(key);
1924 FW_ASSERT(
1925 deserStatus == Fw::FW_SERIALIZE_OK,
1926 static_cast<FwAssertArgType>(deserStatus)
1927 );
1928 // Call handler function
1929 this->pingIn_handler(
1930 portNum,
1931 key
1932 );
1933
1934 break;
1935 }
1936
1937 // Handle command SET_LEVEL
1938 case CMD_SET_LEVEL: {
1939 // Deserialize opcode
1940 FwOpcodeType opCode = 0;
1941 deserStatus = msg.deserialize(opCode);
1942 FW_ASSERT (
1943 deserStatus == Fw::FW_SERIALIZE_OK,
1944 static_cast<FwAssertArgType>(deserStatus)
1945 );
1946
1947 // Deserialize command sequence
1948 U32 cmdSeq = 0;
1949 deserStatus = msg.deserialize(cmdSeq);
1950 FW_ASSERT (
1951 deserStatus == Fw::FW_SERIALIZE_OK,
1952 static_cast<FwAssertArgType>(deserStatus)
1953 );
1954
1955 // Deserialize command argument buffer
1956 Fw::CmdArgBuffer args;
1957 deserStatus = msg.deserialize(args);
1958 FW_ASSERT (
1959 deserStatus == Fw::FW_SERIALIZE_OK,
1960 static_cast<FwAssertArgType>(deserStatus)
1961 );
1962
1963 // Reset buffer
1964 args.resetDeser();
1965
1966 // Deserialize argument level
1967 U32 level;
1968 deserStatus = args.deserialize(level);
1969 if (deserStatus != Fw::FW_SERIALIZE_OK) {
1970 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
1971 this->cmdResponse_out(
1972 opCode,
1973 cmdSeq,
1975 );
1976 }
1977 // Don't crash the task if bad arguments were passed from the ground
1978 break;
1979 }
1980
1981 // Make sure there was no data left over.
1982 // That means the argument buffer size was incorrect.
1983#if FW_CMD_CHECK_RESIDUAL
1984 if (args.getBuffLeft() != 0) {
1985 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
1986 this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
1987 }
1988 // Don't crash the task if bad arguments were passed from the ground
1989 break;
1990 }
1991#endif
1992
1993 // Call handler function
1994 this->SET_LEVEL_cmdHandler(
1995 opCode, cmdSeq,
1996 level
1997 );
1998
1999 break;
2000 }
2001
2002 // Handle command SEND_PKT
2003 case CMD_SEND_PKT: {
2004 // Deserialize opcode
2005 FwOpcodeType opCode = 0;
2006 deserStatus = msg.deserialize(opCode);
2007 FW_ASSERT (
2008 deserStatus == Fw::FW_SERIALIZE_OK,
2009 static_cast<FwAssertArgType>(deserStatus)
2010 );
2011
2012 // Deserialize command sequence
2013 U32 cmdSeq = 0;
2014 deserStatus = msg.deserialize(cmdSeq);
2015 FW_ASSERT (
2016 deserStatus == Fw::FW_SERIALIZE_OK,
2017 static_cast<FwAssertArgType>(deserStatus)
2018 );
2019
2020 // Deserialize command argument buffer
2021 Fw::CmdArgBuffer args;
2022 deserStatus = msg.deserialize(args);
2023 FW_ASSERT (
2024 deserStatus == Fw::FW_SERIALIZE_OK,
2025 static_cast<FwAssertArgType>(deserStatus)
2026 );
2027
2028 // Reset buffer
2029 args.resetDeser();
2030
2031 // Deserialize argument id
2032 U32 id;
2033 deserStatus = args.deserialize(id);
2034 if (deserStatus != Fw::FW_SERIALIZE_OK) {
2035 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2036 this->cmdResponse_out(
2037 opCode,
2038 cmdSeq,
2040 );
2041 }
2042 // Don't crash the task if bad arguments were passed from the ground
2043 break;
2044 }
2045
2046 // Make sure there was no data left over.
2047 // That means the argument buffer size was incorrect.
2048#if FW_CMD_CHECK_RESIDUAL
2049 if (args.getBuffLeft() != 0) {
2050 if (this->m_cmdResponseOut_OutputPort[0].isConnected()) {
2051 this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
2052 }
2053 // Don't crash the task if bad arguments were passed from the ground
2054 break;
2055 }
2056#endif
2057
2058 // Call handler function
2059 this->SEND_PKT_cmdHandler(
2060 opCode, cmdSeq,
2061 id
2062 );
2063
2064 break;
2065 }
2066
2067 default:
2068 return MSG_DISPATCH_ERROR;
2069 }
2070
2071 return MSG_DISPATCH_OK;
2072 }
2073
2074 // ----------------------------------------------------------------------
2075 // Calls for messages received on special input ports
2076 // ----------------------------------------------------------------------
2077
2078 void TlmPacketizerComponentBase ::
2079 m_p_cmdIn_in(
2080 Fw::PassiveComponentBase* callComp,
2081 NATIVE_INT_TYPE portNum,
2082 FwOpcodeType opCode,
2083 U32 cmdSeq,
2084 Fw::CmdArgBuffer& args
2085 )
2086 {
2087 FW_ASSERT(callComp);
2088 TlmPacketizerComponentBase* compPtr = static_cast<TlmPacketizerComponentBase*>(callComp);
2089
2090 const U32 idBase = callComp->getIdBase();
2091 FW_ASSERT(opCode >= idBase, opCode, idBase);
2092
2093 // Select base class function based on opcode
2094 switch (opCode - idBase) {
2095 case OPCODE_SET_LEVEL: {
2096 compPtr->SET_LEVEL_cmdHandlerBase(
2097 opCode,
2098 cmdSeq,
2099 args
2100 );
2101 break;
2102 }
2103
2104 case OPCODE_SEND_PKT: {
2105 compPtr->SEND_PKT_cmdHandlerBase(
2106 opCode,
2107 cmdSeq,
2108 args
2109 );
2110 break;
2111 }
2112 }
2113 }
2114
2115 // ----------------------------------------------------------------------
2116 // Calls for messages received on typed input ports
2117 // ----------------------------------------------------------------------
2118
2119 void TlmPacketizerComponentBase ::
2120 m_p_Run_in(
2121 Fw::PassiveComponentBase* callComp,
2122 NATIVE_INT_TYPE portNum,
2123 NATIVE_UINT_TYPE context
2124 )
2125 {
2126 FW_ASSERT(callComp);
2127 TlmPacketizerComponentBase* compPtr = static_cast<TlmPacketizerComponentBase*>(callComp);
2128 compPtr->Run_handlerBase(
2129 portNum,
2130 context
2131 );
2132 }
2133
2134 void TlmPacketizerComponentBase ::
2135 m_p_TlmRecv_in(
2136 Fw::PassiveComponentBase* callComp,
2137 NATIVE_INT_TYPE portNum,
2138 FwChanIdType id,
2139 Fw::Time& timeTag,
2140 Fw::TlmBuffer& val
2141 )
2142 {
2143 FW_ASSERT(callComp);
2144 TlmPacketizerComponentBase* compPtr = static_cast<TlmPacketizerComponentBase*>(callComp);
2145 compPtr->TlmRecv_handlerBase(
2146 portNum,
2147 id,
2148 timeTag,
2149 val
2150 );
2151 }
2152
2153 void TlmPacketizerComponentBase ::
2154 m_p_pingIn_in(
2155 Fw::PassiveComponentBase* callComp,
2156 NATIVE_INT_TYPE portNum,
2157 U32 key
2158 )
2159 {
2160 FW_ASSERT(callComp);
2161 TlmPacketizerComponentBase* compPtr = static_cast<TlmPacketizerComponentBase*>(callComp);
2162 compPtr->pingIn_handlerBase(
2163 portNum,
2164 key
2165 );
2166 }
2167
2168}
#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
@ TB_NONE
No time base has been established.
Definition FpConfig.h:39
PlatformAssertArgType FwAssertArgType
Definition FpConfig.h:21
U32 FwChanIdType
Definition FpConfig.h:59
U32 FwEventIdType
Definition FpConfig.h:62
U32 FwOpcodeType
Definition FpConfig.h:56
#define FW_LOG_TEXT_BUFFER_SIZE
Max size of string for text log message.
Definition FpConfig.h:299
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects)
Definition FpConfig.h:88
@ ACTIVE_COMPONENT_EXIT
message to exit active component task
Enum representing a command response.
@ FORMAT_ERROR
Command failed to deserialize.
@ SERIALIZED_SIZE
The size of the serial representations of the port arguments.
Definition CmdPortAc.hpp:37
@ ACTIVITY_HI
Important informational events.
@ WARNING_LO
A less serious but recoverable event.
@ ACTIVITY_LO
Less important informational events.
void init()
Object initializer.
Definition ObjBase.cpp:27
NATIVE_UINT_TYPE getBuffLeft() const
returns how much deserialization buffer is left
void resetDeser()
reset deserialization to beginning
SerializeStatus deserialize(U8 &val)
deserialize 8-bit unsigned int
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
@ 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.
const Time ZERO_TIME
Definition Time.cpp:5