F´ Flight Software - C/C++ Documentation  NASA-v1.5.0
A framework for building embedded system applications to NASA flight quality standards.
BlockDriverComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title BlockDriverComponentAc.cpp
3 // \author Auto-generated
4 // \brief cpp file for BlockDriver component base class
5 //
6 // \copyright
7 // Copyright 2009-2015, by the California Institute of Technology.
8 // ALL RIGHTS RESERVED. United States Government Sponsorship
9 // acknowledged.
10 //
11 // ======================================================================
12 
13 #include <stdio.h>
14 #include <FpConfig.hpp>
16 #include <Fw/Types/Assert.hpp>
17 #if FW_ENABLE_TEXT_LOGGING
19 #endif
20 
21 
22 namespace Drv {
23 
24  // ----------------------------------------------------------------------
25  // Anonymous namespace to prevent name collisions
26  // ----------------------------------------------------------------------
27 
28  namespace {
29 
30  typedef enum {
31  BLOCKDRIVER_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
32  SCHED_SCHED,
33  BUFFERIN_DATABUFFER,
34  PINGIN_PING,
35  INT_IF_INTERRUPTREPORT
36  } MsgTypeEnum;
37 
38  // Get the max size by doing a union of the input port serialization sizes.
39 
40  typedef union {
44  // Size of InterruptReport argument list
46  sizeof(U32) +
47  0
48  ];
49  } BuffUnion;
50 
51  // Define a message buffer class large enough to handle all the
52  // asynchronous inputs to the component
53 
54  class ComponentIpcSerializableBuffer :
56  {
57 
58  public:
59 
60  enum {
61  // Max. message size = size of data + message id + port
62  SERIALIZATION_SIZE =
63  sizeof(BuffUnion) +
64  sizeof(NATIVE_INT_TYPE) +
65  sizeof(NATIVE_INT_TYPE)
66  };
67 
68  NATIVE_UINT_TYPE getBuffCapacity(void) const {
69  return sizeof(m_buff);
70  }
71 
72  U8* getBuffAddr(void) {
73  return m_buff;
74  }
75 
76  const U8* getBuffAddr(void) const {
77  return m_buff;
78  }
79 
80  private:
81  // Should be the max of all the input ports serialized sizes...
82  U8 m_buff[SERIALIZATION_SIZE];
83 
84  };
85 
86  }
87 
88  // ----------------------------------------------------------------------
89  // Getters for numbers of input ports
90  // ----------------------------------------------------------------------
91 
94  {
95  FW_ASSERT(portNum < this->getNum_Sched_InputPorts(),static_cast<AssertArg>(portNum));
96  return &this->m_Sched_InputPort[portNum];
97  }
98 
101  {
102  FW_ASSERT(portNum < this->getNum_BufferIn_InputPorts(),static_cast<AssertArg>(portNum));
103  return &this->m_BufferIn_InputPort[portNum];
104  }
105 
108  {
109  FW_ASSERT(portNum < this->getNum_PingIn_InputPorts(),static_cast<AssertArg>(portNum));
110  return &this->m_PingIn_InputPort[portNum];
111  }
112 
113  // ----------------------------------------------------------------------
114  // Typed connectors for output ports
115  // ----------------------------------------------------------------------
116 
119  NATIVE_INT_TYPE portNum,
120  Svc::InputCyclePort* port
121  )
122  {
123  FW_ASSERT(portNum < this->getNum_CycleOut_OutputPorts(),static_cast<AssertArg>(portNum));
124  this->m_CycleOut_OutputPort[portNum].addCallPort(port);
125  }
126 
129  NATIVE_INT_TYPE portNum,
131  )
132  {
133  FW_ASSERT(portNum < this->getNum_BufferOut_OutputPorts(),static_cast<AssertArg>(portNum));
135  }
136 
139  NATIVE_INT_TYPE portNum,
140  Svc::InputPingPort* port
141  )
142  {
143  FW_ASSERT(portNum < this->getNum_PingOut_OutputPorts(),static_cast<AssertArg>(portNum));
145  }
146 
149  NATIVE_INT_TYPE portNum,
150  Fw::InputTlmPort* port
151  )
152  {
153  FW_ASSERT(portNum < this->getNum_Tlm_OutputPorts(),static_cast<AssertArg>(portNum));
154  this->m_Tlm_OutputPort[portNum].addCallPort(port);
155  }
156 
159  NATIVE_INT_TYPE portNum,
160  Fw::InputTimePort* port
161  )
162  {
163  FW_ASSERT(portNum < this->getNum_Time_OutputPorts(),static_cast<AssertArg>(portNum));
165  }
166 
167  // ----------------------------------------------------------------------
168  // Serialization connectors for output ports
169  // ----------------------------------------------------------------------
170 
171 #if FW_PORT_SERIALIZATION
172 
175  NATIVE_INT_TYPE portNum,
176  Fw::InputSerializePort *port
177  )
178  {
179  FW_ASSERT(portNum < this->getNum_CycleOut_OutputPorts(),static_cast<AssertArg>(portNum));
180  return this->m_CycleOut_OutputPort[portNum].registerSerialPort(port);
181  }
182 
185  NATIVE_INT_TYPE portNum,
186  Fw::InputSerializePort *port
187  )
188  {
189  FW_ASSERT(portNum < this->getNum_BufferOut_OutputPorts(),static_cast<AssertArg>(portNum));
190  return this->m_BufferOut_OutputPort[portNum].registerSerialPort(port);
191  }
192 
195  NATIVE_INT_TYPE portNum,
196  Fw::InputSerializePort *port
197  )
198  {
199  FW_ASSERT(portNum < this->getNum_PingOut_OutputPorts(),static_cast<AssertArg>(portNum));
200  return this->m_PingOut_OutputPort[portNum].registerSerialPort(port);
201  }
202 
205  NATIVE_INT_TYPE portNum,
206  Fw::InputSerializePort *port
207  )
208  {
209  FW_ASSERT(portNum < this->getNum_Tlm_OutputPorts(),static_cast<AssertArg>(portNum));
210  return this->m_Tlm_OutputPort[portNum].registerSerialPort(port);
211  }
212 
215  NATIVE_INT_TYPE portNum,
216  Fw::InputSerializePort *port
217  )
218  {
219  FW_ASSERT(portNum < this->getNum_Time_OutputPorts(),static_cast<AssertArg>(portNum));
220  return this->m_Time_OutputPort[portNum].registerSerialPort(port);
221  }
222 
223 #endif
224 
225  // ----------------------------------------------------------------------
226  // Component construction, initialization, and destruction
227  // ----------------------------------------------------------------------
228 
229  BlockDriverComponentBase ::
230 #if FW_OBJECT_NAMES == 1
231  BlockDriverComponentBase(const char* compName) :
232  Fw::ActiveComponentBase(compName)
233 #else
234  BlockDriverComponentBase() :
235  Fw::ActiveComponentBase()
236 #endif
237  {
238 
239 
240 
241  }
242 
244  init(
245  NATIVE_INT_TYPE queueDepth,
246  NATIVE_INT_TYPE instance
247  )
248  {
249 
250  // Initialize base class
252 
253  // Connect input port Sched
254  for (
255  NATIVE_INT_TYPE port = 0;
256  port < this->getNum_Sched_InputPorts();
257  port++
258  ) {
259 
260  this->m_Sched_InputPort[port].init();
261  this->m_Sched_InputPort[port].addCallComp(
262  this,
263  m_p_Sched_in
264  );
265  this->m_Sched_InputPort[port].setPortNum(port);
266 
267 #if FW_OBJECT_NAMES == 1
268  char portName[120];
269  (void) snprintf(
270  portName,
271  sizeof(portName),
272  "%s_Sched_InputPort[%d]",
273  this->m_objName,
274  port
275  );
276  this->m_Sched_InputPort[port].setObjName(portName);
277 #endif
278 
279  }
280 
281  // Connect input port BufferIn
282  for (
283  NATIVE_INT_TYPE port = 0;
284  port < this->getNum_BufferIn_InputPorts();
285  port++
286  ) {
287 
288  this->m_BufferIn_InputPort[port].init();
289  this->m_BufferIn_InputPort[port].addCallComp(
290  this,
292  );
293  this->m_BufferIn_InputPort[port].setPortNum(port);
294 
295 #if FW_OBJECT_NAMES == 1
296  char portName[120];
297  (void) snprintf(
298  portName,
299  sizeof(portName),
300  "%s_BufferIn_InputPort[%d]",
301  this->m_objName,
302  port
303  );
304  this->m_BufferIn_InputPort[port].setObjName(portName);
305 #endif
306 
307  }
308 
309  // Connect input port PingIn
310  for (
311  NATIVE_INT_TYPE port = 0;
312  port < this->getNum_PingIn_InputPorts();
313  port++
314  ) {
315 
316  this->m_PingIn_InputPort[port].init();
317  this->m_PingIn_InputPort[port].addCallComp(
318  this,
320  );
321  this->m_PingIn_InputPort[port].setPortNum(port);
322 
323 #if FW_OBJECT_NAMES == 1
324  char portName[120];
325  (void) snprintf(
326  portName,
327  sizeof(portName),
328  "%s_PingIn_InputPort[%d]",
329  this->m_objName,
330  port
331  );
332  this->m_PingIn_InputPort[port].setObjName(portName);
333 #endif
334 
335  }
336 
337  // Initialize output port CycleOut
338  for (
339  NATIVE_INT_TYPE port = 0;
340  port < this->getNum_CycleOut_OutputPorts();
341  port++
342  ) {
343  this->m_CycleOut_OutputPort[port].init();
344 
345 #if FW_OBJECT_NAMES == 1
346  char portName[120];
347  (void) snprintf(
348  portName,
349  sizeof(portName),
350  "%s_CycleOut_OutputPort[%d]",
351  this->m_objName,
352  port
353  );
354  this->m_CycleOut_OutputPort[port].setObjName(portName);
355 #endif
356 
357  }
358 
359  // Initialize output port BufferOut
360  for (
361  NATIVE_INT_TYPE port = 0;
362  port < this->getNum_BufferOut_OutputPorts();
363  port++
364  ) {
365  this->m_BufferOut_OutputPort[port].init();
366 
367 #if FW_OBJECT_NAMES == 1
368  char portName[120];
369  (void) snprintf(
370  portName,
371  sizeof(portName),
372  "%s_BufferOut_OutputPort[%d]",
373  this->m_objName,
374  port
375  );
376  this->m_BufferOut_OutputPort[port].setObjName(portName);
377 #endif
378 
379  }
380 
381  // Initialize output port PingOut
382  for (
383  NATIVE_INT_TYPE port = 0;
384  port < this->getNum_PingOut_OutputPorts();
385  port++
386  ) {
387  this->m_PingOut_OutputPort[port].init();
388 
389 #if FW_OBJECT_NAMES == 1
390  char portName[120];
391  (void) snprintf(
392  portName,
393  sizeof(portName),
394  "%s_PingOut_OutputPort[%d]",
395  this->m_objName,
396  port
397  );
398  this->m_PingOut_OutputPort[port].setObjName(portName);
399 #endif
400 
401  }
402 
403  // Initialize output port Tlm
404  for (
405  NATIVE_INT_TYPE port = 0;
406  port < this->getNum_Tlm_OutputPorts();
407  port++
408  ) {
409  this->m_Tlm_OutputPort[port].init();
410 
411 #if FW_OBJECT_NAMES == 1
412  char portName[120];
413  (void) snprintf(
414  portName,
415  sizeof(portName),
416  "%s_Tlm_OutputPort[%d]",
417  this->m_objName,
418  port
419  );
420  this->m_Tlm_OutputPort[port].setObjName(portName);
421 #endif
422 
423  }
424 
425  // Initialize output port Time
426  for (
427  NATIVE_INT_TYPE port = 0;
428  port < this->getNum_Time_OutputPorts();
429  port++
430  ) {
431  this->m_Time_OutputPort[port].init();
432 
433 #if FW_OBJECT_NAMES == 1
434  char portName[120];
435  (void) snprintf(
436  portName,
437  sizeof(portName),
438  "%s_Time_OutputPort[%d]",
439  this->m_objName,
440  port
441  );
442  this->m_Time_OutputPort[port].setObjName(portName);
443 #endif
444 
445  }
446 
447  Os::Queue::QueueStatus qStat =
448  this->createQueue(
449  queueDepth,
450  ComponentIpcSerializableBuffer::SERIALIZATION_SIZE
451  );
452  FW_ASSERT(
453  Os::Queue::QUEUE_OK == qStat,
454  static_cast<AssertArg>(qStat)
455  );
456 
457  }
458 
461 
462  }
463 
464  // ----------------------------------------------------------------------
465  // Invocation functions for output ports
466  // ----------------------------------------------------------------------
467 
468  void BlockDriverComponentBase ::
469  CycleOut_out(
470  NATIVE_INT_TYPE portNum,
471  Svc::TimerVal &cycleStart
472  )
473  {
474  FW_ASSERT(portNum < this->getNum_CycleOut_OutputPorts(),static_cast<AssertArg>(portNum));
475  this->m_CycleOut_OutputPort[portNum].invoke(cycleStart);
476  }
477 
480  NATIVE_INT_TYPE portNum,
481  Drv::DataBuffer &buff
482  )
483  {
484  FW_ASSERT(portNum < this->getNum_BufferOut_OutputPorts(),static_cast<AssertArg>(portNum));
486  }
487 
490  NATIVE_INT_TYPE portNum,
491  U32 key
492  )
493  {
494  FW_ASSERT(portNum < this->getNum_PingOut_OutputPorts(),static_cast<AssertArg>(portNum));
495  this->m_PingOut_OutputPort[portNum].invoke(key);
496  }
497 
498  // ----------------------------------------------------------------------
499  // Getters for numbers of ports
500  // ----------------------------------------------------------------------
501 
502  NATIVE_INT_TYPE BlockDriverComponentBase ::
503  getNum_Sched_InputPorts(void)
504  {
506  this->m_Sched_InputPort
507  );
508  }
509 
512  {
515  );
516  }
517 
518  NATIVE_INT_TYPE BlockDriverComponentBase ::
519  getNum_CycleOut_OutputPorts(void)
520  {
522  this->m_CycleOut_OutputPort
523  );
524  }
525 
528  {
531  );
532  }
533 
536  {
538  this->m_PingIn_InputPort
539  );
540  }
541 
544  {
547  );
548  }
549 
552  {
554  this->m_Tlm_OutputPort
555  );
556  }
557 
560  {
562  this->m_Time_OutputPort
563  );
564  }
565 
566  // ----------------------------------------------------------------------
567  // Port connection status queries
568  // ----------------------------------------------------------------------
569 
570  bool BlockDriverComponentBase ::
571  isConnected_CycleOut_OutputPort(NATIVE_INT_TYPE portNum)
572  {
573  FW_ASSERT(
574  portNum < this->getNum_CycleOut_OutputPorts(),
575  static_cast<AssertArg>(portNum)
576  );
577  return this->m_CycleOut_OutputPort[portNum].isConnected();
578  }
579 
582  {
583  FW_ASSERT(
584  portNum < this->getNum_BufferOut_OutputPorts(),
585  static_cast<AssertArg>(portNum)
586  );
588  }
589 
592  {
593  FW_ASSERT(
594  portNum < this->getNum_PingOut_OutputPorts(),
595  static_cast<AssertArg>(portNum)
596  );
597  return this->m_PingOut_OutputPort[portNum].isConnected();
598  }
599 
602  {
603  FW_ASSERT(
604  portNum < this->getNum_Tlm_OutputPorts(),
605  static_cast<AssertArg>(portNum)
606  );
607  return this->m_Tlm_OutputPort[portNum].isConnected();
608  }
609 
612  {
613  FW_ASSERT(
614  portNum < this->getNum_Time_OutputPorts(),
615  static_cast<AssertArg>(portNum)
616  );
617  return this->m_Time_OutputPort[portNum].isConnected();
618  }
619 
620  // ----------------------------------------------------------------------
621  // Telemetry write functions
622  // ----------------------------------------------------------------------
623 
624  void BlockDriverComponentBase ::
625  tlmWrite_BD_Cycles(U32 arg)
626  {
627 
628  if (this->m_Tlm_OutputPort[0].isConnected()) {
629  Fw::Time _tlmTime;
630  if (this->m_Time_OutputPort[0].isConnected()) {
631  this->m_Time_OutputPort[0].invoke( _tlmTime);
632  }
633  Fw::TlmBuffer _tlmBuff;
634  Fw::SerializeStatus _stat = _tlmBuff.serialize(arg);
635  FW_ASSERT(
636  _stat == Fw::FW_SERIALIZE_OK,
637  static_cast<AssertArg>(_stat)
638  );
639 
640  FwChanIdType _id;
641 
642  _id = this->getIdBase() + CHANNELID_BD_CYCLES;
643 
644  this->m_Tlm_OutputPort[0].invoke(
645  _id,
646  _tlmTime,
647  _tlmBuff
648  );
649  }
650 
651  }
652 
653  // ----------------------------------------------------------------------
654  // Time
655  // ----------------------------------------------------------------------
656 
657  Fw::Time BlockDriverComponentBase ::
658  getTime(void)
659  {
660  if (this->m_Time_OutputPort[0].isConnected()) {
661  Fw::Time _time;
662  this->m_Time_OutputPort[0].invoke(_time);
663  return _time;
664  } else {
665  return Fw::Time(TB_NONE,0,0);
666  }
667  }
668 
669  // ----------------------------------------------------------------------
670  // Invocation functions for interfaces
671  // ----------------------------------------------------------------------
672 
673  void BlockDriverComponentBase::
674  InterruptReport_internalInterfaceInvoke(
675  U32 interrupt
676  )
677  {
678 
679  ComponentIpcSerializableBuffer msg;
681 
682  // Serialize the message ID
683  _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(INT_IF_INTERRUPTREPORT));
684  FW_ASSERT (
685  _status == Fw::FW_SERIALIZE_OK,
686  static_cast<AssertArg>(_status)
687  );
688 
689  // Fake port number to make message dequeue work
690  _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(0));
691  FW_ASSERT (
692  _status == Fw::FW_SERIALIZE_OK,
693  static_cast<AssertArg>(_status)
694  );
695 
696  _status = msg.serialize(interrupt);
697  FW_ASSERT(_status == Fw::FW_SERIALIZE_OK, static_cast<AssertArg>(_status));
698 
699  // send message
700  Os::Queue::QueueBlocking _block =
702  Os::Queue::QueueStatus qStatus =
703  this->m_queue.send(msg, 1,_block);
704  FW_ASSERT(
705  qStatus == Os::Queue::QUEUE_OK,
706  static_cast<AssertArg>(qStatus)
707  );
708 
709  }
710 
711  // ----------------------------------------------------------------------
712  // Calls for invocations received on typed input ports
713  // ----------------------------------------------------------------------
714 
715  void BlockDriverComponentBase ::
716  m_p_Sched_in(
717  Fw::PassiveComponentBase* callComp,
718  NATIVE_INT_TYPE portNum,
719  NATIVE_UINT_TYPE context
720  )
721  {
722  FW_ASSERT(callComp);
723  BlockDriverComponentBase* compPtr =
724  (BlockDriverComponentBase*) callComp;
725  compPtr->Sched_handlerBase(portNum, context);
726  }
727 
730  Fw::PassiveComponentBase* callComp,
731  NATIVE_INT_TYPE portNum,
732  Drv::DataBuffer &buff
733  )
734  {
735  FW_ASSERT(callComp);
736  BlockDriverComponentBase* compPtr =
737  (BlockDriverComponentBase*) callComp;
738  compPtr->BufferIn_handlerBase(portNum, buff);
739  }
740 
743  Fw::PassiveComponentBase* callComp,
744  NATIVE_INT_TYPE portNum,
745  U32 key
746  )
747  {
748  FW_ASSERT(callComp);
749  BlockDriverComponentBase* compPtr =
750  (BlockDriverComponentBase*) callComp;
751  compPtr->PingIn_handlerBase(portNum, key);
752  }
753 
754  // ----------------------------------------------------------------------
755  // Port handler base-class functions for typed input ports
756  // ----------------------------------------------------------------------
757 
758  void BlockDriverComponentBase ::
759  Sched_handlerBase(
760  NATIVE_INT_TYPE portNum,
761  NATIVE_UINT_TYPE context
762  )
763  {
764 
765  // Make sure port number is valid
766  FW_ASSERT(portNum < this->getNum_Sched_InputPorts(),static_cast<AssertArg>(portNum));
767 
768  // Call pre-message hook
769  Sched_preMsgHook(
770  portNum,
771  context
772  );
773 
774  ComponentIpcSerializableBuffer msg;
776 
777  _status = msg.serialize(
778  static_cast<NATIVE_INT_TYPE>(SCHED_SCHED)
779  );
780  FW_ASSERT (
781  _status == Fw::FW_SERIALIZE_OK,
782  static_cast<AssertArg>(_status)
783  );
784 
785  _status = msg.serialize(portNum);
786  FW_ASSERT (
787  _status == Fw::FW_SERIALIZE_OK,
788  static_cast<AssertArg>(_status)
789  );
790 
791  // Serialize argument context
792  _status = msg.serialize(context);
793  FW_ASSERT(
794  _status == Fw::FW_SERIALIZE_OK,
795  static_cast<AssertArg>(_status)
796  );
797 
798 
799  // send message
800  Os::Queue::QueueBlocking _block =
802  Os::Queue::QueueStatus qStatus =
803  this->m_queue.send(msg, 0,_block);
804  FW_ASSERT(
805  qStatus == Os::Queue::QUEUE_OK,
806  static_cast<AssertArg>(qStatus)
807  );
808 
809  }
810 
813  NATIVE_INT_TYPE portNum,
814  Drv::DataBuffer &buff
815  )
816  {
817 
818  // Make sure port number is valid
819  FW_ASSERT(portNum < this->getNum_BufferIn_InputPorts(),static_cast<AssertArg>(portNum));
820 
821  // Call pre-message hook
823  portNum,
824  buff
825  );
826 
827  ComponentIpcSerializableBuffer msg;
829 
830  _status = msg.serialize(
831  static_cast<NATIVE_INT_TYPE>(BUFFERIN_DATABUFFER)
832  );
833  FW_ASSERT (
834  _status == Fw::FW_SERIALIZE_OK,
835  static_cast<AssertArg>(_status)
836  );
837 
838  _status = msg.serialize(portNum);
839  FW_ASSERT (
840  _status == Fw::FW_SERIALIZE_OK,
841  static_cast<AssertArg>(_status)
842  );
843 
844  // Serialize argument buff
845  _status = msg.serialize(buff);
846  FW_ASSERT(
847  _status == Fw::FW_SERIALIZE_OK,
848  static_cast<AssertArg>(_status)
849  );
850 
851 
852  // send message
853  Os::Queue::QueueBlocking _block =
855  Os::Queue::QueueStatus qStatus =
856  this->m_queue.send(msg, 0,_block);
857  FW_ASSERT(
858  qStatus == Os::Queue::QUEUE_OK,
859  static_cast<AssertArg>(qStatus)
860  );
861 
862  }
863 
866  NATIVE_INT_TYPE portNum,
867  U32 key
868  )
869  {
870 
871  // Make sure port number is valid
872  FW_ASSERT(portNum < this->getNum_PingIn_InputPorts(),static_cast<AssertArg>(portNum));
873 
874  // Call pre-message hook
876  portNum,
877  key
878  );
879 
880  ComponentIpcSerializableBuffer msg;
882 
883  _status = msg.serialize(
884  static_cast<NATIVE_INT_TYPE>(PINGIN_PING)
885  );
886  FW_ASSERT (
887  _status == Fw::FW_SERIALIZE_OK,
888  static_cast<AssertArg>(_status)
889  );
890 
891  _status = msg.serialize(portNum);
892  FW_ASSERT (
893  _status == Fw::FW_SERIALIZE_OK,
894  static_cast<AssertArg>(_status)
895  );
896 
897  // Serialize argument key
898  _status = msg.serialize(key);
899  FW_ASSERT(
900  _status == Fw::FW_SERIALIZE_OK,
901  static_cast<AssertArg>(_status)
902  );
903 
904 
905  // send message
906  Os::Queue::QueueBlocking _block =
908  Os::Queue::QueueStatus qStatus =
909  this->m_queue.send(msg, 0,_block);
910  FW_ASSERT(
911  qStatus == Os::Queue::QUEUE_OK,
912  static_cast<AssertArg>(qStatus)
913  );
914 
915  }
916 
917  // ----------------------------------------------------------------------
918  // Pre-message hooks for async input ports
919  // ----------------------------------------------------------------------
920 
921  void BlockDriverComponentBase ::
922  Sched_preMsgHook(
923  NATIVE_INT_TYPE portNum,
924  NATIVE_UINT_TYPE context
925  )
926  {
927  // Default: no-op
928  }
929 
932  NATIVE_INT_TYPE portNum,
933  Drv::DataBuffer &buff
934  )
935  {
936  // Default: no-op
937  }
938 
941  NATIVE_INT_TYPE portNum,
942  U32 key
943  )
944  {
945  // Default: no-op
946  }
947 
948  // ----------------------------------------------------------------------
949  // Message dispatch method for active and queued components. Called
950  // by active component thread or implementation code for queued components
951  // ----------------------------------------------------------------------
952 
954  doDispatch(void)
955  {
956  ComponentIpcSerializableBuffer msg;
957  NATIVE_INT_TYPE priority;
958 
959  Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_BLOCKING);
960  FW_ASSERT(
961  msgStatus == Os::Queue::QUEUE_OK,
962  static_cast<AssertArg>(msgStatus)
963  );
964 
965  // Reset to beginning of buffer
966  msg.resetDeser();
967 
968  NATIVE_INT_TYPE desMsg;
969  Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
970  FW_ASSERT(
971  deserStatus == Fw::FW_SERIALIZE_OK,
972  static_cast<AssertArg>(deserStatus)
973  );
974 
975  MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
976 
977  if (msgType == BLOCKDRIVER_COMPONENT_EXIT) {
978  return MSG_DISPATCH_EXIT;
979  }
980 
982  deserStatus = msg.deserialize(portNum);
983  FW_ASSERT(
984  deserStatus == Fw::FW_SERIALIZE_OK,
985  static_cast<AssertArg>(deserStatus)
986  );
987 
988  switch (msgType) {
989 
990  // Handle async input port Sched
991  case SCHED_SCHED: {
992 
993  // Deserialize argument context
995  deserStatus = msg.deserialize(context);
996  FW_ASSERT(
997  deserStatus == Fw::FW_SERIALIZE_OK,
998  static_cast<AssertArg>(deserStatus)
999  );
1000 
1001  // Call handler function
1002  this->Sched_handler(
1003  portNum,
1004  context
1005  );
1006 
1007  break;
1008 
1009  }
1010 
1011  // Handle async input port BufferIn
1012  case BUFFERIN_DATABUFFER: {
1013 
1014  // Deserialize argument buff
1015  Drv::DataBuffer buff;
1016  deserStatus = msg.deserialize(buff);
1017  FW_ASSERT(
1018  deserStatus == Fw::FW_SERIALIZE_OK,
1019  static_cast<AssertArg>(deserStatus)
1020  );
1021 
1022  // Call handler function
1023  this->BufferIn_handler(
1024  portNum,
1025  buff
1026  );
1027 
1028  break;
1029 
1030  }
1031 
1032  // Handle async input port PingIn
1033  case PINGIN_PING: {
1034 
1035  // Deserialize argument key
1036  U32 key;
1037  deserStatus = msg.deserialize(key);
1038  FW_ASSERT(
1039  deserStatus == Fw::FW_SERIALIZE_OK,
1040  static_cast<AssertArg>(deserStatus)
1041  );
1042 
1043  // Call handler function
1044  this->PingIn_handler(
1045  portNum,
1046  key
1047  );
1048 
1049  break;
1050 
1051  }
1052 
1053  // Handle internal interface InterruptReport
1054  case INT_IF_INTERRUPTREPORT: {
1055 
1056  U32 interrupt;
1057  deserStatus = msg.deserialize(interrupt);
1058 
1059  // Internal interfaces should always deserialize
1060  FW_ASSERT(
1061  Fw::FW_SERIALIZE_OK == deserStatus,
1062  static_cast<AssertArg>(deserStatus)
1063  );
1064 
1065  // Make sure there was no data left over.
1066  // That means the buffer size was incorrect.
1067  FW_ASSERT(
1068  msg.getBuffLeft() == 0,
1069  static_cast<AssertArg>(msg.getBuffLeft())
1070  );
1071 
1072  // Call handler function
1073  this->InterruptReport_internalInterfaceHandler(interrupt);
1074 
1075  break;
1076 
1077  }
1078 
1079  default:
1080  return MSG_DISPATCH_ERROR;
1081 
1082  }
1083 
1084  return MSG_DISPATCH_OK;
1085 
1086  }
1087 
1088 } // end namespace Drv
Drv::BlockDriverComponentBase::set_Time_OutputPort
void set_Time_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTimePort *port)
Definition: BlockDriverComponentAc.cpp:158
Drv::BlockDriverComponentBase::isConnected_Time_OutputPort
bool isConnected_Time_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BlockDriverComponentAc.cpp:611
Fw::InputTimePort
Definition: TimePortAc.hpp:28
Drv::BlockDriverComponentBase::~BlockDriverComponentBase
virtual ~BlockDriverComponentBase(void)
Definition: BlockDriverComponentAc.cpp:460
Svc::InputPingPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: PingPortAc.hpp:30
Drv::DataBuffer
Definition: DataBuffer.hpp:9
Fw::InputTlmPort
Definition: TlmPortAc.hpp:29
Drv::BlockDriverComponentBase::PingOut_out
void PingOut_out(NATIVE_INT_TYPE portNum, U32 key)
Definition: BlockDriverComponentAc.cpp:489
Drv::OutputDataBufferPort::addCallPort
void addCallPort(InputDataBufferPort *callPort)
Definition: DataBufferPortAc.cpp:93
Fw::PassiveComponentBase::getIdBase
U32 getIdBase(void) const
Definition: PassiveComponentBase.cpp:40
Drv::BlockDriverComponentBase::PingIn_handlerBase
void PingIn_handlerBase(NATIVE_INT_TYPE portNum, U32 key)
Definition: BlockDriverComponentAc.cpp:865
BlockDriverComponentAc.hpp
Drv::BlockDriverComponentBase::getNum_Tlm_OutputPorts
NATIVE_INT_TYPE getNum_Tlm_OutputPorts(void)
Definition: BlockDriverComponentAc.cpp:551
Fw::Time
Definition: Time.hpp:10
Drv::BlockDriverComponentBase::m_p_PingIn_in
static void m_p_PingIn_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, U32 key)
Definition: BlockDriverComponentAc.cpp:742
Drv::BlockDriverComponentBase::BufferIn_handler
virtual void BufferIn_handler(NATIVE_INT_TYPE portNum, Drv::DataBuffer &buff)=0
Handler for input port BufferIn.
port3
BYTE port3[Svc::InputPingPort::SERIALIZED_SIZE]
Definition: BlockDriverComponentAc.cpp:43
Fw::QueuedComponentBase::doDispatch
virtual MsgDispatchStatus doDispatch(void)=0
method to dispatch a single message in the queue.
Drv::BlockDriverComponentBase::get_BufferIn_InputPort
Drv::InputDataBufferPort * get_BufferIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BlockDriverComponentAc.cpp:100
Drv::BlockDriverComponentBase
Auto-generated base for BlockDriver component.
Definition: BlockDriverComponentAc.hpp:41
Fw::SerializeBufferBase
Definition: Serializable.hpp:43
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Fw::TlmBuffer
Definition: TlmBuffer.hpp:21
FwChanIdType
#define FwChanIdType
Type representation for a channel id.
Definition: FpConfig.hpp:66
Fw::PortBase::isConnected
bool isConnected(void)
Definition: PortBase.cpp:40
Drv::BlockDriverComponentBase::m_PingOut_OutputPort
Svc::OutputPingPort m_PingOut_OutputPort[NUM_PINGOUT_OUTPUT_PORTS]
Definition: BlockDriverComponentAc.hpp:536
Fw::SerializeBufferBase::serialize
SerializeStatus serialize(U8 val)
serialize 8-bit unsigned int
Definition: Serializable.cpp:67
FW_NUM_ARRAY_ELEMENTS
#define FW_NUM_ARRAY_ELEMENTS(a)
number of elements in an array
Definition: BasicTypes.hpp:103
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.hpp:76
Drv::BlockDriverComponentBase::m_BufferIn_InputPort
Drv::InputDataBufferPort m_BufferIn_InputPort[NUM_BUFFERIN_INPUT_PORTS]
Definition: BlockDriverComponentAc.hpp:514
Svc::InputPingPort::init
void init(void)
initialization function
Definition: PingPortAc.cpp:38
Drv::InputDataBufferPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: DataBufferPortAc.hpp:31
Svc::OutputPingPort::init
void init(void)
Definition: PingPortAc.cpp:89
Os::Queue::QueueStatus
QueueStatus
Definition: Queue.hpp:27
Drv
Definition: BlockDriverComponentAc.cpp:22
Fw::QueuedComponentBase::m_queue
Os::Queue m_queue
queue object for active component
Definition: QueuedComponentBase.hpp:36
Drv::BlockDriverComponentBase::set_BufferOut_OutputPort
void set_BufferOut_OutputPort(NATIVE_INT_TYPE portNum, Drv::InputDataBufferPort *port)
Definition: BlockDriverComponentAc.cpp:128
Svc::OutputPingPort::invoke
void invoke(U32 key)
Definition: PingPortAc.cpp:103
Drv::BlockDriverComponentBase::m_BufferOut_OutputPort
Drv::OutputDataBufferPort m_BufferOut_OutputPort[NUM_BUFFEROUT_OUTPUT_PORTS]
Definition: BlockDriverComponentAc.hpp:532
Drv::BlockDriverComponentBase::BufferIn_preMsgHook
virtual void BufferIn_preMsgHook(NATIVE_INT_TYPE portNum, Drv::DataBuffer &buff)
Definition: BlockDriverComponentAc.cpp:931
Drv::BlockDriverComponentBase::getNum_BufferIn_InputPorts
NATIVE_INT_TYPE getNum_BufferIn_InputPorts(void)
Definition: BlockDriverComponentAc.cpp:511
Svc::InputSchedPort::SERIALIZED_SIZE
@ SERIALIZED_SIZE
serialized size of port arguments
Definition: SchedPortAc.hpp:30
Assert.hpp
Drv::BlockDriverComponentBase::getNum_PingOut_OutputPorts
NATIVE_INT_TYPE getNum_PingOut_OutputPorts(void)
Definition: BlockDriverComponentAc.cpp:543
Fw::FW_SERIALIZE_OK
@ FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Os::Queue::send
QueueStatus send(const Fw::SerializeBufferBase &buffer, NATIVE_INT_TYPE priority, QueueBlocking block)
send a message
Definition: QueueCommon.cpp:13
Svc::InputCyclePort
Definition: CyclePortAc.hpp:28
Svc::OutputPingPort::addCallPort
void addCallPort(InputPingPort *callPort)
Definition: PingPortAc.cpp:93
EightyCharString.hpp
Fw::PassiveComponentBase
Definition: PassiveComponentBase.hpp:10
Drv::BlockDriverComponentBase::set_PingOut_OutputPort
void set_PingOut_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputPingPort *port)
Definition: BlockDriverComponentAc.cpp:138
Svc::TimerVal
Serializable class for carrying timer values.
Definition: TimerVal.hpp:22
Fw::OutputTimePort::init
void init(void)
Definition: TimePortAc.cpp:89
Fw::ObjBase::init
void init(void)
Object initializer.
Definition: ObjBase.cpp:26
Os::Queue::QueueBlocking
QueueBlocking
Definition: Queue.hpp:40
Fw::QueuedComponentBase::MSG_DISPATCH_OK
@ MSG_DISPATCH_OK
Dispatch was normal.
Definition: QueuedComponentBase.hpp:26
Drv::OutputDataBufferPort::init
void init(void)
Definition: DataBufferPortAc.cpp:89
BYTE
U8 BYTE
byte type
Definition: BasicTypes.hpp:77
Os::Queue::receive
QueueStatus receive(Fw::SerializeBufferBase &buffer, NATIVE_INT_TYPE &priority, QueueBlocking block)
receive a message
Definition: QueueCommon.cpp:22
Drv::BlockDriverComponentBase::cycleStart
PROTECTED Svc::TimerVal & cycleStart
Definition: BlockDriverComponentAc.hpp:294
Svc::InputPingPort
Definition: PingPortAc.hpp:27
Drv::BlockDriverComponentBase::isConnected_Tlm_OutputPort
bool isConnected_Tlm_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BlockDriverComponentAc.cpp:601
Drv::BlockDriverComponentBase::PingIn_handler
virtual void PingIn_handler(NATIVE_INT_TYPE portNum, U32 key)=0
Handler for input port PingIn.
Fw::OutputTlmPort::addCallPort
void addCallPort(InputTlmPort *callPort)
Definition: TlmPortAc.cpp:105
Drv::BlockDriverComponentBase::context
PROTECTED NATIVE_UINT_TYPE context
Definition: BlockDriverComponentAc.hpp:207
Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT
@ ACTIVE_COMPONENT_EXIT
message to exit active component task
Definition: ActiveComponentBase.hpp:27
Svc::InputSchedPort
Definition: SchedPortAc.hpp:27
port2
BYTE port2[Drv::InputDataBufferPort::SERIALIZED_SIZE]
Definition: BlockDriverComponentAc.cpp:42
Fw::QueuedComponentBase::MsgDispatchStatus
MsgDispatchStatus
Definition: QueuedComponentBase.hpp:25
Drv::BlockDriverComponentBase::set_CycleOut_OutputPort
void set_CycleOut_OutputPort(NATIVE_INT_TYPE portNum, Svc::InputCyclePort *port)
Definition: BlockDriverComponentAc.cpp:118
NATIVE_UINT_TYPE
unsigned int NATIVE_UINT_TYPE
native unsigned integer type declaration
Definition: BasicTypes.hpp:30
Fw::OutputTimePort::invoke
void invoke(Fw::Time &time)
Definition: TimePortAc.cpp:103
Fw::OutputTlmPort::invoke
void invoke(FwChanIdType id, Fw::Time &timeTag, TlmBuffer &val)
Definition: TlmPortAc.cpp:115
Drv::BlockDriverComponentBase::PingIn_preMsgHook
virtual void PingIn_preMsgHook(NATIVE_INT_TYPE portNum, U32 key)
Definition: BlockDriverComponentAc.cpp:940
Drv::InputDataBufferPort::init
void init(void)
initialization function
Definition: DataBufferPortAc.cpp:38
Drv::BlockDriverComponentBase::getNum_Time_OutputPorts
NATIVE_INT_TYPE getNum_Time_OutputPorts(void)
Definition: BlockDriverComponentAc.cpp:559
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:9
Drv::BlockDriverComponentBase::m_p_BufferIn_in
static void m_p_BufferIn_in(Fw::PassiveComponentBase *callComp, NATIVE_INT_TYPE portNum, Drv::DataBuffer &buff)
Definition: BlockDriverComponentAc.cpp:729
Drv::BlockDriverComponentBase::isConnected_BufferOut_OutputPort
bool isConnected_BufferOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BlockDriverComponentAc.cpp:581
Fw::QueuedComponentBase::MSG_DISPATCH_ERROR
@ MSG_DISPATCH_ERROR
Errors dispatching messages.
Definition: QueuedComponentBase.hpp:28
Os::Queue::QUEUE_OK
@ QUEUE_OK
message sent/received okay
Definition: Queue.hpp:28
Drv::BlockDriverComponentBase::get_PingIn_InputPort
Svc::InputPingPort * get_PingIn_InputPort(NATIVE_INT_TYPE portNum)
Definition: BlockDriverComponentAc.cpp:107
Drv::BlockDriverComponentBase::getNum_PingIn_InputPorts
NATIVE_INT_TYPE getNum_PingIn_InputPorts(void)
Definition: BlockDriverComponentAc.cpp:535
port1
BYTE port1[Svc::InputSchedPort::SERIALIZED_SIZE]
Definition: BlockDriverComponentAc.cpp:41
Fw::OutputTlmPort::init
void init(void)
Definition: TlmPortAc.cpp:101
FpConfig.hpp
ISF configuration file.
Fw::InputPortBase::setPortNum
void setPortNum(NATIVE_INT_TYPE portNum)
Definition: InputPortBase.cpp:25
Drv::BlockDriverComponentBase::get_Sched_InputPort
Svc::InputSchedPort * get_Sched_InputPort(NATIVE_INT_TYPE portNum)
Definition: BlockDriverComponentAc.cpp:93
Drv::BlockDriverComponentBase::portNum
PRIVATE NATIVE_INT_TYPE portNum
Definition: BlockDriverComponentAc.hpp:556
Fw::QueuedComponentBase::MSG_DISPATCH_EXIT
@ MSG_DISPATCH_EXIT
A message was sent requesting an exit of the loop.
Definition: QueuedComponentBase.hpp:29
Drv::InputDataBufferPort
Definition: DataBufferPortAc.hpp:28
Drv::BlockDriverComponentBase::getNum_BufferOut_OutputPorts
NATIVE_INT_TYPE getNum_BufferOut_OutputPorts(void)
Definition: BlockDriverComponentAc.cpp:527
Os::Queue::QUEUE_NONBLOCKING
@ QUEUE_NONBLOCKING
Queue receive always returns even if there is no message.
Definition: Queue.hpp:42
Drv::BlockDriverComponentBase::BufferIn_handlerBase
void BufferIn_handlerBase(NATIVE_INT_TYPE portNum, Drv::DataBuffer &buff)
Definition: BlockDriverComponentAc.cpp:812
Drv::BlockDriverComponentBase::m_Time_OutputPort
Fw::OutputTimePort m_Time_OutputPort[NUM_TIME_OUTPUT_PORTS]
Definition: BlockDriverComponentAc.hpp:544
NATIVE_INT_TYPE
int NATIVE_INT_TYPE
native integer type declaration
Definition: BasicTypes.hpp:29
Drv::InputDataBufferPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: DataBufferPortAc.cpp:42
AssertArg
#define AssertArg
Definition: FpConfig.hpp:51
InterruptReportIntIfSize
BYTE InterruptReportIntIfSize[sizeof(U32)+0]
Definition: BlockDriverComponentAc.cpp:48
Drv::BlockDriverComponentBase::set_Tlm_OutputPort
void set_Tlm_OutputPort(NATIVE_INT_TYPE portNum, Fw::InputTlmPort *port)
Definition: BlockDriverComponentAc.cpp:148
Drv::BlockDriverComponentBase::isConnected_PingOut_OutputPort
bool isConnected_PingOut_OutputPort(NATIVE_INT_TYPE portNum)
Definition: BlockDriverComponentAc.cpp:591
Fw::QueuedComponentBase::createQueue
Os::Queue::QueueStatus createQueue(NATIVE_INT_TYPE depth, NATIVE_INT_TYPE msgSize)
Definition: QueuedComponentBase.cpp:29
TB_NONE
@ TB_NONE
No time base has been established.
Definition: FpConfig.hpp:324
Drv::OutputDataBufferPort::invoke
void invoke(Drv::DataBuffer &buff)
Definition: DataBufferPortAc.cpp:103
Fw
Definition: BufferGetPortAc.cpp:6
Fw::OutputTimePort::addCallPort
void addCallPort(InputTimePort *callPort)
Definition: TimePortAc.cpp:93
Os::Queue::QUEUE_BLOCKING
@ QUEUE_BLOCKING
Queue receive blocks until a message arrives.
Definition: Queue.hpp:41
Drv::BlockDriverComponentBase::m_Tlm_OutputPort
Fw::OutputTlmPort m_Tlm_OutputPort[NUM_TLM_OUTPUT_PORTS]
Definition: BlockDriverComponentAc.hpp:540
Drv::BlockDriverComponentBase::m_PingIn_InputPort
Svc::InputPingPort m_PingIn_InputPort[NUM_PINGIN_INPUT_PORTS]
Definition: BlockDriverComponentAc.hpp:518
Svc::InputPingPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
call to register a component
Definition: PingPortAc.cpp:42
Drv::BlockDriverComponentBase::BufferOut_out
void BufferOut_out(NATIVE_INT_TYPE portNum, Drv::DataBuffer &buff)
Definition: BlockDriverComponentAc.cpp:479