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