F´ Flight Software - C/C++ Documentation
A framework for building embedded system applications to NASA flight quality standards.
TlmPacketizer.cpp
Go to the documentation of this file.
1 // ======================================================================
2 // \title TlmPacketizerImpl.cpp
3 // \author tcanham
4 // \brief cpp file for TlmPacketizer component implementation 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 #include <Fw/Com/ComPacket.hpp>
12 #include <Fw/FPrimeBasicTypes.hpp>
13 #include <Fw/Prm/ParamValid.hpp>
16 #include <cstring>
17 #include <limits>
18 
19 namespace Svc {
20 
21 const TlmPacketizer_TelemetrySendPortMap TlmPacketizer::TELEMETRY_SEND_PORT_MAP = {};
22 
23 static_assert(Svc::TelemetrySection::NUM_SECTIONS >= 1, "At least one telemetry section is required");
24 
25 // Keeps every offset a ComBuffer can hold representable in the offset type; setPacketList additionally asserts
26 // at runtime that no offset equals the NOT_IN_PACKET sentinel (the type's maximum)
27 static_assert(FW_COM_BUFFER_MAX_SIZE <= std::numeric_limits<FwTlmPacketizeOffsetType>::max(),
28  "FwTlmPacketizeOffsetType must span an entire ComBuffer");
29 
30 static_assert(static_cast<U8>(Fw::FW_DESERIALIZE_BUFFER_EMPTY) == Fw::DeserialStatus::BUFFER_EMPTY and
34  "Fw::DeserialStatus must mirror Fw::SerializeStatus values");
35 
36 // ----------------------------------------------------------------------
37 // Construction, initialization, and destruction
38 // ----------------------------------------------------------------------
39 
40 TlmPacketizer ::TlmPacketizer(const char* const compName)
41  : TlmPacketizerComponentBase(compName), m_numPackets(0), m_configured(false), m_numChannels(0) {
42  // Register self as parameter delegate
43  this->registerExternalParameters(this);
44  // clear missing tlm channel check
45  for (FwChanIdType entry = 0; entry < TLMPACKETIZER_MAX_MISSING_TLM_CHECK; entry++) {
46  this->m_missTlmCheck[entry].checked = false;
47  this->m_missTlmCheck[entry].id = 0;
48  }
49 
50  // clear packet buffers
51  for (FwChanIdType buffer = 0; buffer < MAX_PACKETIZER_PACKETS; buffer++) {
52  this->m_fillBuffers[buffer].updated = false;
53  }
54 
56  "NUM_CONFIGURABLE_TLMPACKETIZER_GROUPS MUST BE MAX_CONFIGURABLE_TLMPACKETIZER_GROUP + 1");
57 }
58 
60 
62  const Svc::TlmPacketizerPacket& ignoreList,
63  const FwChanIdType startLevel) {
64  // Ignore list may be nullptr as long as numEntries is 0. Providing an ignore list with numEntries 0 disables
65  // functionality for two reasons:
66  // 1. There are no ignored channels as configured by FPP.
67  // 2. Ignore functionality is intentionally disabled by project where nullptr was intentionally supplied.
68  FW_ASSERT(ignoreList.list || ignoreList.numEntries == 0);
69  FW_ASSERT(packetList.numEntries <= MAX_PACKETIZER_PACKETS, static_cast<FwAssertArgType>(packetList.numEntries));
70 
71  // Reset key data members incase of reentrant calls
72  this->m_numChannels = 0;
73  this->m_channelIndices.clear();
74  this->m_configured = false;
75 
76  // validate packet sizes against maximum com buffer size and populate hash
77  // table
78  FwChanIdType maxLevel = 0;
79  for (FwChanIdType pktEntry = 0; pktEntry < packetList.numEntries; pktEntry++) {
80  // Initial size is packetized telemetry descriptor + size of time tag + sizeof packet ID
81  FwSizeType packetLen =
83  // A packet with no channels is autocoded with a nullptr list and is permitted
84  FW_ASSERT(packetList.list[pktEntry]->list != nullptr || packetList.list[pktEntry]->numEntries == 0,
85  static_cast<FwAssertArgType>(pktEntry));
86  // add up entries for each defined packet
87  for (FwChanIdType tlmEntry = 0; tlmEntry < packetList.list[pktEntry]->numEntries; tlmEntry++) {
88  FwChanIdType id = packetList.list[pktEntry]->list[tlmEntry].id;
89  const FwSizeType channelSize = packetList.list[pktEntry]->list[tlmEntry].size;
90  FwSizeType entryIndex = 0;
91  if (this->m_channelIndices.find(id, entryIndex) != Fw::Success::SUCCESS) {
92  // New channel - allocate a slot and initialize offsets to NOT_IN_PACKET
93  entryIndex = this->m_numChannels++;
94  this->m_channels[entryIndex].id = id;
95  this->m_channels[entryIndex].hasValue = false;
96  this->m_channels[entryIndex].channelSize = channelSize;
97  for (FwChanIdType pktOffsetEntry = 0; pktOffsetEntry < MAX_PACKETIZER_PACKETS; pktOffsetEntry++) {
98  this->m_channels[entryIndex].packetOffset[pktOffsetEntry] = NOT_IN_PACKET;
99  }
100  const Fw::Success insertStatus = this->m_channelIndices.insert(id, entryIndex);
101  FW_ASSERT(insertStatus == Fw::Success::SUCCESS, static_cast<FwAssertArgType>(insertStatus));
102  } else {
103  // Existing channel - a channel ID may repeat across packets, but its definition (size) must match.
104  // A conflicting size would corrupt the packet offsets computed from the earlier definition and
105  // overflow the fill buffer during TlmRecv/TlmGet copies, so reject the misconfiguration here.
106  FW_ASSERT(this->m_channels[entryIndex].channelSize == channelSize, static_cast<FwAssertArgType>(id),
107  static_cast<FwAssertArgType>(channelSize),
108  static_cast<FwAssertArgType>(this->m_channels[entryIndex].channelSize));
109  }
110  // not ignored channel - update entry in place via reference
111  TlmEntry& entry = this->m_channels[entryIndex];
112  entry.ignored = false;
113  entry.channelSize = channelSize;
114  // the offset into the buffer will be the current packet length
115  // the offset must fit within FwTlmPacketizeOffsetType and must not equal NOT_IN_PACKET
116  FW_ASSERT(packetLen < NOT_IN_PACKET, static_cast<FwAssertArgType>(packetLen));
117  entry.packetOffset[pktEntry] = static_cast<FwTlmPacketizeOffsetType>(packetLen);
118 
119  packetLen += entry.channelSize;
120 
121  } // end channel in packet
122  FW_ASSERT(packetLen <= FW_COM_BUFFER_MAX_SIZE, static_cast<FwAssertArgType>(packetLen),
123  static_cast<FwAssertArgType>(pktEntry));
124  // clear contents
125  (void)memset(this->m_fillBuffers[pktEntry].buffer.getBuffAddr(), 0, static_cast<size_t>(packetLen));
126  // serialize packet descriptor and packet ID now since it will always be the same
127  Fw::SerializeStatus stat = this->m_fillBuffers[pktEntry].buffer.serializeFrom(
128  static_cast<FwPacketDescriptorType>(Fw::ComPacketType::FW_PACKET_PACKETIZED_TLM));
129  FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, stat);
130  stat = this->m_fillBuffers[pktEntry].buffer.serializeFrom(packetList.list[pktEntry]->id);
131  FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, stat);
132  // set packet buffer length
133  stat = this->m_fillBuffers[pktEntry].buffer.setBuffLen(packetLen);
134  FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, stat);
135  // save ID
136  this->m_fillBuffers[pktEntry].id = packetList.list[pktEntry]->id;
137  // save level
138  this->m_fillBuffers[pktEntry].level = packetList.list[pktEntry]->level;
139  // store max level
140  if (packetList.list[pktEntry]->level > maxLevel) {
141  maxLevel = packetList.list[pktEntry]->level;
142  }
143 
144  } // end packet list
145  FW_ASSERT(maxLevel <= MAX_CONFIGURABLE_TLMPACKETIZER_GROUP, static_cast<FwAssertArgType>(maxLevel));
146 
147  // This section adds entries in the map for channels that are intended to be ignored. When the user supplies
148  // a list with no length, this loop is skipped. To turn-off ignoring of channels, the user can provide a null
149  // list with 0 length.
150  for (FwChanIdType channelEntry = 0; channelEntry < ignoreList.numEntries; channelEntry++) {
151  FwChanIdType id = ignoreList.list[channelEntry].id;
152  FwSizeType entryIndex = 0;
153  if (this->m_channelIndices.find(id, entryIndex) != Fw::Success::SUCCESS) {
154  // New channel - allocate a slot and initialize offsets to NOT_IN_PACKET
155  entryIndex = this->m_numChannels++;
156  this->m_channels[entryIndex].id = id;
157  this->m_channels[entryIndex].hasValue = false;
158  for (FwChanIdType pktOffsetEntry = 0; pktOffsetEntry < MAX_PACKETIZER_PACKETS; pktOffsetEntry++) {
159  this->m_channels[entryIndex].packetOffset[pktOffsetEntry] = NOT_IN_PACKET;
160  }
161  const Fw::Success insertStatus = this->m_channelIndices.insert(id, entryIndex);
162  FW_ASSERT(insertStatus == Fw::Success::SUCCESS, static_cast<FwAssertArgType>(insertStatus));
163  } else {
164  // Ensure it is a duplicate in the ignore list, not a duplicate of a valid channel
165  FW_ASSERT(this->m_channels[entryIndex].ignored, static_cast<FwAssertArgType>(id));
166  }
167  // is ignored channel - update entry in place via reference
168  TlmEntry& entry = this->m_channels[entryIndex];
169  entry.ignored = true;
170  entry.channelSize = ignoreList.list[channelEntry].size;
171  } // end ignore list
172 
173  // store number of packets
174  this->m_numPackets = packetList.numEntries;
175 
176  // indicate configured
177  this->m_configured = true;
178 }
179 
180 // ----------------------------------------------------------------------
181 // Handler implementations for user-defined typed input ports
182 // ----------------------------------------------------------------------
183 
184 void TlmPacketizer ::TlmRecv_handler(const FwIndexType portNum,
185  FwChanIdType id,
186  Fw::Time& timeTag,
187  Fw::TlmBuffer& val) {
188  FW_ASSERT(this->m_configured);
189  FwSizeType entryIndex = 0;
190 
191  // Search to see if the channel is being tracked
192  if (this->m_channelIndices.find(id, entryIndex) != Fw::Success::SUCCESS) {
193  // channel not part of a packet and not ignored
194  this->missingChannel(id);
195  return;
196  }
197 
198  TlmEntry& entry = this->m_channels[entryIndex];
199 
200  // check to see if the channel is ignored. If so, just return.
201  if (entry.ignored) {
202  return;
203  }
204 
205  // An update larger than the configured channel size would overrun the packet
206  // fill buffer. Values may arrive from external sources (e.g. a hub bridging
207  // another address space), so reject rather than assert.
208  if (val.getSize() > entry.channelSize) {
209  this->log_WARNING_HI_OversizedChannel(id, val.getSize(), entry.channelSize);
210  return;
211  }
212 
213  // copy telemetry value into active buffers; hasValue written in-place via reference
214  for (FwChanIdType pkt = 0; pkt < MAX_PACKETIZER_PACKETS; pkt++) {
215  // check if current packet has this channel
216  if (entry.packetOffset[pkt] != NOT_IN_PACKET) {
217  // get destination address
218  Os::ScopeLock lock(this->m_lock);
219  this->m_fillBuffers[pkt].updated = true;
220  this->m_fillBuffers[pkt].latestTime = timeTag;
221  U8* ptr = &this->m_fillBuffers[pkt].buffer.getBuffAddr()[entry.packetOffset[pkt]];
222 
223  (void)memcpy(ptr, val.getBuffAddr(), static_cast<size_t>(val.getSize()));
224  // set under the lock, after the copy, so TlmGet cannot see a value-less VALID entry
225  entry.hasValue = true;
226  }
227  }
228 }
229 
230 void TlmPacketizer ::configureSectionGroupRate_handler(FwIndexType portNum,
231  const Svc::TelemetrySection& section,
232  FwChanIdType tlmGroup,
233  const Svc::RateLogic& rateLogic,
234  U32 minDelta,
235  U32 maxDelta) {
236  this->configureSectionGroupRate(section, tlmGroup, rateLogic, minDelta, maxDelta);
237 }
238 
240 Fw::TlmValid TlmPacketizer ::TlmGet_handler(FwIndexType portNum,
241  FwChanIdType id,
242  Fw::Time& timeTag,
243  Fw::TlmBuffer& val
244 ) {
246  FW_ASSERT(this->m_configured);
247  FwSizeType entryIndex = 0;
248 
249  // Search to see if the channel is being tracked
250  if (this->m_channelIndices.find(id, entryIndex) != Fw::Success::SUCCESS) {
251  // channel not part of a packet and not ignored
252  this->missingChannel(id);
253  val.resetSer();
254  return Fw::TlmValid::INVALID;
255  }
256  const TlmEntry& entry = this->m_channels[entryIndex];
257 
258  // check to see if the channel is ignored. If so, just return, as
259  // we don't store the bytes of ignored channels
260  if (entry.ignored) {
261  val.resetSer();
262  return Fw::TlmValid::INVALID;
263  }
264 
265  if (!entry.hasValue) {
266  // haven't received a value yet for this entry.
267  val.resetSer();
268  return Fw::TlmValid::INVALID;
269  }
270 
271  // make sure we have enough space to store this entry in our buf
272  FW_ASSERT(entry.channelSize <= val.getCapacity(), static_cast<FwAssertArgType>(entry.channelSize),
273  static_cast<FwAssertArgType>(val.getCapacity()));
274 
275  // okay, we have the matching entry.
276  // go over each packet and find the first one which stores this channel
277 
278  for (FwChanIdType pkt = 0; pkt < MAX_PACKETIZER_PACKETS; pkt++) {
279  // check if current packet has this channel
280  if (entry.packetOffset[pkt] != NOT_IN_PACKET) {
281  // okay, it has the channel. copy chan val into the tlm buf
282  Os::ScopeLock lock(this->m_lock);
283  timeTag = this->m_fillBuffers[pkt].latestTime;
284  U8* ptr = &this->m_fillBuffers[pkt].buffer.getBuffAddr()[entry.packetOffset[pkt]];
285  (void)memcpy(val.getBuffAddr(), ptr, static_cast<size_t>(entry.channelSize));
286  // set buf len to the channelSize. keep in mind, this is the MAX serialized size of the channel.
287  // so we may actually be filling val with some junk after the value of the channel.
288  const Fw::SerializeStatus setStatus = val.setBuffLen(entry.channelSize);
289  FW_ASSERT(setStatus == Fw::SerializeStatus::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(setStatus));
290  return Fw::TlmValid::VALID;
291  }
292  }
293 
294  // did not find a packet which stores this channel.
295  // coding error, this was not an ignored channel so it must be in a packet somewhere
296  FW_ASSERT(false, static_cast<FwAssertArgType>(entry.id));
297  // TPP (tim paranoia principle)
298  val.resetSer();
299  return Fw::TlmValid::INVALID;
300 }
301 
302 void TlmPacketizer ::Run_handler(const FwIndexType portNum, U32 context) {
303  FW_ASSERT(this->m_configured);
304 
305  for (FwChanIdType pkt = 0; pkt < this->m_numPackets; pkt++) {
306  // Local flags to track which sections require a packet dispatch
307  bool sectionNeedsSend[TelemetrySection::NUM_SECTIONS] = {false};
308  bool anySectionNeedsSend = false;
309 
310  // Lock only to capture the update status and group, and reset the fill buffer flag.
311  bool isNewData = false;
312  FwChanIdType entryGroup = 0;
313  {
314  Os::ScopeLock lock(this->m_lock);
315  isNewData = this->m_fillBuffers[pkt].updated;
316  entryGroup = this->m_fillBuffers[pkt].level;
317  this->m_fillBuffers[pkt].updated = false;
318  }
319 
320  for (FwIndexType section = 0; section < TelemetrySection::NUM_SECTIONS; section++) {
321  PktSendCounters& pktEntryFlags = this->m_packetFlags[static_cast<FwSizeType>(section)][pkt];
322  // Group policy with the packet's overridden fields copied in
323  const Svc::TlmSendConfig effectiveEntryConfig = this->effectiveConfig(section, pkt);
324 
325  // Packet is updated and not REQUESTED (Keep REQUESTED marking to bypass disable checks)
326  if (isNewData && pktEntryFlags.updateFlag != UpdateFlag::REQUESTED) {
327  pktEntryFlags.updateFlag = UpdateFlag::NEW;
328  }
329 
330  /* Base conditions for sending
331  1. Output port is connected
332  2. The packet was requested (Override Checks).
333 
334  If the packet wasn't requested:
335  3. The effective send state allows sending (packet -> group -> section enable)
336  4. The packet has data (marked updated in the past or new)
337  */
338  if (!this->isConnected_PktSend_OutputPort(this->sectionGroupToPort(section, entryGroup))) {
339  continue;
340  }
341 
342  if (pktEntryFlags.updateFlag == UpdateFlag::REQUESTED) {
343  sectionNeedsSend[section] = true;
344  } else {
345  if (not this->sendAllowed(effectiveEntryConfig.get_sendState(), section)) {
346  continue;
347  }
348  if (pktEntryFlags.updateFlag == UpdateFlag::NEVER_UPDATED) {
349  continue; // Avoid No Data
350  }
351  }
352 
353  // Update Counter, prevent overflow.
354  if (pktEntryFlags.prevSentCounter < std::numeric_limits<U32>::max()) {
355  pktEntryFlags.prevSentCounter++;
356  }
357 
358  /*
359  1. Packet has been updated
360  2. Group Logic includes checking MIN
361  3. Packet sent counter at MIN
362  */
363  if (pktEntryFlags.updateFlag == UpdateFlag::NEW and
364  effectiveEntryConfig.get_rates().get_rateLogic() != Svc::RateLogic::EVERY_MAX and
365  pktEntryFlags.prevSentCounter >= effectiveEntryConfig.get_rates().get_min()) {
366  sectionNeedsSend[section] = true;
367  }
368 
369  /*
370  1. Group Logic includes checking MAX
371  2. Packet set counter is at MAX
372  */
373  if (effectiveEntryConfig.get_rates().get_rateLogic() != Svc::RateLogic::ON_CHANGE_MIN and
374  pktEntryFlags.prevSentCounter >= effectiveEntryConfig.get_rates().get_max()) {
375  sectionNeedsSend[section] = true;
376  }
377 
378  if (sectionNeedsSend[section]) {
379  anySectionNeedsSend = true;
380  }
381  }
382 
383  // Only perform the buffer copy if at least one section needs to send.
384  if (anySectionNeedsSend) {
385  // Snapshot only the packet data under the lock
386  Fw::ComBuffer sendBuffer;
387  Fw::Time sendTime;
388  {
389  Os::ScopeLock lock(this->m_lock);
390  sendBuffer = this->m_fillBuffers[pkt].buffer;
391  sendTime = this->m_fillBuffers[pkt].latestTime;
392  }
393 
394  // serialize time into time offset in packet
396  &sendBuffer.getBuffAddr()[sizeof(FwPacketDescriptorType) + sizeof(FwTlmPacketizeIdType)],
398  const Fw::SerializeStatus timeStatus = buff.serializeFrom(sendTime);
399  FW_ASSERT(Fw::FW_SERIALIZE_OK == timeStatus, static_cast<FwAssertArgType>(timeStatus));
400 
401  for (FwIndexType section = 0; section < TelemetrySection::NUM_SECTIONS; section++) {
402  if (sectionNeedsSend[section]) {
403  PktSendCounters& pktEntryFlags = this->m_packetFlags[section][pkt];
404  FwIndexType outIndex = this->sectionGroupToPort(section, entryGroup);
405 
406  this->PktSend_out(outIndex, sendBuffer, pktEntryFlags.prevSentCounter);
407 
408  pktEntryFlags.prevSentCounter = 0;
409  pktEntryFlags.updateFlag = UpdateFlag::PAST;
410  }
411  }
412  }
413  }
414 }
415 
416 void TlmPacketizer ::controlIn_handler(FwIndexType portNum,
417  const Svc::TelemetrySection& section,
418  const Fw::Enabled& enabled) {
419  // NUM_SECTIONS is an enum constant (not a standalone constant), so isValid() accepts it.
420  // The explicit bounds check prevents an out-of-bounds write to m_sectionEnabled.
421  if (section.isValid() && section < TelemetrySection::NUM_SECTIONS && enabled.isValid()) {
422  (void)(this->m_sectionEnabled[static_cast<FwSizeType>(section)] = enabled);
423  } else {
424  this->log_WARNING_LO_SectionUnconfigurable(section, enabled);
425  }
426 }
427 
428 void TlmPacketizer ::pingIn_handler(const FwIndexType portNum, U32 key) {
429  // return key
430  this->pingOut_out(0, key);
431 }
432 
433 // ----------------------------------------------------------------------
434 // Command handler implementations
435 // ----------------------------------------------------------------------
436 
437 void TlmPacketizer ::SET_LEVEL_cmdHandler(const FwOpcodeType opCode, const U32 cmdSeq, FwChanIdType level) {
440  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
441  return;
442  }
443  for (FwIndexType section = 0; section < TelemetrySection::NUM_SECTIONS; section++) {
444  for (FwChanIdType group = 0; group < NUM_CONFIGURABLE_TLMPACKETIZER_GROUPS; group++) {
445  this->m_groupConfigs[static_cast<FwSizeType>(section)][group].set_sendState(
447  }
448  }
449  this->tlmWrite_GroupConfigs(this->m_groupConfigs);
450  this->log_ACTIVITY_HI_LevelSet(level);
451  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
452 }
453 
454 void TlmPacketizer ::SEND_PKT_cmdHandler(const FwOpcodeType opCode,
455  const U32 cmdSeq,
456  const U32 id,
457  const Svc::TelemetrySection& section) {
458  FwChanIdType pkt = 0;
459  if (this->resolvePacket(section, id, pkt) != PacketStatus::OK) {
460  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
461  return;
462  }
463 
464  {
465  Os::ScopeLock lock(this->m_lock);
466  this->m_fillBuffers[pkt].updated = true;
467  this->m_fillBuffers[pkt].latestTime = this->getTime();
468  }
469 
470  this->m_packetFlags[section][pkt].updateFlag = UpdateFlag::REQUESTED;
471 
472  this->log_ACTIVITY_HI_PacketSent(id);
473  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
474 }
475 
476 void TlmPacketizer ::ENABLE_SECTION_cmdHandler(FwOpcodeType opCode,
477  U32 cmdSeq,
478  const Svc::TelemetrySection& section,
479  const Fw::Enabled& enable) {
480  FW_ASSERT(section.isValid());
481  FW_ASSERT(enable.isValid());
482  if (section < 0 or section >= TelemetrySection::NUM_SECTIONS) {
483  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
484  return;
485  }
486  (void)(this->m_sectionEnabled[section] = enable);
487  this->tlmWrite_SectionEnabled(this->m_sectionEnabled);
488  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
489 }
490 
491 void TlmPacketizer ::CONFIGURE_GROUP_SEND_cmdHandler(FwOpcodeType opCode,
492  U32 cmdSeq,
493  const Svc::TelemetrySection& section,
494  FwChanIdType tlmGroup,
495  const Svc::TlmSendState& sendState) {
496  FW_ASSERT(section.isValid());
497  if (section < 0 or section >= TelemetrySection::NUM_SECTIONS or tlmGroup > MAX_CONFIGURABLE_TLMPACKETIZER_GROUP) {
498  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
499  return;
500  }
501  this->m_groupConfigs[section][tlmGroup].set_sendState(sendState);
502  this->tlmWrite_GroupConfigs(this->m_groupConfigs);
503  this->log_ACTIVITY_HI_GroupSendStateSet(section, tlmGroup, sendState);
504  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
505 }
506 
507 void TlmPacketizer ::CONFIGURE_GROUP_RATES_cmdHandler(FwOpcodeType opCode,
508  U32 cmdSeq,
509  const Svc::TelemetrySection& section,
510  FwChanIdType tlmGroup,
511  const Svc::RateLogic& rateLogic,
512  U32 minDelta,
513  U32 maxDelta) {
514  FW_ASSERT(section.isValid());
515  FW_ASSERT(rateLogic.isValid());
516  if (section < 0 or section >= TelemetrySection::NUM_SECTIONS or tlmGroup > MAX_CONFIGURABLE_TLMPACKETIZER_GROUP) {
517  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::VALIDATION_ERROR);
518  return;
519  }
520  this->configureSectionGroupRate(section, tlmGroup, rateLogic, minDelta, maxDelta);
521  this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
522 }
523 
524 void TlmPacketizer ::GET_PACKET_CONFIG_cmdHandler(FwOpcodeType opCode,
525  U32 cmdSeq,
526  const Svc::TelemetrySection& section,
527  U32 packetId) {
528  FwChanIdType pkt = 0;
529  const PacketStatus status = this->resolvePacket(section, packetId, pkt);
530  if (status == PacketStatus::OK) {
531  const FwSizeType sectionIndex = static_cast<FwSizeType>(section.e);
532  this->log_ACTIVITY_HI_PacketConfigReport(section, packetId, this->m_packetOverrides[sectionIndex][pkt],
533  this->effectiveConfig(static_cast<FwIndexType>(section.e), pkt));
534  }
535  this->cmdResponse_out(opCode, cmdSeq, TlmPacketizer::toCmdResponse(status));
536 }
537 
538 void TlmPacketizer ::OVERRIDE_PACKET_SEND_cmdHandler(FwOpcodeType opCode,
539  U32 cmdSeq,
540  const Svc::TelemetrySection& section,
541  U32 packetId,
542  const Svc::TlmSendState& sendState) {
544  Svc::TlmSendConfig(sendState, Svc::RateConfig()));
545  this->cmdResponse_out(opCode, cmdSeq,
546  TlmPacketizer::toCmdResponse(this->overridePacket(section, packetId, requested)));
547 }
548 
549 void TlmPacketizer ::OVERRIDE_PACKET_RATES_cmdHandler(FwOpcodeType opCode,
550  U32 cmdSeq,
551  const Svc::TelemetrySection& section,
552  U32 packetId,
553  const Svc::RateLogic& rateLogic,
554  U32 minDelta,
555  U32 maxDelta) {
556  const Svc::PacketOverrideConfig requested(
559  this->cmdResponse_out(opCode, cmdSeq,
560  TlmPacketizer::toCmdResponse(this->overridePacket(section, packetId, requested)));
561 }
562 
563 void TlmPacketizer ::CLEAR_PACKET_OVERRIDE_cmdHandler(FwOpcodeType opCode,
564  U32 cmdSeq,
565  const Svc::TelemetrySection& section,
566  U32 packetId) {
568  this->cmdResponse_out(opCode, cmdSeq,
569  TlmPacketizer::toCmdResponse(this->overridePacket(section, packetId, requested)));
570 }
571 
572 void TlmPacketizer::configureSectionGroupRate(
573  const Svc::TelemetrySection& section,
574  FwChanIdType tlmGroup,
575  const Svc::RateLogic& rateLogic,
576  U32 minDelta,
577  U32 maxDelta
578 ) {
579  FW_ASSERT(section.isValid());
580  FW_ASSERT(rateLogic.isValid());
581  // These two asserts are an "if" statement in a command so they will no assert on bad user data
582  FW_ASSERT(section >= 0 and section < TelemetrySection::NUM_SECTIONS);
584 
585  this->m_groupConfigs[section][tlmGroup].set_rates(Svc::RateConfig(rateLogic, minDelta, maxDelta));
586  this->tlmWrite_GroupConfigs(this->m_groupConfigs);
587 }
588 
589 FwIndexType TlmPacketizer::sectionGroupToPort(const FwIndexType section, const FwSizeType group) {
590  // Confirm the indices will not overflow the size of the array
591  FW_ASSERT(group < TlmPacketizer_TelemetrySendSection::SIZE, static_cast<FwAssertArgType>(group));
592  FW_ASSERT(section < TlmPacketizer_TelemetrySendPortMap::SIZE, static_cast<FwAssertArgType>(section));
593 
594  const FwIndexType outIndex = TlmPacketizer::TELEMETRY_SEND_PORT_MAP[static_cast<FwSizeType>(section)][group];
595 
596  // Confirm the output port index is within the valid number of telemetry send ports
597  FW_ASSERT(outIndex < TELEMETRY_SEND_PORTS, static_cast<FwAssertArgType>(outIndex));
598  return outIndex;
599 }
600 
601 Fw::CmdResponse TlmPacketizer::toCmdResponse(PacketStatus status) {
602  switch (status) {
603  case PacketStatus::OK:
604  return Fw::CmdResponse::OK;
605  case PacketStatus::MIRROR_FAILED:
607  default:
609  }
610 }
611 
612 Svc::TlmSendConfig TlmPacketizer::effectiveConfig(FwIndexType section, FwChanIdType pkt) const {
613  const FwSizeType sectionIndex = static_cast<FwSizeType>(section);
614  // Start from the group policy, then copy in the fields the packet overrides
615  Svc::TlmSendConfig effective = this->m_groupConfigs[sectionIndex][this->m_fillBuffers[pkt].level];
616  const Svc::PacketOverrideConfig& packetOverride = this->m_packetOverrides[sectionIndex][pkt];
617  const Svc::PacketOverrideType overrideType = packetOverride.get_overrideType();
618  const bool overridesSend = (overrideType == Svc::PacketOverrideType::OVERRIDE_SEND) or
620  const bool overridesRates = (overrideType == Svc::PacketOverrideType::OVERRIDE_RATES) or
622  // A packet-level INHERIT_FROM_PARENT means "use the group's state", so it is not copied
623  if (overridesSend and packetOverride.get_sendConfig().get_sendState() != Svc::TlmSendState::INHERIT_FROM_PARENT) {
624  effective.set_sendState(packetOverride.get_sendConfig().get_sendState());
625  }
626  if (overridesRates) {
627  effective.set_rates(packetOverride.get_sendConfig().get_rates());
628  }
629  return effective;
630 }
631 
632 bool TlmPacketizer::sendAllowed(const Svc::TlmSendState& sendState, FwIndexType section) const {
633  switch (sendState.e) {
635  return true;
637  return false;
638  // INHERIT_FROM_PARENT here is a group-level state, whose parent is the section. Fall-through intended.
641  return this->m_sectionEnabled[static_cast<FwSizeType>(section)] == Fw::Enabled::ENABLED;
642  default:
643  FW_ASSERT(0, static_cast<FwAssertArgType>(sendState.e));
644  return false;
645  }
646 }
647 
648 Fw::Success TlmPacketizer::findPacketIndexById(U32 packetId, FwChanIdType& pkt) const {
649  for (FwChanIdType p = 0; p < this->m_numPackets; p++) {
650  if (this->m_fillBuffers[p].id == packetId) {
651  pkt = p;
652  return Fw::Success::SUCCESS;
653  }
654  }
655  return Fw::Success::FAILURE;
656 }
657 
658 TlmPacketizer::PacketStatus TlmPacketizer::resolvePacket(const Svc::TelemetrySection& section,
659  U32 packetId,
660  FwChanIdType& pkt) {
661  if (not section.isValid() or section < 0 or section >= TelemetrySection::NUM_SECTIONS) {
662  this->log_WARNING_LO_InvalidPacketConfig(packetId);
663  return PacketStatus::INVALID_SECTION;
664  }
665  if (this->findPacketIndexById(packetId, pkt) != Fw::Success::SUCCESS) {
666  this->log_WARNING_LO_PacketNotFound(packetId);
667  return PacketStatus::UNKNOWN_PACKET;
668  }
669  return PacketStatus::OK;
670 }
671 
672 Svc::PacketOverrideType TlmPacketizer::mergeOverrideType(const Svc::PacketOverrideType& current,
673  const Svc::PacketOverrideType& requested) {
674  if (current == Svc::PacketOverrideType::GROUP_DEFAULT or current == requested) {
675  return requested;
676  }
677  // Different fields already overridden: both apply
679 }
680 
681 TlmPacketizer::PacketStatus TlmPacketizer::applyPacketOverride(const Svc::TelemetrySection& section,
682  FwChanIdType pkt,
683  const Svc::PacketOverrideConfig& requested) {
684  Svc::PacketOverrideConfig& stored = this->m_packetOverrides[static_cast<FwSizeType>(section.e)][pkt];
685  // Snapshot so a failed mirror can roll back and the persisted copy never diverges
686  const Svc::PacketOverrideConfig previous = stored;
687  // Fields not (yet) overridden hold neutral values: INHERIT_FROM_PARENT and default rates
688  Svc::TlmSendConfig merged = (previous.get_overrideType() == Svc::PacketOverrideType::GROUP_DEFAULT)
690  : stored.get_sendConfig();
691  switch (requested.get_overrideType()) {
693  merged.set_sendState(requested.get_sendConfig().get_sendState());
694  break;
696  merged.set_rates(requested.get_sendConfig().get_rates());
697  break;
699  merged = requested.get_sendConfig();
700  break;
701  default:
702  // GROUP_DEFAULT: clearing keeps no policy of its own
703  merged = Svc::TlmSendConfig();
704  break;
705  }
706  stored.set_sendConfig(merged);
707  stored.set_overrideType(
710  : TlmPacketizer::mergeOverrideType(previous.get_overrideType(), requested.get_overrideType()));
711  if (this->mirrorOverride(section, pkt) != Fw::Success::SUCCESS) {
712  stored = previous;
713  return PacketStatus::MIRROR_FAILED;
714  }
715  return PacketStatus::OK;
716 }
717 
718 TlmPacketizer::PacketStatus TlmPacketizer::overridePacket(const Svc::TelemetrySection& section,
719  U32 packetId,
720  const Svc::PacketOverrideConfig& requested) {
721  FwChanIdType pkt = 0;
722  PacketStatus status = this->resolvePacket(section, packetId, pkt);
723  if (status != PacketStatus::OK) {
724  return status;
725  }
726  status = this->applyPacketOverride(section, pkt, requested);
727  if (status != PacketStatus::OK) {
728  return status;
729  }
731  this->log_ACTIVITY_HI_PacketOverrideCleared(section, packetId);
732  } else {
733  this->log_ACTIVITY_HI_PacketOverrideSet(section, packetId,
734  this->m_packetOverrides[static_cast<FwSizeType>(section.e)][pkt]);
735  }
736  return PacketStatus::OK;
737 }
738 
739 void TlmPacketizer ::packetOverrideIn_handler(FwIndexType portNum, Fw::Buffer& fwBuffer) {
740  // Reload per-packet overrides from the persistence component: one PacketConfigEntry record after another
741  if (fwBuffer.isValid()) {
742  auto deserializer = fwBuffer.getDeserializer();
743  const FwSizeType recordSize = static_cast<FwSizeType>(Svc::PacketConfigEntry::SERIALIZED_SIZE);
744  const FwSizeType maxRecords = static_cast<FwSizeType>(fwBuffer.getSize()) / recordSize;
746  for (FwSizeType record = 0; (record < maxRecords) and (status == Fw::FW_SERIALIZE_OK); record++) {
748  status = deserializer.deserializeTo(entry);
749  if (status != Fw::FW_SERIALIZE_OK) {
750  break;
751  }
752  const Svc::TelemetrySection section = entry.get_section();
753  FwChanIdType pkt = 0;
754  // Enum values were validated by deserialization; only the section range remains to check
755  if (section < 0 or section >= TelemetrySection::NUM_SECTIONS) {
757  } else if (this->findPacketIndexById(entry.get_packetId(), pkt) != Fw::Success::SUCCESS) {
759  } else {
760  this->m_packetOverrides[static_cast<FwSizeType>(section.e)][pkt] = entry.get_override();
761  }
762  }
763  // Trailing bytes that do not form a whole record are a malformed buffer
764  if ((status == Fw::FW_SERIALIZE_OK) and (deserializer.getDeserializeSizeLeft() != 0)) {
766  }
767  if (status != Fw::FW_SERIALIZE_OK) {
768  Fw::DeserialStatus reported(static_cast<Fw::DeserialStatus::T>(status));
769  if (not reported.isValid()) {
771  }
772  this->log_WARNING_HI_ConfigReloadFailed(reported);
773  }
774  } else {
776  }
777  this->packetOverrideReturnOut_out(0, fwBuffer);
778 }
779 
780 void TlmPacketizer ::packetOverrideReturnIn_handler(FwIndexType portNum, Fw::Buffer& fwBuffer) {
781  // Mirror buffers come from allocate and go back to the same pool; the SDD requires the whole
782  // mirror path (packetOverrideOut, allocate, deallocate, packetOverrideReturnIn) wired or none of it
784  this->deallocate_out(0, fwBuffer);
785 }
786 
787 Fw::Success TlmPacketizer::mirrorOverride(const Svc::TelemetrySection& section, FwChanIdType pkt) {
788  // persistent storage component should mirror this state; skip if not wired
789  if (not this->isConnected_packetOverrideOut_OutputPort(0)) {
790  return Fw::Success::SUCCESS;
791  }
792  // A mirror port without an allocator cannot persist anything, and without a deallocator the returned
793  // mirror buffers could never be freed; the SDD requires the whole mirror path wired or none of it
796  const FwSizeType sectionIndex = static_cast<FwSizeType>(section.e);
797  const Svc::PacketConfigEntry entry(static_cast<U32>(this->m_fillBuffers[pkt].id), section,
798  this->m_packetOverrides[sectionIndex][pkt]);
799  const FwSizeType entrySize = static_cast<FwSizeType>(Svc::PacketConfigEntry::SERIALIZED_SIZE);
800  Fw::Buffer buffer = this->allocate_out(0, entrySize);
801  if (not buffer.isValid()) {
803  return Fw::Success::FAILURE;
804  }
805  // Fw.BufferGet contract: a valid buffer is at least the requested size
806  FW_ASSERT(static_cast<FwSizeType>(buffer.getSize()) >= entrySize, static_cast<FwAssertArgType>(buffer.getSize()));
807  auto serializer = buffer.getSerializer();
808  const Fw::SerializeStatus status = serializer.serializeFrom(entry);
809  FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
810  buffer.setSize(static_cast<Fw::Buffer::SizeType>(entrySize));
811  this->packetOverrideOut_out(0, buffer);
812  return Fw::Success::SUCCESS;
813 }
814 
815 void TlmPacketizer::missingChannel(FwChanIdType id) {
816  // search to see if missing channel has already been sent
817  for (FwChanIdType slot = 0; slot < TLMPACKETIZER_MAX_MISSING_TLM_CHECK; slot++) {
818  // if it's been checked, return
819  if (this->m_missTlmCheck[slot].checked and (this->m_missTlmCheck[slot].id == id)) {
820  return;
821  } else if (not this->m_missTlmCheck[slot].checked) {
822  this->m_missTlmCheck[slot].checked = true;
823  this->m_missTlmCheck[slot].id = id;
824  this->log_WARNING_LO_NoChan(id);
825  return;
826  }
827  }
828 }
829 
830 Fw::SerializeStatus TlmPacketizer::deserializeParam(const FwPrmIdType base_id,
831  const FwPrmIdType local_id,
832  const Fw::ParamValid prmStat,
833  Fw::SerialBufferBase& buff) {
834  if (FW_PARAM_OK(prmStat)) {
835  switch (local_id) {
836  // A stored value of a different shape (e.g. saved by a previous FSW load) must not load as a scrambled
837  // table
840  Fw::SerializeStatus status = buff.deserializeTo(loaded);
841  if ((status == Fw::FW_SERIALIZE_OK) and (buff.getDeserializeSizeLeft() != 0)) {
843  }
844  if (status == Fw::FW_SERIALIZE_OK) {
845  this->m_sectionEnabled = loaded;
846  }
847  return status;
848  }
851  Fw::SerializeStatus status = buff.deserializeTo(loaded);
852  if ((status == Fw::FW_SERIALIZE_OK) and (buff.getDeserializeSizeLeft() != 0)) {
854  }
855  if (status == Fw::FW_SERIALIZE_OK) {
856  this->m_groupConfigs = loaded;
857  }
858  return status;
859  }
860  default:
861  FW_ASSERT(false, static_cast<FwAssertArgType>(local_id));
862  }
863  }
865 }
866 
867 Fw::SerializeStatus TlmPacketizer::serializeParam(const FwPrmIdType base_id,
868  const FwPrmIdType local_id,
869  Fw::SerialBufferBase& buff) const {
870  switch (local_id) {
872  return buff.serializeFrom(this->m_sectionEnabled);
874  return buff.serializeFrom(this->m_groupConfigs);
875  default:
876  FW_ASSERT(false, static_cast<FwAssertArgType>(local_id));
877  }
879 }
880 
881 } // end namespace Svc
bool isConnected_PktSend_OutputPort(FwIndexType portNum) const
Serialization/Deserialization operation was successful.
bool isValid() const
Check raw enum value for validity.
U16 FwPacketDescriptorType
The width of packet descriptors when they are serialized by the framework.
bool isConnected_packetOverrideOut_OutputPort(FwIndexType portNum) const
TlmPacketizer(const char *const compName)
void set_sendState(Svc::TlmSendState::T sendState)
Set member sendState.
REQUIRED: Counter, leave as last element.
FwIdType FwOpcodeType
The type of a command opcode.
Deserialized type ID didn&#39;t match.
Deserialization buffer was empty when trying to read more data.
#define FW_PARAM_OK(paramValid)
Definition: ParamValid.hpp:22
Representing success.
FwSizeType size
serialized size of channel in bytes
PlatformSizeType FwSizeType
FwTlmPacketizeIdType id
packet ID
void tlmWrite_GroupConfigs(const Svc::TlmPacketizer_SectionConfigs &arg, Fw::Time _tlmTime=Fw::Time()) const
Deserialization buffer was empty when trying to read data.
void setSize(FwSizeType size)
Definition: Buffer.cpp:131
Send policy of a group or packet. Resolution: packet -> group -> section enable.
Enabled state.
void log_ACTIVITY_HI_LevelSet(FwChanIdType level) const
Telemetry send policy (send state + rates), shared by the per-group config and per-packet override...
void log_ACTIVITY_HI_GroupSendStateSet(const Svc::TelemetrySection &section, FwChanIdType tlmGroup, const Svc::TlmSendState &sendState) const
void set_rates(const Svc::RateConfig &rates)
Set member rates.
Deserialization status.
Serializable::SizeType getSize() const override
Get current buffer size.
FwIdType FwPrmIdType
The type of a parameter identifier.
const TlmPacketizerPacket * list[MAX_PACKETIZER_PACKETS]
void log_WARNING_LO_NoChan(FwChanIdType Id) const
void log_ACTIVITY_HI_PacketSent(U32 packetId) const
A single per-packet override record: mirrored on packetOverrideOut, reloaded from packetOverrideIn...
bool isConnected_allocate_OutputPort(FwIndexType portNum) const
bool isValid() const
Check raw enum value for validity.
Per-packet override: which fields apply and their values.
void log_ACTIVITY_HI_PacketOverrideCleared(const Svc::TelemetrySection &section, U32 packetId) const
Deserialization data had incorrect values (unexpected data types)
void log_WARNING_LO_ReloadRecordInvalid(U32 packetId) const
Deserialization data had incorrect values (unexpected data types)
void cmdResponse_out(FwOpcodeType opCode, U32 cmdSeq, Fw::CmdResponse response)
Emit command response.
Enum representing a command response.
SerializeStatus serializeFrom(U8 val, Endianness mode=Endianness::BIG) override
Serialize an 8-bit unsigned integer value.
void log_ACTIVITY_HI_PacketOverrideSet(const Svc::TelemetrySection &section, U32 packetId, const Svc::PacketOverrideConfig &override) const
Send on updates after MIN ticks since last send.
virtual SerializeStatus serializeFrom(U8 val, Endianness mode=Endianness::BIG)=0
Serialize an 8-bit unsigned integer value.
Success find(const K &key, V &value) const override
Serializable::SizeType getCapacity() const override
Get buffer capacity.
Send every MAX ticks between sends.
const TlmPacketizerChannelEntry * list
pointer to a channel entry
void log_WARNING_LO_PacketNotFound(U32 packetId) const
void log_WARNING_LO_InvalidPacketConfig(U32 packetId) const
static const FwChanIdType TLMPACKETIZER_MAX_MISSING_TLM_CHECK
Maximum number of missing channels to track and report.
void tlmWrite_SectionEnabled(const Svc::TlmPacketizer_SectionEnabled &arg, Fw::Time _tlmTime=Fw::Time()) const
Write telemetry channel SectionEnabled.
Svc::RateConfig & get_rates()
Get member rates.
Svc::TlmSendState::T get_sendState() const
Get member sendState.
SerializeStatus
forward declaration for string
void registerExternalParameters(Fw::ParamExternalDelegate *paramExternalDelegatePtr)
Initialize the external parameter delegate.
virtual SerializeStatus deserializeTo(U8 &val, Endianness mode=Endianness::BIG)=0
Deserialize an 8-bit unsigned integer value.
U16 FwTlmPacketizeOffsetType
bool isConnected_deallocate_OutputPort(FwIndexType portNum) const
FwChanIdType id
Id of channel.
ExternalSerializeBufferWithMemberCopy getDeserializer()
Definition: Buffer.cpp:165
Svc::PacketOverrideType::T get_overrideType() const
Get member overrideType.
FwChanIdType level
packet level - used to select set of packets to send
The rates are overridden; the send state follows the group.
Data was the wrong format (e.g. wrong packet type)
Which fields of a packet&#39;s config override its group.
void log_WARNING_LO_SectionUnconfigurable(const Svc::TelemetrySection &section, const Fw::Enabled &enable) const
Log event SectionUnconfigurable.
U8 * getBuffAddr()
Get buffer address for data filling (non-const version)
Svc::TlmSendConfig & get_sendConfig()
Get member sendConfig.
Enumeration for rate logic types for telemetry groups.
Packet: use the group&#39;s state; group: use the section enable (default)
bool isValid() const
Definition: Buffer.cpp:78
void deallocate_out(FwIndexType portNum, Fw::Buffer &fwBuffer) const
Invoke output port deallocate.
void set_sendConfig(const Svc::TlmSendConfig &sendConfig)
Set member sendConfig.
Data was left in the buffer, but not enough to deserialize.
External serialize buffer with no copy semantics.
Data was left in in the buffer, but not enough to deserialize.
FwIdType FwChanIdType
The type of a telemetry channel identifier.
void resetSer() override
Reset serialization pointer to beginning of buffer.
Fw::Buffer allocate_out(FwIndexType portNum, FwSizeType size) const
Invoke output port allocate.
Send only while the section is enabled.
Deserialized type ID didn&#39;t match.
Representing failure.
void log_WARNING_HI_ConfigReloadFailed(const Fw::DeserialStatus &status) const
Enabled and disabled states.
U16 FwTlmPacketizeIdType
The type of a telemetry packet identifier.
Command successfully executed.
void clear() override
Clear the map.
void setPacketList(const TlmPacketizerPacketList &packetList, const Svc::TlmPacketizerPacket &ignoreList, const FwChanIdType startLevel)
virtual Serializable::SizeType getDeserializeSizeLeft() const =0
Get remaining deserialization buffer size.
bool isValid() const
Check raw enum value for validity.
uint8_t U8
8-bit unsigned integer
Definition: BasicTypes.h:54
enum T e
The raw enum value.
SerializeStatus setBuffLen(Serializable::SizeType length) override
Set buffer length manually.
enum T e
The raw enum value.
FwSizeType getSize() const
Definition: Buffer.cpp:90
void log_ACTIVITY_HI_PacketConfigReport(const Svc::TelemetrySection &section, U32 packetId, const Svc::PacketOverrideConfig &override, const Svc::TlmSendConfig &effective) const
Command had execution error.
void PktSend_out(FwIndexType portNum, Fw::ComBuffer &data, U32 context) const
Invoke output port PktSend.
void log_WARNING_LO_MaxLevelExceed(FwChanIdType level, FwChanIdType max) const
void log_WARNING_LO_ReloadRecordUnknownPacket(U32 packetId) const
PlatformIndexType FwIndexType
Svc::TelemetrySection::T get_section() const
Get member section.
locks a mutex within the current scope
void packetOverrideOut_out(FwIndexType portNum, Fw::Buffer &fwBuffer) const
Invoke output port packetOverrideOut.
void set_overrideType(Svc::PacketOverrideType::T overrideType)
Set member overrideType.
void log_WARNING_HI_OversizedChannel(FwChanIdType Id, FwSizeType valSize, FwSizeType expected)
Command failed validation.
RateGroupDivider component implementation.
No override: the packet follows its group.
void packetOverrideReturnOut_out(FwIndexType portNum, Fw::Buffer &fwBuffer) const
Invoke output port packetOverrideReturnOut.
Enum representing parameter validity.
U32 get_packetId() const
Get member packetId.
Svc::PacketOverrideConfig & get_override()
Get member override.
FwChanIdType numEntries
number of channels in packet
void pingOut_out(FwIndexType portNum, U32 key) const
Invoke output port pingOut.
Success insert(const K &key, const V &value) override
The send state is overridden; rates follow the group.
ExternalSerializeBufferWithMemberCopy getSerializer()
Definition: Buffer.cpp:155
The size of the serial representation.
#define FW_ASSERT(...)
Definition: Assert.hpp:14
Success/Failure.
Both the send state and the rates are overridden.
PlatformAssertArgType FwAssertArgType
The type of arguments to assert functions.
Auto-generated base for TlmPacketizer component.
Send; the section enable is ignored.