F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
LinuxGpioDriverComponentAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title LinuxGpioDriverComponentAc.cpp
3 // \author Generated by fpp-to-cpp
4 // \brief cpp file for LinuxGpioDriver component base class
5 // ======================================================================
6 
7 #include "Drv/LinuxGpioDriver/LinuxGpioDriverComponentAc.hpp"
8 #include "Fw/Types/Assert.hpp"
9 #include "Fw/Types/ExternalString.hpp"
10 #if FW_ENABLE_TEXT_LOGGING
11 #include "Fw/Types/String.hpp"
12 #endif
13 
14 namespace Drv {
15 
16  // ----------------------------------------------------------------------
17  // Component initialization
18  // ----------------------------------------------------------------------
19 
20  void LinuxGpioDriverComponentBase ::
21  init(FwEnumStoreType instance)
22  {
23  // Initialize base class
24  Fw::PassiveComponentBase::init(instance);
25 
26  // Connect input port gpioRead
27  for (
28  FwIndexType port = 0;
29  port < static_cast<FwIndexType>(this->getNum_gpioRead_InputPorts());
30  port++
31  ) {
32  this->m_gpioRead_InputPort[port].init();
33  this->m_gpioRead_InputPort[port].addCallComp(
34  this,
35  m_p_gpioRead_in
36  );
37  this->m_gpioRead_InputPort[port].setPortNum(port);
38 
39 #if FW_OBJECT_NAMES == 1
40  Fw::ObjectName portName;
41  portName.format(
42  "%s_gpioRead_InputPort[%" PRI_FwIndexType "]",
43  this->m_objName.toChar(),
44  port
45  );
46  this->m_gpioRead_InputPort[port].setObjName(portName.toChar());
47 #endif
48  }
49 
50  // Connect input port gpioWrite
51  for (
52  FwIndexType port = 0;
53  port < static_cast<FwIndexType>(this->getNum_gpioWrite_InputPorts());
54  port++
55  ) {
56  this->m_gpioWrite_InputPort[port].init();
57  this->m_gpioWrite_InputPort[port].addCallComp(
58  this,
59  m_p_gpioWrite_in
60  );
61  this->m_gpioWrite_InputPort[port].setPortNum(port);
62 
63 #if FW_OBJECT_NAMES == 1
64  Fw::ObjectName portName;
65  portName.format(
66  "%s_gpioWrite_InputPort[%" PRI_FwIndexType "]",
67  this->m_objName.toChar(),
68  port
69  );
70  this->m_gpioWrite_InputPort[port].setObjName(portName.toChar());
71 #endif
72  }
73 
74  // Connect output port Log
75  for (
76  FwIndexType port = 0;
77  port < static_cast<FwIndexType>(this->getNum_Log_OutputPorts());
78  port++
79  ) {
80  this->m_Log_OutputPort[port].init();
81 
82 #if FW_OBJECT_NAMES == 1
83  Fw::ObjectName portName;
84  portName.format(
85  "%s_Log_OutputPort[%" PRI_FwIndexType "]",
86  this->m_objName.toChar(),
87  port
88  );
89  this->m_Log_OutputPort[port].setObjName(portName.toChar());
90 #endif
91  }
92 
93 #if FW_ENABLE_TEXT_LOGGING == 1
94  // Connect output port LogText
95  for (
96  FwIndexType port = 0;
97  port < static_cast<FwIndexType>(this->getNum_LogText_OutputPorts());
98  port++
99  ) {
100  this->m_LogText_OutputPort[port].init();
101 
102 #if FW_OBJECT_NAMES == 1
103  Fw::ObjectName portName;
104  portName.format(
105  "%s_LogText_OutputPort[%" PRI_FwIndexType "]",
106  this->m_objName.toChar(),
107  port
108  );
109  this->m_LogText_OutputPort[port].setObjName(portName.toChar());
110 #endif
111  }
112 #endif
113 
114  // Connect output port Time
115  for (
116  FwIndexType port = 0;
117  port < static_cast<FwIndexType>(this->getNum_Time_OutputPorts());
118  port++
119  ) {
120  this->m_Time_OutputPort[port].init();
121 
122 #if FW_OBJECT_NAMES == 1
123  Fw::ObjectName portName;
124  portName.format(
125  "%s_Time_OutputPort[%" PRI_FwIndexType "]",
126  this->m_objName.toChar(),
127  port
128  );
129  this->m_Time_OutputPort[port].setObjName(portName.toChar());
130 #endif
131  }
132 
133  // Connect output port gpioInterrupt
134  for (
135  FwIndexType port = 0;
136  port < static_cast<FwIndexType>(this->getNum_gpioInterrupt_OutputPorts());
137  port++
138  ) {
139  this->m_gpioInterrupt_OutputPort[port].init();
140 
141 #if FW_OBJECT_NAMES == 1
142  Fw::ObjectName portName;
143  portName.format(
144  "%s_gpioInterrupt_OutputPort[%" PRI_FwIndexType "]",
145  this->m_objName.toChar(),
146  port
147  );
148  this->m_gpioInterrupt_OutputPort[port].setObjName(portName.toChar());
149 #endif
150  }
151  }
152 
153  // ----------------------------------------------------------------------
154  // Getters for typed input ports
155  // ----------------------------------------------------------------------
156 
157  Drv::InputGpioReadPort* LinuxGpioDriverComponentBase ::
158  get_gpioRead_InputPort(FwIndexType portNum)
159  {
160  FW_ASSERT(
161  (0 <= portNum) && (portNum < this->getNum_gpioRead_InputPorts()),
162  static_cast<FwAssertArgType>(portNum)
163  );
164 
165  return &this->m_gpioRead_InputPort[portNum];
166  }
167 
168  Drv::InputGpioWritePort* LinuxGpioDriverComponentBase ::
169  get_gpioWrite_InputPort(FwIndexType portNum)
170  {
171  FW_ASSERT(
172  (0 <= portNum) && (portNum < this->getNum_gpioWrite_InputPorts()),
173  static_cast<FwAssertArgType>(portNum)
174  );
175 
176  return &this->m_gpioWrite_InputPort[portNum];
177  }
178 
179  // ----------------------------------------------------------------------
180  // Connect input ports to special output ports
181  // ----------------------------------------------------------------------
182 
183  void LinuxGpioDriverComponentBase ::
184  set_Log_OutputPort(
185  FwIndexType portNum,
186  Fw::InputLogPort* port
187  )
188  {
189  FW_ASSERT(
190  (0 <= portNum) && (portNum < this->getNum_Log_OutputPorts()),
191  static_cast<FwAssertArgType>(portNum)
192  );
193 
194  this->m_Log_OutputPort[portNum].addCallPort(port);
195  }
196 
197 #if FW_ENABLE_TEXT_LOGGING == 1
198 
199  void LinuxGpioDriverComponentBase ::
200  set_LogText_OutputPort(
201  FwIndexType portNum,
202  Fw::InputLogTextPort* port
203  )
204  {
205  FW_ASSERT(
206  (0 <= portNum) && (portNum < this->getNum_LogText_OutputPorts()),
207  static_cast<FwAssertArgType>(portNum)
208  );
209 
210  this->m_LogText_OutputPort[portNum].addCallPort(port);
211  }
212 
213 #endif
214 
215  void LinuxGpioDriverComponentBase ::
216  set_Time_OutputPort(
217  FwIndexType portNum,
218  Fw::InputTimePort* port
219  )
220  {
221  FW_ASSERT(
222  (0 <= portNum) && (portNum < this->getNum_Time_OutputPorts()),
223  static_cast<FwAssertArgType>(portNum)
224  );
225 
226  this->m_Time_OutputPort[portNum].addCallPort(port);
227  }
228 
229  // ----------------------------------------------------------------------
230  // Connect typed input ports to typed output ports
231  // ----------------------------------------------------------------------
232 
233  void LinuxGpioDriverComponentBase ::
234  set_gpioInterrupt_OutputPort(
235  FwIndexType portNum,
236  Svc::InputCyclePort* port
237  )
238  {
239  FW_ASSERT(
240  (0 <= portNum) && (portNum < this->getNum_gpioInterrupt_OutputPorts()),
241  static_cast<FwAssertArgType>(portNum)
242  );
243 
244  this->m_gpioInterrupt_OutputPort[portNum].addCallPort(port);
245  }
246 
247 #if FW_PORT_SERIALIZATION
248 
249  // ----------------------------------------------------------------------
250  // Connect serial input ports to special output ports
251  // ----------------------------------------------------------------------
252 
253  void LinuxGpioDriverComponentBase ::
254  set_Log_OutputPort(
255  FwIndexType portNum,
256  Fw::InputSerializePort* port
257  )
258  {
259  FW_ASSERT(
260  (0 <= portNum) && (portNum < this->getNum_Log_OutputPorts()),
261  static_cast<FwAssertArgType>(portNum)
262  );
263 
264  this->m_Log_OutputPort[portNum].registerSerialPort(port);
265  }
266 
267 #if FW_ENABLE_TEXT_LOGGING == 1
268 
269  void LinuxGpioDriverComponentBase ::
270  set_LogText_OutputPort(
271  FwIndexType portNum,
272  Fw::InputSerializePort* port
273  )
274  {
275  FW_ASSERT(
276  (0 <= portNum) && (portNum < this->getNum_LogText_OutputPorts()),
277  static_cast<FwAssertArgType>(portNum)
278  );
279 
280  this->m_LogText_OutputPort[portNum].registerSerialPort(port);
281  }
282 
283 #endif
284 
285  void LinuxGpioDriverComponentBase ::
286  set_Time_OutputPort(
287  FwIndexType portNum,
288  Fw::InputSerializePort* port
289  )
290  {
291  FW_ASSERT(
292  (0 <= portNum) && (portNum < this->getNum_Time_OutputPorts()),
293  static_cast<FwAssertArgType>(portNum)
294  );
295 
296  this->m_Time_OutputPort[portNum].registerSerialPort(port);
297  }
298 
299 #endif
300 
301 #if FW_PORT_SERIALIZATION
302 
303  // ----------------------------------------------------------------------
304  // Connect serial input ports to typed output ports
305  // ----------------------------------------------------------------------
306 
307  void LinuxGpioDriverComponentBase ::
308  set_gpioInterrupt_OutputPort(
309  FwIndexType portNum,
310  Fw::InputSerializePort* port
311  )
312  {
313  FW_ASSERT(
314  (0 <= portNum) && (portNum < this->getNum_gpioInterrupt_OutputPorts()),
315  static_cast<FwAssertArgType>(portNum)
316  );
317 
318  this->m_gpioInterrupt_OutputPort[portNum].registerSerialPort(port);
319  }
320 
321 #endif
322 
323  // ----------------------------------------------------------------------
324  // Component construction and destruction
325  // ----------------------------------------------------------------------
326 
327  LinuxGpioDriverComponentBase ::
328  LinuxGpioDriverComponentBase(const char* compName) :
329  Fw::PassiveComponentBase(compName)
330  {
331 
332  }
333 
334  LinuxGpioDriverComponentBase ::
335  ~LinuxGpioDriverComponentBase()
336  {
337 
338  }
339 
340  // ----------------------------------------------------------------------
341  // Connection status queries for special output ports
342  // ----------------------------------------------------------------------
343 
344  bool LinuxGpioDriverComponentBase ::
345  isConnected_Log_OutputPort(FwIndexType portNum)
346  {
347  FW_ASSERT(
348  (0 <= portNum) && (portNum < this->getNum_Log_OutputPorts()),
349  static_cast<FwAssertArgType>(portNum)
350  );
351 
352  return this->m_Log_OutputPort[portNum].isConnected();
353  }
354 
355 #if FW_ENABLE_TEXT_LOGGING == 1
356 
357  bool LinuxGpioDriverComponentBase ::
358  isConnected_LogText_OutputPort(FwIndexType portNum)
359  {
360  FW_ASSERT(
361  (0 <= portNum) && (portNum < this->getNum_LogText_OutputPorts()),
362  static_cast<FwAssertArgType>(portNum)
363  );
364 
365  return this->m_LogText_OutputPort[portNum].isConnected();
366  }
367 
368 #endif
369 
370  bool LinuxGpioDriverComponentBase ::
371  isConnected_Time_OutputPort(FwIndexType portNum)
372  {
373  FW_ASSERT(
374  (0 <= portNum) && (portNum < this->getNum_Time_OutputPorts()),
375  static_cast<FwAssertArgType>(portNum)
376  );
377 
378  return this->m_Time_OutputPort[portNum].isConnected();
379  }
380 
381  // ----------------------------------------------------------------------
382  // Connection status queries for typed output ports
383  // ----------------------------------------------------------------------
384 
385  bool LinuxGpioDriverComponentBase ::
386  isConnected_gpioInterrupt_OutputPort(FwIndexType portNum)
387  {
388  FW_ASSERT(
389  (0 <= portNum) && (portNum < this->getNum_gpioInterrupt_OutputPorts()),
390  static_cast<FwAssertArgType>(portNum)
391  );
392 
393  return this->m_gpioInterrupt_OutputPort[portNum].isConnected();
394  }
395 
396  // ----------------------------------------------------------------------
397  // Port handler base-class functions for typed input ports
398  //
399  // Call these functions directly to bypass the corresponding ports
400  // ----------------------------------------------------------------------
401 
402  Drv::GpioStatus LinuxGpioDriverComponentBase ::
403  gpioRead_handlerBase(
404  FwIndexType portNum,
405  Fw::Logic& state
406  )
407  {
408  // Make sure port number is valid
409  FW_ASSERT(
410  (0 <= portNum) && (portNum < this->getNum_gpioRead_InputPorts()),
411  static_cast<FwAssertArgType>(portNum)
412  );
413 
414  Drv::GpioStatus retVal;
415 
416  // Call handler function
417  retVal = this->gpioRead_handler(
418  portNum,
419  state
420  );
421 
422  return retVal;
423  }
424 
425  Drv::GpioStatus LinuxGpioDriverComponentBase ::
426  gpioWrite_handlerBase(
427  FwIndexType portNum,
428  const Fw::Logic& state
429  )
430  {
431  // Make sure port number is valid
432  FW_ASSERT(
433  (0 <= portNum) && (portNum < this->getNum_gpioWrite_InputPorts()),
434  static_cast<FwAssertArgType>(portNum)
435  );
436 
437  Drv::GpioStatus retVal;
438 
439  // Call handler function
440  retVal = this->gpioWrite_handler(
441  portNum,
442  state
443  );
444 
445  return retVal;
446  }
447 
448  // ----------------------------------------------------------------------
449  // Invocation functions for typed output ports
450  // ----------------------------------------------------------------------
451 
452  void LinuxGpioDriverComponentBase ::
453  gpioInterrupt_out(
454  FwIndexType portNum,
455  Os::RawTime& cycleStart
456  )
457  {
458  FW_ASSERT(
459  (0 <= portNum) && (portNum < this->getNum_gpioInterrupt_OutputPorts()),
460  static_cast<FwAssertArgType>(portNum)
461  );
462 
463  FW_ASSERT(
464  this->m_gpioInterrupt_OutputPort[portNum].isConnected(),
465  static_cast<FwAssertArgType>(portNum)
466  );
467  this->m_gpioInterrupt_OutputPort[portNum].invoke(
468  cycleStart
469  );
470  }
471 
472  // ----------------------------------------------------------------------
473  // Event logging functions
474  // ----------------------------------------------------------------------
475 
476  void LinuxGpioDriverComponentBase ::
477  log_DIAGNOSTIC_OpenChip(
478  const Fw::StringBase& chip,
479  const Fw::StringBase& chipLabel,
480  U32 pin,
481  const Fw::StringBase& pinMessage
482  ) const
483  {
484  // Get the time
485  Fw::Time _logTime;
486  if (this->m_Time_OutputPort[0].isConnected()) {
487  this->m_Time_OutputPort[0].invoke(_logTime);
488  }
489 
490  FwEventIdType _id = static_cast<FwEventIdType>(0);
491 
492  _id = this->getIdBase() + EVENTID_OPENCHIP;
493 
494  // Emit the event on the log port
495  if (this->m_Log_OutputPort[0].isConnected()) {
496  Fw::LogBuffer _logBuff;
497  Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
498 
499 #if FW_AMPCS_COMPATIBLE
500  // Serialize the number of arguments
501  _status = _logBuff.serializeFrom(static_cast<U8>(4));
502  FW_ASSERT(
503  _status == Fw::FW_SERIALIZE_OK,
504  static_cast<FwAssertArgType>(_status)
505  );
506 #endif
507 
508  _status = chip.serializeTo(_logBuff, FW_MIN(FW_LOG_STRING_MAX_SIZE, 80));
509  FW_ASSERT(
510  _status == Fw::FW_SERIALIZE_OK,
511  static_cast<FwAssertArgType>(_status)
512  );
513 
514  _status = chipLabel.serializeTo(_logBuff, FW_MIN(FW_LOG_STRING_MAX_SIZE, 80));
515  FW_ASSERT(
516  _status == Fw::FW_SERIALIZE_OK,
517  static_cast<FwAssertArgType>(_status)
518  );
519 
520 #if FW_AMPCS_COMPATIBLE
521  // Serialize the argument size
522  _status = _logBuff.serializeFrom(
523  static_cast<U8>(sizeof(U32))
524  );
525  FW_ASSERT(
526  _status == Fw::FW_SERIALIZE_OK,
527  static_cast<FwAssertArgType>(_status)
528  );
529 #endif
530  _status = _logBuff.serializeFrom(pin);
531  FW_ASSERT(
532  _status == Fw::FW_SERIALIZE_OK,
533  static_cast<FwAssertArgType>(_status)
534  );
535 
536  _status = pinMessage.serializeTo(_logBuff, FW_MIN(FW_LOG_STRING_MAX_SIZE, 80));
537  FW_ASSERT(
538  _status == Fw::FW_SERIALIZE_OK,
539  static_cast<FwAssertArgType>(_status)
540  );
541 
542  this->m_Log_OutputPort[0].invoke(
543  _id,
544  _logTime,
545  Fw::LogSeverity::DIAGNOSTIC,
546  _logBuff
547  );
548  }
549 
550  // Emit the event on the text log port
551 #if FW_ENABLE_TEXT_LOGGING
552  if (this->m_LogText_OutputPort[0].isConnected()) {
553 #if FW_OBJECT_NAMES == 1
554  const char* _formatString =
555  "(%s) %s: Opened GPIO chip %s[%s] pin %" PRIu32 "[%s]";
556 #else
557  const char* _formatString =
558  "%s: Opened GPIO chip %s[%s] pin %" PRIu32 "[%s]";
559 #endif
560 
561  Fw::TextLogString _logString;
562  _logString.format(
563  _formatString,
564 #if FW_OBJECT_NAMES == 1
565  this->m_objName.toChar(),
566 #endif
567  "OpenChip ",
568  chip.toChar(),
569  chipLabel.toChar(),
570  pin,
571  pinMessage.toChar()
572  );
573 
574  this->m_LogText_OutputPort[0].invoke(
575  _id,
576  _logTime,
577  Fw::LogSeverity::DIAGNOSTIC,
578  _logString
579  );
580  }
581 #endif
582  }
583 
584  void LinuxGpioDriverComponentBase ::
585  log_WARNING_HI_OpenChipError(
586  const Fw::StringBase& chip,
587  Os::FileStatus status
588  ) const
589  {
590  // Get the time
591  Fw::Time _logTime;
592  if (this->m_Time_OutputPort[0].isConnected()) {
593  this->m_Time_OutputPort[0].invoke(_logTime);
594  }
595 
596  FwEventIdType _id = static_cast<FwEventIdType>(0);
597 
598  _id = this->getIdBase() + EVENTID_OPENCHIPERROR;
599 
600  // Emit the event on the log port
601  if (this->m_Log_OutputPort[0].isConnected()) {
602  Fw::LogBuffer _logBuff;
603  Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
604 
605 #if FW_AMPCS_COMPATIBLE
606  // Serialize the number of arguments
607  _status = _logBuff.serializeFrom(static_cast<U8>(2));
608  FW_ASSERT(
609  _status == Fw::FW_SERIALIZE_OK,
610  static_cast<FwAssertArgType>(_status)
611  );
612 #endif
613 
614  _status = chip.serializeTo(_logBuff, FW_MIN(FW_LOG_STRING_MAX_SIZE, 80));
615  FW_ASSERT(
616  _status == Fw::FW_SERIALIZE_OK,
617  static_cast<FwAssertArgType>(_status)
618  );
619 
620 #if FW_AMPCS_COMPATIBLE
621  // Serialize the argument size
622  _status = _logBuff.serializeFrom(
623  static_cast<U8>(Os::FileStatus::SERIALIZED_SIZE)
624  );
625  FW_ASSERT(
626  _status == Fw::FW_SERIALIZE_OK,
627  static_cast<FwAssertArgType>(_status)
628  );
629 #endif
630  _status = _logBuff.serializeFrom(status);
631  FW_ASSERT(
632  _status == Fw::FW_SERIALIZE_OK,
633  static_cast<FwAssertArgType>(_status)
634  );
635 
636  this->m_Log_OutputPort[0].invoke(
637  _id,
638  _logTime,
639  Fw::LogSeverity::WARNING_HI,
640  _logBuff
641  );
642  }
643 
644  // Emit the event on the text log port
645 #if FW_ENABLE_TEXT_LOGGING
646  if (this->m_LogText_OutputPort[0].isConnected()) {
647 #if FW_OBJECT_NAMES == 1
648  const char* _formatString =
649  "(%s) %s: Failed to open GPIO chip %s: %s";
650 #else
651  const char* _formatString =
652  "%s: Failed to open GPIO chip %s: %s";
653 #endif
654 
655  Fw::String statusStr;
656  status.toString(statusStr);
657 
658  Fw::TextLogString _logString;
659  _logString.format(
660  _formatString,
661 #if FW_OBJECT_NAMES == 1
662  this->m_objName.toChar(),
663 #endif
664  "OpenChipError ",
665  chip.toChar(),
666  statusStr.toChar()
667  );
668 
669  this->m_LogText_OutputPort[0].invoke(
670  _id,
671  _logTime,
672  Fw::LogSeverity::WARNING_HI,
673  _logString
674  );
675  }
676 #endif
677  }
678 
679  void LinuxGpioDriverComponentBase ::
680  log_WARNING_HI_OpenPinError(
681  const Fw::StringBase& chip,
682  U32 pin,
683  const Fw::StringBase& pinMessage,
684  Os::FileStatus status
685  ) const
686  {
687  // Get the time
688  Fw::Time _logTime;
689  if (this->m_Time_OutputPort[0].isConnected()) {
690  this->m_Time_OutputPort[0].invoke(_logTime);
691  }
692 
693  FwEventIdType _id = static_cast<FwEventIdType>(0);
694 
695  _id = this->getIdBase() + EVENTID_OPENPINERROR;
696 
697  // Emit the event on the log port
698  if (this->m_Log_OutputPort[0].isConnected()) {
699  Fw::LogBuffer _logBuff;
700  Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
701 
702 #if FW_AMPCS_COMPATIBLE
703  // Serialize the number of arguments
704  _status = _logBuff.serializeFrom(static_cast<U8>(4));
705  FW_ASSERT(
706  _status == Fw::FW_SERIALIZE_OK,
707  static_cast<FwAssertArgType>(_status)
708  );
709 #endif
710 
711  _status = chip.serializeTo(_logBuff, FW_MIN(FW_LOG_STRING_MAX_SIZE, 80));
712  FW_ASSERT(
713  _status == Fw::FW_SERIALIZE_OK,
714  static_cast<FwAssertArgType>(_status)
715  );
716 
717 #if FW_AMPCS_COMPATIBLE
718  // Serialize the argument size
719  _status = _logBuff.serializeFrom(
720  static_cast<U8>(sizeof(U32))
721  );
722  FW_ASSERT(
723  _status == Fw::FW_SERIALIZE_OK,
724  static_cast<FwAssertArgType>(_status)
725  );
726 #endif
727  _status = _logBuff.serializeFrom(pin);
728  FW_ASSERT(
729  _status == Fw::FW_SERIALIZE_OK,
730  static_cast<FwAssertArgType>(_status)
731  );
732 
733  _status = pinMessage.serializeTo(_logBuff, FW_MIN(FW_LOG_STRING_MAX_SIZE, 80));
734  FW_ASSERT(
735  _status == Fw::FW_SERIALIZE_OK,
736  static_cast<FwAssertArgType>(_status)
737  );
738 
739 #if FW_AMPCS_COMPATIBLE
740  // Serialize the argument size
741  _status = _logBuff.serializeFrom(
742  static_cast<U8>(Os::FileStatus::SERIALIZED_SIZE)
743  );
744  FW_ASSERT(
745  _status == Fw::FW_SERIALIZE_OK,
746  static_cast<FwAssertArgType>(_status)
747  );
748 #endif
749  _status = _logBuff.serializeFrom(status);
750  FW_ASSERT(
751  _status == Fw::FW_SERIALIZE_OK,
752  static_cast<FwAssertArgType>(_status)
753  );
754 
755  this->m_Log_OutputPort[0].invoke(
756  _id,
757  _logTime,
758  Fw::LogSeverity::WARNING_HI,
759  _logBuff
760  );
761  }
762 
763  // Emit the event on the text log port
764 #if FW_ENABLE_TEXT_LOGGING
765  if (this->m_LogText_OutputPort[0].isConnected()) {
766 #if FW_OBJECT_NAMES == 1
767  const char* _formatString =
768  "(%s) %s: Failed to open GPIO chip %s pin %" PRIu32 " [%s]: %s";
769 #else
770  const char* _formatString =
771  "%s: Failed to open GPIO chip %s pin %" PRIu32 " [%s]: %s";
772 #endif
773 
774  Fw::String statusStr;
775  status.toString(statusStr);
776 
777  Fw::TextLogString _logString;
778  _logString.format(
779  _formatString,
780 #if FW_OBJECT_NAMES == 1
781  this->m_objName.toChar(),
782 #endif
783  "OpenPinError ",
784  chip.toChar(),
785  pin,
786  pinMessage.toChar(),
787  statusStr.toChar()
788  );
789 
790  this->m_LogText_OutputPort[0].invoke(
791  _id,
792  _logTime,
793  Fw::LogSeverity::WARNING_HI,
794  _logString
795  );
796  }
797 #endif
798  }
799 
800  void LinuxGpioDriverComponentBase ::
801  log_WARNING_HI_InterruptReadError(
802  U32 expected,
803  U32 got
804  ) const
805  {
806  // Get the time
807  Fw::Time _logTime;
808  if (this->m_Time_OutputPort[0].isConnected()) {
809  this->m_Time_OutputPort[0].invoke(_logTime);
810  }
811 
812  FwEventIdType _id = static_cast<FwEventIdType>(0);
813 
814  _id = this->getIdBase() + EVENTID_INTERRUPTREADERROR;
815 
816  // Emit the event on the log port
817  if (this->m_Log_OutputPort[0].isConnected()) {
818  Fw::LogBuffer _logBuff;
819  Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
820 
821 #if FW_AMPCS_COMPATIBLE
822  // Serialize the number of arguments
823  _status = _logBuff.serializeFrom(static_cast<U8>(2));
824  FW_ASSERT(
825  _status == Fw::FW_SERIALIZE_OK,
826  static_cast<FwAssertArgType>(_status)
827  );
828 #endif
829 
830 #if FW_AMPCS_COMPATIBLE
831  // Serialize the argument size
832  _status = _logBuff.serializeFrom(
833  static_cast<U8>(sizeof(U32))
834  );
835  FW_ASSERT(
836  _status == Fw::FW_SERIALIZE_OK,
837  static_cast<FwAssertArgType>(_status)
838  );
839 #endif
840  _status = _logBuff.serializeFrom(expected);
841  FW_ASSERT(
842  _status == Fw::FW_SERIALIZE_OK,
843  static_cast<FwAssertArgType>(_status)
844  );
845 
846 #if FW_AMPCS_COMPATIBLE
847  // Serialize the argument size
848  _status = _logBuff.serializeFrom(
849  static_cast<U8>(sizeof(U32))
850  );
851  FW_ASSERT(
852  _status == Fw::FW_SERIALIZE_OK,
853  static_cast<FwAssertArgType>(_status)
854  );
855 #endif
856  _status = _logBuff.serializeFrom(got);
857  FW_ASSERT(
858  _status == Fw::FW_SERIALIZE_OK,
859  static_cast<FwAssertArgType>(_status)
860  );
861 
862  this->m_Log_OutputPort[0].invoke(
863  _id,
864  _logTime,
865  Fw::LogSeverity::WARNING_HI,
866  _logBuff
867  );
868  }
869 
870  // Emit the event on the text log port
871 #if FW_ENABLE_TEXT_LOGGING
872  if (this->m_LogText_OutputPort[0].isConnected()) {
873 #if FW_OBJECT_NAMES == 1
874  const char* _formatString =
875  "(%s) %s: Interrupt data read expected %" PRIu32 " byes and got %" PRIu32 "";
876 #else
877  const char* _formatString =
878  "%s: Interrupt data read expected %" PRIu32 " byes and got %" PRIu32 "";
879 #endif
880 
881  Fw::TextLogString _logString;
882  _logString.format(
883  _formatString,
884 #if FW_OBJECT_NAMES == 1
885  this->m_objName.toChar(),
886 #endif
887  "InterruptReadError ",
888  expected,
889  got
890  );
891 
892  this->m_LogText_OutputPort[0].invoke(
893  _id,
894  _logTime,
895  Fw::LogSeverity::WARNING_HI,
896  _logString
897  );
898  }
899 #endif
900  }
901 
902  void LinuxGpioDriverComponentBase ::
903  log_WARNING_HI_PollingError(I32 error_number) const
904  {
905  // Get the time
906  Fw::Time _logTime;
907  if (this->m_Time_OutputPort[0].isConnected()) {
908  this->m_Time_OutputPort[0].invoke(_logTime);
909  }
910 
911  FwEventIdType _id = static_cast<FwEventIdType>(0);
912 
913  _id = this->getIdBase() + EVENTID_POLLINGERROR;
914 
915  // Emit the event on the log port
916  if (this->m_Log_OutputPort[0].isConnected()) {
917  Fw::LogBuffer _logBuff;
918  Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
919 
920 #if FW_AMPCS_COMPATIBLE
921  // Serialize the number of arguments
922  _status = _logBuff.serializeFrom(static_cast<U8>(1));
923  FW_ASSERT(
924  _status == Fw::FW_SERIALIZE_OK,
925  static_cast<FwAssertArgType>(_status)
926  );
927 #endif
928 
929 #if FW_AMPCS_COMPATIBLE
930  // Serialize the argument size
931  _status = _logBuff.serializeFrom(
932  static_cast<U8>(sizeof(I32))
933  );
934  FW_ASSERT(
935  _status == Fw::FW_SERIALIZE_OK,
936  static_cast<FwAssertArgType>(_status)
937  );
938 #endif
939  _status = _logBuff.serializeFrom(error_number);
940  FW_ASSERT(
941  _status == Fw::FW_SERIALIZE_OK,
942  static_cast<FwAssertArgType>(_status)
943  );
944 
945  this->m_Log_OutputPort[0].invoke(
946  _id,
947  _logTime,
948  Fw::LogSeverity::WARNING_HI,
949  _logBuff
950  );
951  }
952 
953  // Emit the event on the text log port
954 #if FW_ENABLE_TEXT_LOGGING
955  if (this->m_LogText_OutputPort[0].isConnected()) {
956 #if FW_OBJECT_NAMES == 1
957  const char* _formatString =
958  "(%s) %s: Interrupt polling returned errno: %" PRIi32 "";
959 #else
960  const char* _formatString =
961  "%s: Interrupt polling returned errno: %" PRIi32 "";
962 #endif
963 
964  Fw::TextLogString _logString;
965  _logString.format(
966  _formatString,
967 #if FW_OBJECT_NAMES == 1
968  this->m_objName.toChar(),
969 #endif
970  "PollingError ",
971  error_number
972  );
973 
974  this->m_LogText_OutputPort[0].invoke(
975  _id,
976  _logTime,
977  Fw::LogSeverity::WARNING_HI,
978  _logString
979  );
980  }
981 #endif
982  }
983 
984  // ----------------------------------------------------------------------
985  // Time
986  // ----------------------------------------------------------------------
987 
988  Fw::Time LinuxGpioDriverComponentBase ::
989  getTime() const
990  {
991  if (this->m_Time_OutputPort[0].isConnected()) {
992  Fw::Time _time;
993  this->m_Time_OutputPort[0].invoke(_time);
994  return _time;
995  }
996  else {
997  return Fw::Time(TimeBase::TB_NONE, 0, 0);
998  }
999  }
1000 
1001  // ----------------------------------------------------------------------
1002  // Calls for messages received on typed input ports
1003  // ----------------------------------------------------------------------
1004 
1005  Drv::GpioStatus LinuxGpioDriverComponentBase ::
1006  m_p_gpioRead_in(
1007  Fw::PassiveComponentBase* callComp,
1008  FwIndexType portNum,
1009  Fw::Logic& state
1010  )
1011  {
1012  FW_ASSERT(callComp);
1013  LinuxGpioDriverComponentBase* compPtr = static_cast<LinuxGpioDriverComponentBase*>(callComp);
1014  return compPtr->gpioRead_handlerBase(
1015  portNum,
1016  state
1017  );
1018  }
1019 
1020  Drv::GpioStatus LinuxGpioDriverComponentBase ::
1021  m_p_gpioWrite_in(
1022  Fw::PassiveComponentBase* callComp,
1023  FwIndexType portNum,
1024  const Fw::Logic& state
1025  )
1026  {
1027  FW_ASSERT(callComp);
1028  LinuxGpioDriverComponentBase* compPtr = static_cast<LinuxGpioDriverComponentBase*>(callComp);
1029  return compPtr->gpioWrite_handlerBase(
1030  portNum,
1031  state
1032  );
1033  }
1034 
1035 }
Fw::FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Fw::OutputTimePort::addCallPort
void addCallPort(InputTimePort *callPort)
Register an input port.
Definition: TimePortAc.cpp:134
Drv::LinuxGpioDriverComponentBase::get_gpioRead_InputPort
Drv::InputGpioReadPort * get_gpioRead_InputPort(FwIndexType portNum)
Definition: LinuxGpioDriverComponentAc.cpp:158
Drv::LinuxGpioDriverComponentBase::isConnected_gpioInterrupt_OutputPort
bool isConnected_gpioInterrupt_OutputPort(FwIndexType portNum)
Definition: LinuxGpioDriverComponentAc.cpp:386
Drv::LinuxGpioDriverComponentBase::getNum_Time_OutputPorts
static constexpr FwIndexType getNum_Time_OutputPorts()
Definition: LinuxGpioDriverComponentAc.hpp:257
Drv::LinuxGpioDriverComponentBase::get_gpioWrite_InputPort
Drv::InputGpioWritePort * get_gpioWrite_InputPort(FwIndexType portNum)
Definition: LinuxGpioDriverComponentAc.cpp:169
Drv::LinuxGpioDriverComponentBase::getNum_gpioRead_InputPorts
static constexpr FwIndexType getNum_gpioRead_InputPorts()
Definition: LinuxGpioDriverComponentAc.hpp:219
Fw::TextLogString
Definition: TextLogString.hpp:17
String.hpp
FwEnumStoreType
I32 FwEnumStoreType
Definition: FwEnumStoreTypeAliasAc.h:14
Drv::InputGpioWritePort::init
void init()
Initialization function.
Definition: GpioWritePortAc.cpp:26
FW_LOG_STRING_MAX_SIZE
#define FW_LOG_STRING_MAX_SIZE
Max size of log string parameter type.
Definition: FpConfig.h:206
Drv::LinuxGpioDriverComponentBase::log_WARNING_HI_InterruptReadError
void log_WARNING_HI_InterruptReadError(U32 expected, U32 got) const
Log event InterruptReadError.
Definition: LinuxGpioDriverComponentAc.cpp:801
ExternalString.hpp
Fw::String::toChar
const char * toChar() const
Definition: String.hpp:50
Drv::LinuxGpioDriverComponentBase::LinuxGpioDriverComponentBase
LinuxGpioDriverComponentBase(const char *compName="")
Construct LinuxGpioDriverComponentBase object.
Definition: LinuxGpioDriverComponentAc.cpp:328
Drv::InputGpioWritePort
Input GpioWrite port.
Definition: GpioWritePortAc.hpp:24
Drv::LinuxGpioDriverComponentBase::set_gpioInterrupt_OutputPort
void set_gpioInterrupt_OutputPort(FwIndexType portNum, Svc::InputCyclePort *port)
Connect port to gpioInterrupt[portNum].
Definition: LinuxGpioDriverComponentAc.cpp:234
Drv::LinuxGpioDriverComponentBase::gpioWrite_handlerBase
Drv::GpioStatus gpioWrite_handlerBase(FwIndexType portNum, const Fw::Logic &state)
Handler base-class function for input port gpioWrite.
Definition: LinuxGpioDriverComponentAc.cpp:426
Drv::LinuxGpioDriverComponentBase::getNum_gpioInterrupt_OutputPorts
static constexpr FwIndexType getNum_gpioInterrupt_OutputPorts()
Definition: LinuxGpioDriverComponentAc.hpp:270
Drv::LinuxGpioDriverComponentBase::gpioWrite_handler
virtual Drv::GpioStatus gpioWrite_handler(FwIndexType portNum, const Fw::Logic &state)=0
Handler for input port gpioWrite.
Drv::LinuxGpioDriverComponentBase::log_WARNING_HI_OpenPinError
void log_WARNING_HI_OpenPinError(const Fw::StringBase &chip, U32 pin, const Fw::StringBase &pinMessage, Os::FileStatus status) const
Log event OpenPinError.
Definition: LinuxGpioDriverComponentAc.cpp:680
TimeBase::TB_NONE
No time base has been established (Required)
Definition: TimeBaseEnumAc.hpp:31
Drv::LinuxGpioDriverComponentBase::gpioRead_handler
virtual Drv::GpioStatus gpioRead_handler(FwIndexType portNum, Fw::Logic &state)=0
Handler for input port gpioRead.
Fw::LogSeverity::DIAGNOSTIC
Software diagnostic events.
Definition: LogSeverityEnumAc.hpp:45
Fw::ObjBase::init
void init()
Object initializer.
Definition: ObjBase.cpp:24
Drv::LinuxGpioDriverComponentBase::set_Time_OutputPort
void set_Time_OutputPort(FwIndexType portNum, Fw::InputTimePort *port)
Connect port to Time[portNum].
Definition: LinuxGpioDriverComponentAc.cpp:216
Drv::LinuxGpioDriverComponentBase::gpioRead_handlerBase
Drv::GpioStatus gpioRead_handlerBase(FwIndexType portNum, Fw::Logic &state)
Handler base-class function for input port gpioRead.
Definition: LinuxGpioDriverComponentAc.cpp:403
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Svc::OutputCyclePort::addCallPort
void addCallPort(InputCyclePort *callPort)
Register an input port.
Definition: CyclePortAc.cpp:134
Drv::LinuxGpioDriverComponentBase::getNum_gpioWrite_InputPorts
static constexpr FwIndexType getNum_gpioWrite_InputPorts()
Definition: LinuxGpioDriverComponentAc.hpp:226
FwEventIdType
FwIdType FwEventIdType
The type of an event identifier.
Definition: FwEventIdTypeAliasAc.h:14
Drv::LinuxGpioDriverComponentBase::isConnected_Log_OutputPort
bool isConnected_Log_OutputPort(FwIndexType portNum)
Definition: LinuxGpioDriverComponentAc.cpp:345
FW_OBJECT_NAMES
#define FW_OBJECT_NAMES
Indicates whether or not object names are stored (more memory, can be used for tracking objects) ...
Definition: FpConfig.h:40
Drv::LinuxGpioDriverComponentBase
Auto-generated base for LinuxGpioDriver component.
Definition: LinuxGpioDriverComponentAc.hpp:31
Fw::OutputTimePort::init
void init()
Initialization function.
Definition: TimePortAc.cpp:128
Drv::LinuxGpioDriverComponentBase::getNum_Log_OutputPorts
static constexpr FwIndexType getNum_Log_OutputPorts()
Definition: LinuxGpioDriverComponentAc.hpp:239
FW_MIN
#define FW_MIN(a, b)
MIN macro.
Definition: BasicTypes.h:92
Drv::LinuxGpioDriverComponentBase::isConnected_Time_OutputPort
bool isConnected_Time_OutputPort(FwIndexType portNum)
Definition: LinuxGpioDriverComponentAc.cpp:371
Drv::LinuxGpioDriverComponentBase::log_WARNING_HI_OpenChipError
void log_WARNING_HI_OpenChipError(const Fw::StringBase &chip, Os::FileStatus status) const
Log event OpenChipError.
Definition: LinuxGpioDriverComponentAc.cpp:585
Fw::OutputTimePort::invoke
void invoke(Fw::Time &time) const
Invoke a port interface.
Definition: TimePortAc.cpp:147
Assert.hpp
Fw::ObjectName::toChar
const char * toChar() const
Definition: ObjectName.hpp:50
Drv::InputGpioReadPort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
Register a component.
Definition: GpioReadPortAc.cpp:32
Drv::InputGpioReadPort::init
void init()
Initialization function.
Definition: GpioReadPortAc.cpp:26
Drv::LinuxGpioDriverComponentBase::log_DIAGNOSTIC_OpenChip
void log_DIAGNOSTIC_OpenChip(const Fw::StringBase &chip, const Fw::StringBase &chipLabel, U32 pin, const Fw::StringBase &pinMessage) const
Log event OpenChip.
Definition: LinuxGpioDriverComponentAc.cpp:477
Drv::LinuxGpioDriverComponentBase::gpioInterrupt_out
void gpioInterrupt_out(FwIndexType portNum, Os::RawTime &cycleStart)
Invoke output port gpioInterrupt.
Definition: LinuxGpioDriverComponentAc.cpp:453
Drv::InputGpioWritePort::addCallComp
void addCallComp(Fw::PassiveComponentBase *callComp, CompFuncPtr funcPtr)
Register a component.
Definition: GpioWritePortAc.cpp:32
Fw::LogSeverity::WARNING_HI
A serious but recoverable event.
Definition: LogSeverityEnumAc.hpp:35
Fw::PortBase::isConnected
bool isConnected() const
Definition: PortBase.cpp:38
Fw::SerializeBufferBase::serializeFrom
SerializeStatus serializeFrom(U8 val, Endianness mode=Endianness::BIG)
serialize 8-bit unsigned int
Definition: Serializable.cpp:64
PRI_FwIndexType
#define PRI_FwIndexType
Definition: FwIndexTypeAliasAc.h:16
Drv::InputGpioReadPort
Input GpioRead port.
Definition: GpioReadPortAc.hpp:24
Fw::StringBase::format
FormatStatus format(const CHAR *formatString,...)
write formatted string to buffer
Definition: StringBase.cpp:55
Fw::OutputLogPort::init
void init()
Initialization function.
Definition: LogPortAc.cpp:151
Fw::InputPortBase::setPortNum
void setPortNum(FwIndexType portNum)
Definition: InputPortBase.cpp:16
Svc::OutputCyclePort::init
void init()
Initialization function.
Definition: CyclePortAc.cpp:128
Drv::LinuxGpioDriverComponentBase::set_Log_OutputPort
void set_Log_OutputPort(FwIndexType portNum, Fw::InputLogPort *port)
Connect port to Log[portNum].
Definition: LinuxGpioDriverComponentAc.cpp:184
Fw::OutputLogPort::invoke
void invoke(FwEventIdType id, Fw::Time &timeTag, const Fw::LogSeverity &severity, Fw::LogBuffer &args) const
Invoke a port interface.
Definition: LogPortAc.cpp:170
Os::FileStatus::SERIALIZED_SIZE
The size of the serial representation.
Definition: FileStatusEnumAc.hpp:69
FwIndexType
PlatformIndexType FwIndexType
Definition: FwIndexTypeAliasAc.h:15
Drv::LinuxGpioDriverComponentBase::log_WARNING_HI_PollingError
void log_WARNING_HI_PollingError(I32 error_number) const
Log event PollingError.
Definition: LinuxGpioDriverComponentAc.cpp:903
Fw::OutputLogPort::addCallPort
void addCallPort(InputLogPort *callPort)
Register an input port.
Definition: LogPortAc.cpp:157
Fw::StringBase::serializeTo
SerializeStatus serializeTo(SerializeBufferBase &buffer, Endianness mode=Endianness::BIG) const override
serialize contents to buffer
Definition: StringBase.cpp:142
Fw::Logic
Logic states.
Definition: LogicEnumAc.hpp:17
Svc::OutputCyclePort::invoke
void invoke(Os::RawTime &cycleStart) const
Invoke a port interface.
Definition: CyclePortAc.cpp:147
Fw
Implementation of malloc based allocator.
Definition: FppConstantsAc.hpp:121
Fw::InputLogTextPort
Definition: LogTextPortAc.hpp:29
Drv::LinuxGpioDriverComponentBase::~LinuxGpioDriverComponentBase
virtual ~LinuxGpioDriverComponentBase()
Destroy LinuxGpioDriverComponentBase object.
Definition: LinuxGpioDriverComponentAc.cpp:335
Os::FileStatus
FPP shadow-enum representing Os::File::Status.
Definition: FileStatusEnumAc.hpp:17
FW_ASSERT
#define FW_ASSERT(...)
Definition: Assert.hpp:14
Fw::StringBase::toChar
virtual const CHAR * toChar() const =0
LinuxGpioDriverComponentAc.hpp