F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
ChannelTelemetrySerializableAc.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title ChannelTelemetrySerializableAc.cpp
3 // \author Generated by fpp-to-cpp
4 // \brief cpp file for ChannelTelemetry struct
5 // ======================================================================
6 
7 #include "Fw/Types/Assert.hpp"
8 #include "Svc/Ccsds/CfdpManager/Types/ChannelTelemetrySerializableAc.hpp"
9 
10 namespace Svc {
11 
12  namespace Ccsds {
13 
14  namespace Cfdp {
15 
16  // ----------------------------------------------------------------------
17  // Constructors
18  // ----------------------------------------------------------------------
19 
20  ChannelTelemetry ::
21  ChannelTelemetry() :
22  Serializable(),
23  m_recvErrors(),
24  m_recvDropped(),
25  m_recvSpurious(),
26  m_recvFileDataBytes(),
27  m_recvNakSegmentRequests(),
28  m_recvPdu(),
29  m_recvEofCanceled(),
30  m_sentNakSegmentRequests(),
31  m_sentFileDataBytes(),
32  m_sentPdu(),
33  m_sentEofCanceled(),
34  m_faultAckLimit(),
35  m_faultNakLimit(),
36  m_faultInactivityTimer(),
37  m_faultCrcMismatch(),
38  m_faultFileSizeMismatch(),
39  m_faultFileOpen(),
40  m_faultFileRead(),
41  m_faultFileWrite(),
42  m_faultFileSeek(),
43  m_faultFileRename(),
44  m_faultDirectoryRead(),
45  m_faultRxEofError(),
46  m_faultTxEofError(),
47  m_queueFree(),
48  m_queueTxActive(),
49  m_queueTxWaiting(),
50  m_queueRx(),
51  m_queueHistory(),
52  m_playbackCounter(),
53  m_pollCounter()
54  {
55 
56  }
57 
58  ChannelTelemetry ::
59  ChannelTelemetry(
60  U32 recvErrors,
61  U32 recvDropped,
62  U32 recvSpurious,
63  U64 recvFileDataBytes,
64  U32 recvNakSegmentRequests,
65  U32 recvPdu,
66  U32 recvEofCanceled,
67  U32 sentNakSegmentRequests,
68  U64 sentFileDataBytes,
69  U32 sentPdu,
70  U32 sentEofCanceled,
71  U32 faultAckLimit,
72  U32 faultNakLimit,
73  U32 faultInactivityTimer,
74  U32 faultCrcMismatch,
75  U32 faultFileSizeMismatch,
76  U32 faultFileOpen,
77  U32 faultFileRead,
78  U32 faultFileWrite,
79  U32 faultFileSeek,
80  U32 faultFileRename,
81  U32 faultDirectoryRead,
82  U32 faultRxEofError,
83  U32 faultTxEofError,
84  U16 queueFree,
85  U16 queueTxActive,
86  U16 queueTxWaiting,
87  U16 queueRx,
88  U16 queueHistory,
89  U8 playbackCounter,
90  U8 pollCounter
91  ) :
92  Serializable(),
93  m_recvErrors(recvErrors),
94  m_recvDropped(recvDropped),
95  m_recvSpurious(recvSpurious),
96  m_recvFileDataBytes(recvFileDataBytes),
97  m_recvNakSegmentRequests(recvNakSegmentRequests),
98  m_recvPdu(recvPdu),
99  m_recvEofCanceled(recvEofCanceled),
100  m_sentNakSegmentRequests(sentNakSegmentRequests),
101  m_sentFileDataBytes(sentFileDataBytes),
102  m_sentPdu(sentPdu),
103  m_sentEofCanceled(sentEofCanceled),
104  m_faultAckLimit(faultAckLimit),
105  m_faultNakLimit(faultNakLimit),
106  m_faultInactivityTimer(faultInactivityTimer),
107  m_faultCrcMismatch(faultCrcMismatch),
108  m_faultFileSizeMismatch(faultFileSizeMismatch),
109  m_faultFileOpen(faultFileOpen),
110  m_faultFileRead(faultFileRead),
111  m_faultFileWrite(faultFileWrite),
112  m_faultFileSeek(faultFileSeek),
113  m_faultFileRename(faultFileRename),
114  m_faultDirectoryRead(faultDirectoryRead),
115  m_faultRxEofError(faultRxEofError),
116  m_faultTxEofError(faultTxEofError),
117  m_queueFree(queueFree),
118  m_queueTxActive(queueTxActive),
119  m_queueTxWaiting(queueTxWaiting),
120  m_queueRx(queueRx),
121  m_queueHistory(queueHistory),
122  m_playbackCounter(playbackCounter),
123  m_pollCounter(pollCounter)
124  {
125 
126  }
127 
128  ChannelTelemetry ::
129  ChannelTelemetry(const ChannelTelemetry& obj) :
130  Serializable(),
131  m_recvErrors(obj.m_recvErrors),
132  m_recvDropped(obj.m_recvDropped),
133  m_recvSpurious(obj.m_recvSpurious),
134  m_recvFileDataBytes(obj.m_recvFileDataBytes),
135  m_recvNakSegmentRequests(obj.m_recvNakSegmentRequests),
136  m_recvPdu(obj.m_recvPdu),
137  m_recvEofCanceled(obj.m_recvEofCanceled),
138  m_sentNakSegmentRequests(obj.m_sentNakSegmentRequests),
139  m_sentFileDataBytes(obj.m_sentFileDataBytes),
140  m_sentPdu(obj.m_sentPdu),
141  m_sentEofCanceled(obj.m_sentEofCanceled),
142  m_faultAckLimit(obj.m_faultAckLimit),
143  m_faultNakLimit(obj.m_faultNakLimit),
144  m_faultInactivityTimer(obj.m_faultInactivityTimer),
145  m_faultCrcMismatch(obj.m_faultCrcMismatch),
146  m_faultFileSizeMismatch(obj.m_faultFileSizeMismatch),
147  m_faultFileOpen(obj.m_faultFileOpen),
148  m_faultFileRead(obj.m_faultFileRead),
149  m_faultFileWrite(obj.m_faultFileWrite),
150  m_faultFileSeek(obj.m_faultFileSeek),
151  m_faultFileRename(obj.m_faultFileRename),
152  m_faultDirectoryRead(obj.m_faultDirectoryRead),
153  m_faultRxEofError(obj.m_faultRxEofError),
154  m_faultTxEofError(obj.m_faultTxEofError),
155  m_queueFree(obj.m_queueFree),
156  m_queueTxActive(obj.m_queueTxActive),
157  m_queueTxWaiting(obj.m_queueTxWaiting),
158  m_queueRx(obj.m_queueRx),
159  m_queueHistory(obj.m_queueHistory),
160  m_playbackCounter(obj.m_playbackCounter),
161  m_pollCounter(obj.m_pollCounter)
162  {
163 
164  }
165 
166  // ----------------------------------------------------------------------
167  // Operators
168  // ----------------------------------------------------------------------
169 
170  ChannelTelemetry& ChannelTelemetry ::
171  operator=(const ChannelTelemetry& obj)
172  {
173  if (this == &obj) {
174  return *this;
175  }
176 
177  set(obj.m_recvErrors, obj.m_recvDropped, obj.m_recvSpurious, obj.m_recvFileDataBytes, obj.m_recvNakSegmentRequests, obj.m_recvPdu, obj.m_recvEofCanceled, obj.m_sentNakSegmentRequests, obj.m_sentFileDataBytes, obj.m_sentPdu, obj.m_sentEofCanceled, obj.m_faultAckLimit, obj.m_faultNakLimit, obj.m_faultInactivityTimer, obj.m_faultCrcMismatch, obj.m_faultFileSizeMismatch, obj.m_faultFileOpen, obj.m_faultFileRead, obj.m_faultFileWrite, obj.m_faultFileSeek, obj.m_faultFileRename, obj.m_faultDirectoryRead, obj.m_faultRxEofError, obj.m_faultTxEofError, obj.m_queueFree, obj.m_queueTxActive, obj.m_queueTxWaiting, obj.m_queueRx, obj.m_queueHistory, obj.m_playbackCounter, obj.m_pollCounter);
178  return *this;
179  }
180 
181  bool ChannelTelemetry ::
182  operator==(const ChannelTelemetry& obj) const
183  {
184  if (this == &obj) { return true; }
185  return (
186  (this->m_recvErrors == obj.m_recvErrors) &&
187  (this->m_recvDropped == obj.m_recvDropped) &&
188  (this->m_recvSpurious == obj.m_recvSpurious) &&
189  (this->m_recvFileDataBytes == obj.m_recvFileDataBytes) &&
190  (this->m_recvNakSegmentRequests == obj.m_recvNakSegmentRequests) &&
191  (this->m_recvPdu == obj.m_recvPdu) &&
192  (this->m_recvEofCanceled == obj.m_recvEofCanceled) &&
193  (this->m_sentNakSegmentRequests == obj.m_sentNakSegmentRequests) &&
194  (this->m_sentFileDataBytes == obj.m_sentFileDataBytes) &&
195  (this->m_sentPdu == obj.m_sentPdu) &&
196  (this->m_sentEofCanceled == obj.m_sentEofCanceled) &&
197  (this->m_faultAckLimit == obj.m_faultAckLimit) &&
198  (this->m_faultNakLimit == obj.m_faultNakLimit) &&
199  (this->m_faultInactivityTimer == obj.m_faultInactivityTimer) &&
200  (this->m_faultCrcMismatch == obj.m_faultCrcMismatch) &&
201  (this->m_faultFileSizeMismatch == obj.m_faultFileSizeMismatch) &&
202  (this->m_faultFileOpen == obj.m_faultFileOpen) &&
203  (this->m_faultFileRead == obj.m_faultFileRead) &&
204  (this->m_faultFileWrite == obj.m_faultFileWrite) &&
205  (this->m_faultFileSeek == obj.m_faultFileSeek) &&
206  (this->m_faultFileRename == obj.m_faultFileRename) &&
207  (this->m_faultDirectoryRead == obj.m_faultDirectoryRead) &&
208  (this->m_faultRxEofError == obj.m_faultRxEofError) &&
209  (this->m_faultTxEofError == obj.m_faultTxEofError) &&
210  (this->m_queueFree == obj.m_queueFree) &&
211  (this->m_queueTxActive == obj.m_queueTxActive) &&
212  (this->m_queueTxWaiting == obj.m_queueTxWaiting) &&
213  (this->m_queueRx == obj.m_queueRx) &&
214  (this->m_queueHistory == obj.m_queueHistory) &&
215  (this->m_playbackCounter == obj.m_playbackCounter) &&
216  (this->m_pollCounter == obj.m_pollCounter)
217  );
218  }
219 
220  bool ChannelTelemetry ::
221  operator!=(const ChannelTelemetry& obj) const
222  {
223  return !(*this == obj);
224  }
225 
226 #ifdef BUILD_UT
227 
228  std::ostream& operator<<(std::ostream& os, const ChannelTelemetry& obj) {
229  Fw::String s;
230  obj.toString(s);
231  os << s.toChar();
232  return os;
233  }
234 
235 #endif
236 
237  // ----------------------------------------------------------------------
238  // Member functions
239  // ----------------------------------------------------------------------
240 
241  Fw::SerializeStatus ChannelTelemetry ::
242  serializeTo(
243  Fw::SerialBufferBase& buffer,
244  Fw::Endianness mode
245  ) const
246  {
247  Fw::SerializeStatus status;
248 
249  status = buffer.serializeFrom(this->m_recvErrors, mode);
250  if (status != Fw::FW_SERIALIZE_OK) {
251  return status;
252  }
253  status = buffer.serializeFrom(this->m_recvDropped, mode);
254  if (status != Fw::FW_SERIALIZE_OK) {
255  return status;
256  }
257  status = buffer.serializeFrom(this->m_recvSpurious, mode);
258  if (status != Fw::FW_SERIALIZE_OK) {
259  return status;
260  }
261  status = buffer.serializeFrom(this->m_recvFileDataBytes, mode);
262  if (status != Fw::FW_SERIALIZE_OK) {
263  return status;
264  }
265  status = buffer.serializeFrom(this->m_recvNakSegmentRequests, mode);
266  if (status != Fw::FW_SERIALIZE_OK) {
267  return status;
268  }
269  status = buffer.serializeFrom(this->m_recvPdu, mode);
270  if (status != Fw::FW_SERIALIZE_OK) {
271  return status;
272  }
273  status = buffer.serializeFrom(this->m_recvEofCanceled, mode);
274  if (status != Fw::FW_SERIALIZE_OK) {
275  return status;
276  }
277  status = buffer.serializeFrom(this->m_sentNakSegmentRequests, mode);
278  if (status != Fw::FW_SERIALIZE_OK) {
279  return status;
280  }
281  status = buffer.serializeFrom(this->m_sentFileDataBytes, mode);
282  if (status != Fw::FW_SERIALIZE_OK) {
283  return status;
284  }
285  status = buffer.serializeFrom(this->m_sentPdu, mode);
286  if (status != Fw::FW_SERIALIZE_OK) {
287  return status;
288  }
289  status = buffer.serializeFrom(this->m_sentEofCanceled, mode);
290  if (status != Fw::FW_SERIALIZE_OK) {
291  return status;
292  }
293  status = buffer.serializeFrom(this->m_faultAckLimit, mode);
294  if (status != Fw::FW_SERIALIZE_OK) {
295  return status;
296  }
297  status = buffer.serializeFrom(this->m_faultNakLimit, mode);
298  if (status != Fw::FW_SERIALIZE_OK) {
299  return status;
300  }
301  status = buffer.serializeFrom(this->m_faultInactivityTimer, mode);
302  if (status != Fw::FW_SERIALIZE_OK) {
303  return status;
304  }
305  status = buffer.serializeFrom(this->m_faultCrcMismatch, mode);
306  if (status != Fw::FW_SERIALIZE_OK) {
307  return status;
308  }
309  status = buffer.serializeFrom(this->m_faultFileSizeMismatch, mode);
310  if (status != Fw::FW_SERIALIZE_OK) {
311  return status;
312  }
313  status = buffer.serializeFrom(this->m_faultFileOpen, mode);
314  if (status != Fw::FW_SERIALIZE_OK) {
315  return status;
316  }
317  status = buffer.serializeFrom(this->m_faultFileRead, mode);
318  if (status != Fw::FW_SERIALIZE_OK) {
319  return status;
320  }
321  status = buffer.serializeFrom(this->m_faultFileWrite, mode);
322  if (status != Fw::FW_SERIALIZE_OK) {
323  return status;
324  }
325  status = buffer.serializeFrom(this->m_faultFileSeek, mode);
326  if (status != Fw::FW_SERIALIZE_OK) {
327  return status;
328  }
329  status = buffer.serializeFrom(this->m_faultFileRename, mode);
330  if (status != Fw::FW_SERIALIZE_OK) {
331  return status;
332  }
333  status = buffer.serializeFrom(this->m_faultDirectoryRead, mode);
334  if (status != Fw::FW_SERIALIZE_OK) {
335  return status;
336  }
337  status = buffer.serializeFrom(this->m_faultRxEofError, mode);
338  if (status != Fw::FW_SERIALIZE_OK) {
339  return status;
340  }
341  status = buffer.serializeFrom(this->m_faultTxEofError, mode);
342  if (status != Fw::FW_SERIALIZE_OK) {
343  return status;
344  }
345  status = buffer.serializeFrom(this->m_queueFree, mode);
346  if (status != Fw::FW_SERIALIZE_OK) {
347  return status;
348  }
349  status = buffer.serializeFrom(this->m_queueTxActive, mode);
350  if (status != Fw::FW_SERIALIZE_OK) {
351  return status;
352  }
353  status = buffer.serializeFrom(this->m_queueTxWaiting, mode);
354  if (status != Fw::FW_SERIALIZE_OK) {
355  return status;
356  }
357  status = buffer.serializeFrom(this->m_queueRx, mode);
358  if (status != Fw::FW_SERIALIZE_OK) {
359  return status;
360  }
361  status = buffer.serializeFrom(this->m_queueHistory, mode);
362  if (status != Fw::FW_SERIALIZE_OK) {
363  return status;
364  }
365  status = buffer.serializeFrom(this->m_playbackCounter, mode);
366  if (status != Fw::FW_SERIALIZE_OK) {
367  return status;
368  }
369  status = buffer.serializeFrom(this->m_pollCounter, mode);
370  if (status != Fw::FW_SERIALIZE_OK) {
371  return status;
372  }
373 
374  return status;
375  }
376 
377  Fw::SerializeStatus ChannelTelemetry ::
378  deserializeFrom(
379  Fw::SerialBufferBase& buffer,
380  Fw::Endianness mode
381  )
382  {
383  Fw::SerializeStatus status;
384 
385  status = buffer.deserializeTo(this->m_recvErrors, mode);
386  if (status != Fw::FW_SERIALIZE_OK) {
387  return status;
388  }
389  status = buffer.deserializeTo(this->m_recvDropped, mode);
390  if (status != Fw::FW_SERIALIZE_OK) {
391  return status;
392  }
393  status = buffer.deserializeTo(this->m_recvSpurious, mode);
394  if (status != Fw::FW_SERIALIZE_OK) {
395  return status;
396  }
397  status = buffer.deserializeTo(this->m_recvFileDataBytes, mode);
398  if (status != Fw::FW_SERIALIZE_OK) {
399  return status;
400  }
401  status = buffer.deserializeTo(this->m_recvNakSegmentRequests, mode);
402  if (status != Fw::FW_SERIALIZE_OK) {
403  return status;
404  }
405  status = buffer.deserializeTo(this->m_recvPdu, mode);
406  if (status != Fw::FW_SERIALIZE_OK) {
407  return status;
408  }
409  status = buffer.deserializeTo(this->m_recvEofCanceled, mode);
410  if (status != Fw::FW_SERIALIZE_OK) {
411  return status;
412  }
413  status = buffer.deserializeTo(this->m_sentNakSegmentRequests, mode);
414  if (status != Fw::FW_SERIALIZE_OK) {
415  return status;
416  }
417  status = buffer.deserializeTo(this->m_sentFileDataBytes, mode);
418  if (status != Fw::FW_SERIALIZE_OK) {
419  return status;
420  }
421  status = buffer.deserializeTo(this->m_sentPdu, mode);
422  if (status != Fw::FW_SERIALIZE_OK) {
423  return status;
424  }
425  status = buffer.deserializeTo(this->m_sentEofCanceled, mode);
426  if (status != Fw::FW_SERIALIZE_OK) {
427  return status;
428  }
429  status = buffer.deserializeTo(this->m_faultAckLimit, mode);
430  if (status != Fw::FW_SERIALIZE_OK) {
431  return status;
432  }
433  status = buffer.deserializeTo(this->m_faultNakLimit, mode);
434  if (status != Fw::FW_SERIALIZE_OK) {
435  return status;
436  }
437  status = buffer.deserializeTo(this->m_faultInactivityTimer, mode);
438  if (status != Fw::FW_SERIALIZE_OK) {
439  return status;
440  }
441  status = buffer.deserializeTo(this->m_faultCrcMismatch, mode);
442  if (status != Fw::FW_SERIALIZE_OK) {
443  return status;
444  }
445  status = buffer.deserializeTo(this->m_faultFileSizeMismatch, mode);
446  if (status != Fw::FW_SERIALIZE_OK) {
447  return status;
448  }
449  status = buffer.deserializeTo(this->m_faultFileOpen, mode);
450  if (status != Fw::FW_SERIALIZE_OK) {
451  return status;
452  }
453  status = buffer.deserializeTo(this->m_faultFileRead, mode);
454  if (status != Fw::FW_SERIALIZE_OK) {
455  return status;
456  }
457  status = buffer.deserializeTo(this->m_faultFileWrite, mode);
458  if (status != Fw::FW_SERIALIZE_OK) {
459  return status;
460  }
461  status = buffer.deserializeTo(this->m_faultFileSeek, mode);
462  if (status != Fw::FW_SERIALIZE_OK) {
463  return status;
464  }
465  status = buffer.deserializeTo(this->m_faultFileRename, mode);
466  if (status != Fw::FW_SERIALIZE_OK) {
467  return status;
468  }
469  status = buffer.deserializeTo(this->m_faultDirectoryRead, mode);
470  if (status != Fw::FW_SERIALIZE_OK) {
471  return status;
472  }
473  status = buffer.deserializeTo(this->m_faultRxEofError, mode);
474  if (status != Fw::FW_SERIALIZE_OK) {
475  return status;
476  }
477  status = buffer.deserializeTo(this->m_faultTxEofError, mode);
478  if (status != Fw::FW_SERIALIZE_OK) {
479  return status;
480  }
481  status = buffer.deserializeTo(this->m_queueFree, mode);
482  if (status != Fw::FW_SERIALIZE_OK) {
483  return status;
484  }
485  status = buffer.deserializeTo(this->m_queueTxActive, mode);
486  if (status != Fw::FW_SERIALIZE_OK) {
487  return status;
488  }
489  status = buffer.deserializeTo(this->m_queueTxWaiting, mode);
490  if (status != Fw::FW_SERIALIZE_OK) {
491  return status;
492  }
493  status = buffer.deserializeTo(this->m_queueRx, mode);
494  if (status != Fw::FW_SERIALIZE_OK) {
495  return status;
496  }
497  status = buffer.deserializeTo(this->m_queueHistory, mode);
498  if (status != Fw::FW_SERIALIZE_OK) {
499  return status;
500  }
501  status = buffer.deserializeTo(this->m_playbackCounter, mode);
502  if (status != Fw::FW_SERIALIZE_OK) {
503  return status;
504  }
505  status = buffer.deserializeTo(this->m_pollCounter, mode);
506  if (status != Fw::FW_SERIALIZE_OK) {
507  return status;
508  }
509 
510  return status;
511  }
512 
513  FwSizeType ChannelTelemetry ::
514  serializedSize() const
515  {
516  FwSizeType size = 0;
517  size += sizeof(U32);
518  size += sizeof(U32);
519  size += sizeof(U32);
520  size += sizeof(U64);
521  size += sizeof(U32);
522  size += sizeof(U32);
523  size += sizeof(U32);
524  size += sizeof(U32);
525  size += sizeof(U64);
526  size += sizeof(U32);
527  size += sizeof(U32);
528  size += sizeof(U32);
529  size += sizeof(U32);
530  size += sizeof(U32);
531  size += sizeof(U32);
532  size += sizeof(U32);
533  size += sizeof(U32);
534  size += sizeof(U32);
535  size += sizeof(U32);
536  size += sizeof(U32);
537  size += sizeof(U32);
538  size += sizeof(U32);
539  size += sizeof(U32);
540  size += sizeof(U32);
541  size += sizeof(U16);
542  size += sizeof(U16);
543  size += sizeof(U16);
544  size += sizeof(U16);
545  size += sizeof(U16);
546  size += sizeof(U8);
547  size += sizeof(U8);
548  return size;
549  }
550 
551 #if FW_SERIALIZABLE_TO_STRING
552 
553  void ChannelTelemetry ::
554  toString(Fw::StringBase& sb) const
555  {
556  Fw::String tmp;
557  sb = "( ";
558 
559  // Format recvErrors
560  sb += "recvErrors = ";
561  tmp.format("%" PRIu32 "", this->m_recvErrors);
562  sb += tmp;
563  sb += ", ";
564 
565  // Format recvDropped
566  sb += "recvDropped = ";
567  tmp.format("%" PRIu32 "", this->m_recvDropped);
568  sb += tmp;
569  sb += ", ";
570 
571  // Format recvSpurious
572  sb += "recvSpurious = ";
573  tmp.format("%" PRIu32 "", this->m_recvSpurious);
574  sb += tmp;
575  sb += ", ";
576 
577  // Format recvFileDataBytes
578  sb += "recvFileDataBytes = ";
579  tmp.format("%" PRIu64 "", this->m_recvFileDataBytes);
580  sb += tmp;
581  sb += ", ";
582 
583  // Format recvNakSegmentRequests
584  sb += "recvNakSegmentRequests = ";
585  tmp.format("%" PRIu32 "", this->m_recvNakSegmentRequests);
586  sb += tmp;
587  sb += ", ";
588 
589  // Format recvPdu
590  sb += "recvPdu = ";
591  tmp.format("%" PRIu32 "", this->m_recvPdu);
592  sb += tmp;
593  sb += ", ";
594 
595  // Format recvEofCanceled
596  sb += "recvEofCanceled = ";
597  tmp.format("%" PRIu32 "", this->m_recvEofCanceled);
598  sb += tmp;
599  sb += ", ";
600 
601  // Format sentNakSegmentRequests
602  sb += "sentNakSegmentRequests = ";
603  tmp.format("%" PRIu32 "", this->m_sentNakSegmentRequests);
604  sb += tmp;
605  sb += ", ";
606 
607  // Format sentFileDataBytes
608  sb += "sentFileDataBytes = ";
609  tmp.format("%" PRIu64 "", this->m_sentFileDataBytes);
610  sb += tmp;
611  sb += ", ";
612 
613  // Format sentPdu
614  sb += "sentPdu = ";
615  tmp.format("%" PRIu32 "", this->m_sentPdu);
616  sb += tmp;
617  sb += ", ";
618 
619  // Format sentEofCanceled
620  sb += "sentEofCanceled = ";
621  tmp.format("%" PRIu32 "", this->m_sentEofCanceled);
622  sb += tmp;
623  sb += ", ";
624 
625  // Format faultAckLimit
626  sb += "faultAckLimit = ";
627  tmp.format("%" PRIu32 "", this->m_faultAckLimit);
628  sb += tmp;
629  sb += ", ";
630 
631  // Format faultNakLimit
632  sb += "faultNakLimit = ";
633  tmp.format("%" PRIu32 "", this->m_faultNakLimit);
634  sb += tmp;
635  sb += ", ";
636 
637  // Format faultInactivityTimer
638  sb += "faultInactivityTimer = ";
639  tmp.format("%" PRIu32 "", this->m_faultInactivityTimer);
640  sb += tmp;
641  sb += ", ";
642 
643  // Format faultCrcMismatch
644  sb += "faultCrcMismatch = ";
645  tmp.format("%" PRIu32 "", this->m_faultCrcMismatch);
646  sb += tmp;
647  sb += ", ";
648 
649  // Format faultFileSizeMismatch
650  sb += "faultFileSizeMismatch = ";
651  tmp.format("%" PRIu32 "", this->m_faultFileSizeMismatch);
652  sb += tmp;
653  sb += ", ";
654 
655  // Format faultFileOpen
656  sb += "faultFileOpen = ";
657  tmp.format("%" PRIu32 "", this->m_faultFileOpen);
658  sb += tmp;
659  sb += ", ";
660 
661  // Format faultFileRead
662  sb += "faultFileRead = ";
663  tmp.format("%" PRIu32 "", this->m_faultFileRead);
664  sb += tmp;
665  sb += ", ";
666 
667  // Format faultFileWrite
668  sb += "faultFileWrite = ";
669  tmp.format("%" PRIu32 "", this->m_faultFileWrite);
670  sb += tmp;
671  sb += ", ";
672 
673  // Format faultFileSeek
674  sb += "faultFileSeek = ";
675  tmp.format("%" PRIu32 "", this->m_faultFileSeek);
676  sb += tmp;
677  sb += ", ";
678 
679  // Format faultFileRename
680  sb += "faultFileRename = ";
681  tmp.format("%" PRIu32 "", this->m_faultFileRename);
682  sb += tmp;
683  sb += ", ";
684 
685  // Format faultDirectoryRead
686  sb += "faultDirectoryRead = ";
687  tmp.format("%" PRIu32 "", this->m_faultDirectoryRead);
688  sb += tmp;
689  sb += ", ";
690 
691  // Format faultRxEofError
692  sb += "faultRxEofError = ";
693  tmp.format("%" PRIu32 "", this->m_faultRxEofError);
694  sb += tmp;
695  sb += ", ";
696 
697  // Format faultTxEofError
698  sb += "faultTxEofError = ";
699  tmp.format("%" PRIu32 "", this->m_faultTxEofError);
700  sb += tmp;
701  sb += ", ";
702 
703  // Format queueFree
704  sb += "queueFree = ";
705  tmp.format("%" PRIu16 "", this->m_queueFree);
706  sb += tmp;
707  sb += ", ";
708 
709  // Format queueTxActive
710  sb += "queueTxActive = ";
711  tmp.format("%" PRIu16 "", this->m_queueTxActive);
712  sb += tmp;
713  sb += ", ";
714 
715  // Format queueTxWaiting
716  sb += "queueTxWaiting = ";
717  tmp.format("%" PRIu16 "", this->m_queueTxWaiting);
718  sb += tmp;
719  sb += ", ";
720 
721  // Format queueRx
722  sb += "queueRx = ";
723  tmp.format("%" PRIu16 "", this->m_queueRx);
724  sb += tmp;
725  sb += ", ";
726 
727  // Format queueHistory
728  sb += "queueHistory = ";
729  tmp.format("%" PRIu16 "", this->m_queueHistory);
730  sb += tmp;
731  sb += ", ";
732 
733  // Format playbackCounter
734  sb += "playbackCounter = ";
735  tmp.format("%" PRIu8 "", this->m_playbackCounter);
736  sb += tmp;
737  sb += ", ";
738 
739  // Format pollCounter
740  sb += "pollCounter = ";
741  tmp.format("%" PRIu8 "", this->m_pollCounter);
742  sb += tmp;
743  sb += " )";
744  }
745 
746 #endif
747 
748  // ----------------------------------------------------------------------
749  // Setter functions
750  // ----------------------------------------------------------------------
751 
752  void ChannelTelemetry ::
753  set(
754  U32 recvErrors,
755  U32 recvDropped,
756  U32 recvSpurious,
757  U64 recvFileDataBytes,
758  U32 recvNakSegmentRequests,
759  U32 recvPdu,
760  U32 recvEofCanceled,
761  U32 sentNakSegmentRequests,
762  U64 sentFileDataBytes,
763  U32 sentPdu,
764  U32 sentEofCanceled,
765  U32 faultAckLimit,
766  U32 faultNakLimit,
767  U32 faultInactivityTimer,
768  U32 faultCrcMismatch,
769  U32 faultFileSizeMismatch,
770  U32 faultFileOpen,
771  U32 faultFileRead,
772  U32 faultFileWrite,
773  U32 faultFileSeek,
774  U32 faultFileRename,
775  U32 faultDirectoryRead,
776  U32 faultRxEofError,
777  U32 faultTxEofError,
778  U16 queueFree,
779  U16 queueTxActive,
780  U16 queueTxWaiting,
781  U16 queueRx,
782  U16 queueHistory,
783  U8 playbackCounter,
784  U8 pollCounter
785  )
786  {
787  this->m_recvErrors = recvErrors;
788  this->m_recvDropped = recvDropped;
789  this->m_recvSpurious = recvSpurious;
790  this->m_recvFileDataBytes = recvFileDataBytes;
791  this->m_recvNakSegmentRequests = recvNakSegmentRequests;
792  this->m_recvPdu = recvPdu;
793  this->m_recvEofCanceled = recvEofCanceled;
794  this->m_sentNakSegmentRequests = sentNakSegmentRequests;
795  this->m_sentFileDataBytes = sentFileDataBytes;
796  this->m_sentPdu = sentPdu;
797  this->m_sentEofCanceled = sentEofCanceled;
798  this->m_faultAckLimit = faultAckLimit;
799  this->m_faultNakLimit = faultNakLimit;
800  this->m_faultInactivityTimer = faultInactivityTimer;
801  this->m_faultCrcMismatch = faultCrcMismatch;
802  this->m_faultFileSizeMismatch = faultFileSizeMismatch;
803  this->m_faultFileOpen = faultFileOpen;
804  this->m_faultFileRead = faultFileRead;
805  this->m_faultFileWrite = faultFileWrite;
806  this->m_faultFileSeek = faultFileSeek;
807  this->m_faultFileRename = faultFileRename;
808  this->m_faultDirectoryRead = faultDirectoryRead;
809  this->m_faultRxEofError = faultRxEofError;
810  this->m_faultTxEofError = faultTxEofError;
811  this->m_queueFree = queueFree;
812  this->m_queueTxActive = queueTxActive;
813  this->m_queueTxWaiting = queueTxWaiting;
814  this->m_queueRx = queueRx;
815  this->m_queueHistory = queueHistory;
816  this->m_playbackCounter = playbackCounter;
817  this->m_pollCounter = pollCounter;
818  }
819 
820  void ChannelTelemetry ::
821  set_recvErrors(U32 recvErrors)
822  {
823  this->m_recvErrors = recvErrors;
824  }
825 
826  void ChannelTelemetry ::
827  set_recvDropped(U32 recvDropped)
828  {
829  this->m_recvDropped = recvDropped;
830  }
831 
832  void ChannelTelemetry ::
833  set_recvSpurious(U32 recvSpurious)
834  {
835  this->m_recvSpurious = recvSpurious;
836  }
837 
838  void ChannelTelemetry ::
839  set_recvFileDataBytes(U64 recvFileDataBytes)
840  {
841  this->m_recvFileDataBytes = recvFileDataBytes;
842  }
843 
844  void ChannelTelemetry ::
845  set_recvNakSegmentRequests(U32 recvNakSegmentRequests)
846  {
847  this->m_recvNakSegmentRequests = recvNakSegmentRequests;
848  }
849 
850  void ChannelTelemetry ::
851  set_recvPdu(U32 recvPdu)
852  {
853  this->m_recvPdu = recvPdu;
854  }
855 
856  void ChannelTelemetry ::
857  set_recvEofCanceled(U32 recvEofCanceled)
858  {
859  this->m_recvEofCanceled = recvEofCanceled;
860  }
861 
862  void ChannelTelemetry ::
863  set_sentNakSegmentRequests(U32 sentNakSegmentRequests)
864  {
865  this->m_sentNakSegmentRequests = sentNakSegmentRequests;
866  }
867 
868  void ChannelTelemetry ::
869  set_sentFileDataBytes(U64 sentFileDataBytes)
870  {
871  this->m_sentFileDataBytes = sentFileDataBytes;
872  }
873 
874  void ChannelTelemetry ::
875  set_sentPdu(U32 sentPdu)
876  {
877  this->m_sentPdu = sentPdu;
878  }
879 
880  void ChannelTelemetry ::
881  set_sentEofCanceled(U32 sentEofCanceled)
882  {
883  this->m_sentEofCanceled = sentEofCanceled;
884  }
885 
886  void ChannelTelemetry ::
887  set_faultAckLimit(U32 faultAckLimit)
888  {
889  this->m_faultAckLimit = faultAckLimit;
890  }
891 
892  void ChannelTelemetry ::
893  set_faultNakLimit(U32 faultNakLimit)
894  {
895  this->m_faultNakLimit = faultNakLimit;
896  }
897 
898  void ChannelTelemetry ::
899  set_faultInactivityTimer(U32 faultInactivityTimer)
900  {
901  this->m_faultInactivityTimer = faultInactivityTimer;
902  }
903 
904  void ChannelTelemetry ::
905  set_faultCrcMismatch(U32 faultCrcMismatch)
906  {
907  this->m_faultCrcMismatch = faultCrcMismatch;
908  }
909 
910  void ChannelTelemetry ::
911  set_faultFileSizeMismatch(U32 faultFileSizeMismatch)
912  {
913  this->m_faultFileSizeMismatch = faultFileSizeMismatch;
914  }
915 
916  void ChannelTelemetry ::
917  set_faultFileOpen(U32 faultFileOpen)
918  {
919  this->m_faultFileOpen = faultFileOpen;
920  }
921 
922  void ChannelTelemetry ::
923  set_faultFileRead(U32 faultFileRead)
924  {
925  this->m_faultFileRead = faultFileRead;
926  }
927 
928  void ChannelTelemetry ::
929  set_faultFileWrite(U32 faultFileWrite)
930  {
931  this->m_faultFileWrite = faultFileWrite;
932  }
933 
934  void ChannelTelemetry ::
935  set_faultFileSeek(U32 faultFileSeek)
936  {
937  this->m_faultFileSeek = faultFileSeek;
938  }
939 
940  void ChannelTelemetry ::
941  set_faultFileRename(U32 faultFileRename)
942  {
943  this->m_faultFileRename = faultFileRename;
944  }
945 
946  void ChannelTelemetry ::
947  set_faultDirectoryRead(U32 faultDirectoryRead)
948  {
949  this->m_faultDirectoryRead = faultDirectoryRead;
950  }
951 
952  void ChannelTelemetry ::
953  set_faultRxEofError(U32 faultRxEofError)
954  {
955  this->m_faultRxEofError = faultRxEofError;
956  }
957 
958  void ChannelTelemetry ::
959  set_faultTxEofError(U32 faultTxEofError)
960  {
961  this->m_faultTxEofError = faultTxEofError;
962  }
963 
964  void ChannelTelemetry ::
965  set_queueFree(U16 queueFree)
966  {
967  this->m_queueFree = queueFree;
968  }
969 
970  void ChannelTelemetry ::
971  set_queueTxActive(U16 queueTxActive)
972  {
973  this->m_queueTxActive = queueTxActive;
974  }
975 
976  void ChannelTelemetry ::
977  set_queueTxWaiting(U16 queueTxWaiting)
978  {
979  this->m_queueTxWaiting = queueTxWaiting;
980  }
981 
982  void ChannelTelemetry ::
983  set_queueRx(U16 queueRx)
984  {
985  this->m_queueRx = queueRx;
986  }
987 
988  void ChannelTelemetry ::
989  set_queueHistory(U16 queueHistory)
990  {
991  this->m_queueHistory = queueHistory;
992  }
993 
994  void ChannelTelemetry ::
995  set_playbackCounter(U8 playbackCounter)
996  {
997  this->m_playbackCounter = playbackCounter;
998  }
999 
1000  void ChannelTelemetry ::
1001  set_pollCounter(U8 pollCounter)
1002  {
1003  this->m_pollCounter = pollCounter;
1004  }
1005 
1006  }
1007 
1008  }
1009 
1010 }
Fw::FW_SERIALIZE_OK
Serialization/Deserialization operation was successful.
Definition: Serializable.hpp:15
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultCrcMismatch
void set_faultCrcMismatch(U32 faultCrcMismatch)
Set member faultCrcMismatch.
Definition: ChannelTelemetrySerializableAc.cpp:905
Svc::Ccsds::Cfdp::ChannelTelemetry::set_recvSpurious
void set_recvSpurious(U32 recvSpurious)
Set member recvSpurious.
Definition: ChannelTelemetrySerializableAc.cpp:833
FwSizeType
PlatformSizeType FwSizeType
Definition: FwSizeTypeAliasAc.h:15
Svc::Ccsds::Cfdp::ChannelTelemetry::operator==
bool operator==(const ChannelTelemetry &obj) const
Equality operator.
Definition: ChannelTelemetrySerializableAc.cpp:182
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultFileSeek
void set_faultFileSeek(U32 faultFileSeek)
Set member faultFileSeek.
Definition: ChannelTelemetrySerializableAc.cpp:935
Svc::Ccsds::Cfdp::ChannelTelemetry::set_sentNakSegmentRequests
void set_sentNakSegmentRequests(U32 sentNakSegmentRequests)
Set member sentNakSegmentRequests.
Definition: ChannelTelemetrySerializableAc.cpp:863
Svc::Ccsds::Cfdp::ChannelTelemetry::set_recvEofCanceled
void set_recvEofCanceled(U32 recvEofCanceled)
Set member recvEofCanceled.
Definition: ChannelTelemetrySerializableAc.cpp:857
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultRxEofError
void set_faultRxEofError(U32 faultRxEofError)
Set member faultRxEofError.
Definition: ChannelTelemetrySerializableAc.cpp:953
Svc::Ccsds::Cfdp::ChannelTelemetry::set_queueTxActive
void set_queueTxActive(U16 queueTxActive)
Set member queueTxActive.
Definition: ChannelTelemetrySerializableAc.cpp:971
Svc::Ccsds::Cfdp::ChannelTelemetry::set_recvNakSegmentRequests
void set_recvNakSegmentRequests(U32 recvNakSegmentRequests)
Set member recvNakSegmentRequests.
Definition: ChannelTelemetrySerializableAc.cpp:845
Svc::Ccsds::Cfdp::ChannelTelemetry::set_sentFileDataBytes
void set_sentFileDataBytes(U64 sentFileDataBytes)
Set member sentFileDataBytes.
Definition: ChannelTelemetrySerializableAc.cpp:869
Svc::Ccsds::Cfdp::ChannelTelemetry::deserializeFrom
Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase &buffer, Fw::Endianness mode=Fw::Endianness::BIG)
Deserialization.
Definition: ChannelTelemetrySerializableAc.cpp:378
Svc::Ccsds::Cfdp::ChannelTelemetry::set_pollCounter
void set_pollCounter(U8 pollCounter)
Set member pollCounter.
Definition: ChannelTelemetrySerializableAc.cpp:1001
Fw::SerialBufferBase::serializeFrom
virtual SerializeStatus serializeFrom(U8 val, Endianness mode=Endianness::BIG)=0
Serialize an 8-bit unsigned integer value.
Svc::Ccsds::Cfdp::ChannelTelemetry::serializedSize
FwSizeType serializedSize() const
Get the dynamic serialized size of the struct.
Definition: ChannelTelemetrySerializableAc.cpp:514
Svc::Ccsds::Cfdp::ChannelTelemetry::set_recvFileDataBytes
void set_recvFileDataBytes(U64 recvFileDataBytes)
Set member recvFileDataBytes.
Definition: ChannelTelemetrySerializableAc.cpp:839
Fw::SerializeStatus
SerializeStatus
forward declaration for string
Definition: Serializable.hpp:14
Fw::SerialBufferBase::deserializeTo
virtual SerializeStatus deserializeTo(U8 &val, Endianness mode=Endianness::BIG)=0
Deserialize an 8-bit unsigned integer value.
Svc::Ccsds::Cfdp::ChannelTelemetry::set_queueTxWaiting
void set_queueTxWaiting(U16 queueTxWaiting)
Set member queueTxWaiting.
Definition: ChannelTelemetrySerializableAc.cpp:977
Svc::Ccsds::Cfdp::ChannelTelemetry::set_sentPdu
void set_sentPdu(U32 sentPdu)
Set member sentPdu.
Definition: ChannelTelemetrySerializableAc.cpp:875
Svc::Ccsds::Cfdp::ChannelTelemetry::set_queueRx
void set_queueRx(U16 queueRx)
Set member queueRx.
Definition: ChannelTelemetrySerializableAc.cpp:983
Svc::Ccsds::Cfdp::ChannelTelemetry::operator!=
bool operator!=(const ChannelTelemetry &obj) const
Inequality operator.
Definition: ChannelTelemetrySerializableAc.cpp:221
Svc::Ccsds::Cfdp::ChannelTelemetry::serializeTo
Fw::SerializeStatus serializeTo(Fw::SerialBufferBase &buffer, Fw::Endianness mode=Fw::Endianness::BIG) const
Serialization.
Definition: ChannelTelemetrySerializableAc.cpp:242
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultAckLimit
void set_faultAckLimit(U32 faultAckLimit)
Set member faultAckLimit.
Definition: ChannelTelemetrySerializableAc.cpp:887
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultDirectoryRead
void set_faultDirectoryRead(U32 faultDirectoryRead)
Set member faultDirectoryRead.
Definition: ChannelTelemetrySerializableAc.cpp:947
Assert.hpp
Svc::Ccsds::Cfdp::ChannelTelemetry::set_recvDropped
void set_recvDropped(U32 recvDropped)
Set member recvDropped.
Definition: ChannelTelemetrySerializableAc.cpp:827
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultInactivityTimer
void set_faultInactivityTimer(U32 faultInactivityTimer)
Set member faultInactivityTimer.
Definition: ChannelTelemetrySerializableAc.cpp:899
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultTxEofError
void set_faultTxEofError(U32 faultTxEofError)
Set member faultTxEofError.
Definition: ChannelTelemetrySerializableAc.cpp:959
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultFileOpen
void set_faultFileOpen(U32 faultFileOpen)
Set member faultFileOpen.
Definition: ChannelTelemetrySerializableAc.cpp:917
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultFileRename
void set_faultFileRename(U32 faultFileRename)
Set member faultFileRename.
Definition: ChannelTelemetrySerializableAc.cpp:941
Svc::Ccsds::Cfdp::ChannelTelemetry::set_recvPdu
void set_recvPdu(U32 recvPdu)
Set member recvPdu.
Definition: ChannelTelemetrySerializableAc.cpp:851
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultNakLimit
void set_faultNakLimit(U32 faultNakLimit)
Set member faultNakLimit.
Definition: ChannelTelemetrySerializableAc.cpp:893
Fw::StringTemplate::toChar
const char * toChar() const
Convert to a C-style char*.
Definition: StringTemplate.hpp:49
Fw::StringBase::format
FormatStatus format(const CHAR *formatString,...)
write formatted string to buffer
Definition: StringBase.cpp:58
U8
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.h:54
Svc::Ccsds::Cfdp::ChannelTelemetry::set_playbackCounter
void set_playbackCounter(U8 playbackCounter)
Set member playbackCounter.
Definition: ChannelTelemetrySerializableAc.cpp:995
Svc::Ccsds::Cfdp::ChannelTelemetry::set
void set(U32 recvErrors, U32 recvDropped, U32 recvSpurious, U64 recvFileDataBytes, U32 recvNakSegmentRequests, U32 recvPdu, U32 recvEofCanceled, U32 sentNakSegmentRequests, U64 sentFileDataBytes, U32 sentPdu, U32 sentEofCanceled, U32 faultAckLimit, U32 faultNakLimit, U32 faultInactivityTimer, U32 faultCrcMismatch, U32 faultFileSizeMismatch, U32 faultFileOpen, U32 faultFileRead, U32 faultFileWrite, U32 faultFileSeek, U32 faultFileRename, U32 faultDirectoryRead, U32 faultRxEofError, U32 faultTxEofError, U16 queueFree, U16 queueTxActive, U16 queueTxWaiting, U16 queueRx, U16 queueHistory, U8 playbackCounter, U8 pollCounter)
Set all members.
Definition: ChannelTelemetrySerializableAc.cpp:753
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultFileWrite
void set_faultFileWrite(U32 faultFileWrite)
Set member faultFileWrite.
Definition: ChannelTelemetrySerializableAc.cpp:929
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultFileRead
void set_faultFileRead(U32 faultFileRead)
Set member faultFileRead.
Definition: ChannelTelemetrySerializableAc.cpp:923
Svc::Ccsds::Cfdp::ChannelTelemetry
Structure for the telemetry array of CFDP channels.
Definition: ChannelTelemetrySerializableAc.hpp:22
Svc
RateGroupDivider component implementation.
Definition: ActiveRateGroupCfg.hpp:18
Svc::Ccsds::Cfdp::ChannelTelemetry::set_faultFileSizeMismatch
void set_faultFileSizeMismatch(U32 faultFileSizeMismatch)
Set member faultFileSizeMismatch.
Definition: ChannelTelemetrySerializableAc.cpp:911
Fw::Endianness
Endianness
Definition: Serializable.hpp:37
Svc::Ccsds::Cfdp::ChannelTelemetry::set_queueHistory
void set_queueHistory(U16 queueHistory)
Set member queueHistory.
Definition: ChannelTelemetrySerializableAc.cpp:989
Svc::Ccsds::Cfdp::ChannelTelemetry::set_queueFree
void set_queueFree(U16 queueFree)
Set member queueFree.
Definition: ChannelTelemetrySerializableAc.cpp:965
ChannelTelemetrySerializableAc.hpp
Svc::Ccsds::Cfdp::ChannelTelemetry::operator=
ChannelTelemetry & operator=(const ChannelTelemetry &obj)
Copy assignment operator.
Definition: ChannelTelemetrySerializableAc.cpp:171
Svc::Ccsds::Cfdp::ChannelTelemetry::set_sentEofCanceled
void set_sentEofCanceled(U32 sentEofCanceled)
Set member sentEofCanceled.
Definition: ChannelTelemetrySerializableAc.cpp:881
Svc::Ccsds::Cfdp::ChannelTelemetry::set_recvErrors
void set_recvErrors(U32 recvErrors)
Set member recvErrors.
Definition: ChannelTelemetrySerializableAc.cpp:821
U64
#define U64(C)
Definition: sha.h:181