Add packetized telemetry option (#1776)

* manual packet gen

* Added tlmPkt to deployment

* Packet files

* Fixes to packet gen script

* format python, updated packet files

* spelling fixes

* integrating packet autocoder

* final updates for telemetry packetization

* formatting telemetry packetizer cpde

* moving tlm packetizer configuration file

* resetting stock telemetry channelizer

* missed packetizer setup call

* fixing autocoding miss-match with Svc::TlmChan

Co-authored-by: M Starch <LeStarch@googlemail.com>

.gitignore

@@ -82,3 +82,5 @@ depend
 
 /.idea/
 /venv/
+
+Packet-Views

Autocoders/Python/bin/tlm_packet_gen.py

@@ -114,6 +114,8 @@ namespace ${packet_list_namespace} {
 PRINT = logging.getLogger("output")
 DEBUG = logging.getLogger("debug")
 
+PACKET_VIEW_DIR = "./Packet-Views"
+
 
 class TlmPacketParseValueError(ValueError):
     pass
@@ -136,8 +138,8 @@ class TlmPacketParser(object):
     def get_type_size(self, type_name, size):
 
         # switch based on type
-        if type == "string":
+        if type_name == "string":
-            return size
+            return int(size) + 2  # plus 2 to store the string length
         elif type_name == "I8":
             return 1
         elif type_name == "I16":
@@ -163,28 +165,6 @@ class TlmPacketParser(object):
         else:
             return None
 
-    #    def search_for_file(self,file_type, file_path):
-    #        '''
-    #        Searches for a given included port or serializable by looking in three places:
-    #        - The specified BUILD_ROOT
-    #        - The F Prime core
-    #        - The exact specified path
-    #        @param file_type: type of file searched for
-    #        @param file_path: path to look for based on offset
-    #        @return: full path of file
-    #        '''
-    #        core = os.environ.get("FPRIME_CORE_DIR", BUILD_ROOT)
-    #        for possible in [BUILD_ROOT, core, None]:
-    #            if not possible is None:
-    #                checker = os.path.join(possible, file_path)
-    #            else:
-    #                checker = file_path
-    #            if os.path.exists(checker):
-    #                DEBUG.debug("%s xml type description file: %s" % (file_type,file_path))
-    #                return checker
-    #        else:
-    #            return None
-
     def generate_channel_size_dict(self, the_parsed_topology_xml, xml_filename):
         """
         Generates GDS XML dictionary from parsed topology XML
@@ -224,7 +204,7 @@ class TlmPacketParser(object):
 
         for comp in the_parsed_topology_xml.get_instances():
             comp_name = comp.get_name()
-            comp_id = int(comp.get_base_id())
+            comp_id = int(comp.get_base_id(), 0)
             comp_type = comp.get_type()
             if self.verbose:
                 PRINT.debug("Processing %s" % comp_name)
@@ -246,6 +226,9 @@ class TlmPacketParser(object):
                     # if channel is enum
                     if type(chan_type) == type(tuple()):
                         chan_size = 4
+                    # if channel type is string
+                    #                    elif chan_type == "string":
+                    #                        chan_size = int(chan.get_size()) + 2 # FIXME: buffer size storage size magic number - needs to be turned into a constant
                     # if channel is serializable
                     elif chan_type in self.size_dict:
                         chan_size = self.size_dict[chan_type]
@@ -266,7 +249,7 @@ class TlmPacketParser(object):
 
     def gen_packet_file(self, xml_filename):
 
-        view_path = "./Views"
+        view_path = PACKET_VIEW_DIR
 
         if not os.path.exists(view_path):
             os.mkdir(view_path)
@@ -275,11 +258,6 @@ class TlmPacketParser(object):
         if not os.path.isfile(xml_filename):
             raise TlmPacketParseIOError("File %s does not exist!" % xml_filename)
 
-        if not "PacketsAi" in xml_filename:
-            raise IOError(
-                "ERROR: Missing PacketsAi at end of file name %s" % xml_filename
-            )
-
         fd = open(xml_filename, "r")
         xml_parser = etree.XMLParser(remove_comments=True)
         element_tree = etree.parse(fd, parser=xml_parser)
@@ -315,12 +293,12 @@ class TlmPacketParser(object):
             ht.num_packets = 0
             total_packet_size = 0
             levels = []
-            view_path = "./Views"
+            view_path = PACKET_VIEW_DIR
             # find the topology import
             for entry in element_tree.getroot():
                 # read in topology file
                 if entry.tag == "import_topology":
-                    top_file = search_for_file("Packet", entry.text)
+                    top_file = search_for_file("Topology", entry.text)
                     if top_file is None:
                         raise TlmPacketParseIOError(
                             "import file %s not found" % entry.text
@@ -424,12 +402,9 @@ class TlmPacketParser(object):
                 "Invalid xml type %s" % element_tree.getroot().tag
             )
 
-        output_file_base = os.path.splitext(os.path.basename(xml_filename))[0].replace(
+        output_file_base = os.path.splitext(os.path.basename(xml_filename))[0]
-            "Ai", ""
+        nearest_build_root = get_nearest_build_root(xml_filename)
-        )
+        file_dir = os.path.relpath(os.path.dirname(xml_filename), nearest_build_root)
-        file_dir = os.path.dirname(xml_filename).replace(
-            get_nearest_build_root(xml_filename) + os.sep, ""
-        )
 
         missing_channels = False
 
@@ -499,6 +474,7 @@ class TlmPacketParser(object):
             for (
                 member_name,
                 member_type,
+                member_array_size,
                 member_size,
                 member_format_specifier,
                 member_comment,
@@ -520,6 +496,8 @@ class TlmPacketParser(object):
                     )
                     sys.exit(-1)
                 serializable_size += type_size
+                if member_array_size != None:
+                    serializable_size *= member_array_size
             self.add_type_size(serializable_type, serializable_size)
             if self.verbose:
                 print(
@@ -616,7 +594,7 @@ def main():
         print(f"Usage: {sys.argv[0]} [options] xml_filename")
         return
     elif len(args) == 1:
-        xml_filename = args[0]
+        xml_filename = os.path.abspath(args[0])
     else:
         print("ERROR: Too many filenames, should only have one")
         return

Autocoders/Python/bin/tlm_packet_gen.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/bash
+
+script_dir=$(dirname $0)
+
+# $0 = this script
+# $1 = packet file
+# $2 = deployment build cache (ex. Ref/build-fprime-automatic-native)
+
+export PYTHONPATH=$script_dir/../src
+export BUILD_ROOT=$script_dir/../../../:$2:$2/F-Prime
+echo "BUILD_ROOT=$BUILD_ROOT"
+
+# get python from the path
+python3 $script_dir/tlm_packet_gen.py $1

Autocoders/Python/src/fprime_ac/parsers/XmlSerializeParser.py

@@ -320,6 +320,6 @@ class XmlSerializeParser:
 
     def get_members(self):
         """
-        Returns a list of member (name, type, optional size, optional format, optional comment) needed.
+        Returns a list of member (name, type, optional array size, optional size, optional format, optional comment) needed.
         """
         return self.__members

Autocoders/Python/src/fprime_ac/utils/buildroot.py

@@ -41,6 +41,7 @@ def get_nearest_build_root(path):
     :param path: path to find nearest build root to
     :return: nearest build root
     """
+    path = os.path.abspath(path)
     parents = filter(
         lambda build: os.path.commonpath([build, path]) == build, get_build_roots()
     )

Ref/Top/CMakeLists.txt

@@ -7,6 +7,7 @@
 
 set(SOURCE_FILES
   "${CMAKE_CURRENT_LIST_DIR}/instances.fpp"
+  "${CMAKE_CURRENT_LIST_DIR}/RefPackets.xml"
   "${CMAKE_CURRENT_LIST_DIR}/topology.fpp"
   "${CMAKE_CURRENT_LIST_DIR}/RefTopology.cpp"
 )

Ref/Top/RefPackets.xml

@@ -18,8 +18,9 @@
         <channel name="fileUplinkBufferManager.HiBuffs"/>
         <channel name="fileDownlink.FilesSent"/>
         <channel name="fileDownlink.PacketsSent"/>
-        <channel name="pktTlm.TPK_SendLevel"/>
         <channel name="fileManager.CommandsExecuted"/>
+        <!-- Uncomment to use Svc::TlmPacketizer -->
+        <!--channel name="tlmSend.SendLevel"/-->
     </packet>
 
     <packet name="CDHErrors" id="2" level="1">
@@ -64,51 +65,83 @@
         <channel name="SG5.Type"/>
     </packet>
 
-    <packet name="SigGen1Info" id="5" level="2">
+    <packet name="SystemRes1" id="5" level="2">
+        <channel name="systemResources.MEMORY_TOTAL"/>
+        <channel name="systemResources.MEMORY_USED"/>
+        <channel name="systemResources.NON_VOLATILE_TOTAL"/>
+        <channel name="systemResources.NON_VOLATILE_FREE"/>
+    </packet>
+
+    <packet name="SystemRes2" id="6" level="2">
+        <channel name="systemResources.FRAMEWORK_VERSION"/>
+        <channel name="systemResources.PROJECT_VERSION"/>
+    </packet>
+
+    <packet name="SystemRes3" id="7" level="2">
+        <channel name="systemResources.CPU"/>
+        <channel name="systemResources.CPU_00"/>
+        <channel name="systemResources.CPU_01"/>
+        <channel name="systemResources.CPU_02"/>
+        <channel name="systemResources.CPU_03"/>
+        <channel name="systemResources.CPU_04"/>
+        <channel name="systemResources.CPU_05"/>
+        <channel name="systemResources.CPU_06"/>
+        <channel name="systemResources.CPU_07"/>
+        <channel name="systemResources.CPU_08"/>
+        <channel name="systemResources.CPU_09"/>
+        <channel name="systemResources.CPU_10"/>
+        <channel name="systemResources.CPU_11"/>
+        <channel name="systemResources.CPU_12"/>
+        <channel name="systemResources.CPU_13"/>
+        <channel name="systemResources.CPU_14"/>
+        <channel name="systemResources.CPU_15"/>
+    </packet>
+
+    <packet name="SigGen1Info" id="10" level="2">
         <channel name="SG1.Info"/>
     </packet>
 
-    <packet name="SigGen2Info" id="6" level="2">
+    <packet name="SigGen2Info" id="11" level="2">
         <channel name="SG2.Info"/>
     </packet>
 
-    <packet name="SigGen3Info" id="7" level="2">
+    <packet name="SigGen3Info" id="12" level="2">
         <channel name="SG3.Info"/>
     </packet>
 
-    <packet name="SigGen4Info" id="8" level="2">
+    <packet name="SigGen4Info" id="13" level="2">
         <channel name="SG4.Info"/>
     </packet>
 
-    <packet name="SigGen5Info" id="9" level="2">
+    <packet name="SigGen5Info" id="14" level="2">
         <channel name="SG5.Info"/>
     </packet>
 
-    <packet name="SigGen1" id="10" level="3">
+    <packet name="SigGen1" id="15" level="3">
         <channel name="SG1.PairOutput"/>
         <channel name="SG1.History"/>
         <channel name="SG1.PairHistory"/>
     </packet>
 
-    <packet name="SigGen2" id="11" level="3">
+    <packet name="SigGen2" id="16" level="3">
         <channel name="SG2.PairOutput"/>
         <channel name="SG2.History"/>
         <channel name="SG2.PairHistory"/>
     </packet>
 
-    <packet name="SigGen3" id="12" level="3">
+    <packet name="SigGen3" id="17" level="3">
         <channel name="SG3.PairOutput"/>
         <channel name="SG3.History"/>
         <channel name="SG3.PairHistory"/>
     </packet>
 
-    <packet name="SigGen4" id="13" level="3">
+    <packet name="SigGen4" id="18" level="3">
         <channel name="SG4.PairOutput"/>
         <channel name="SG4.History"/>
         <channel name="SG4.PairHistory"/>
     </packet>
 
-    <packet name="SigGen5" id="14" level="3">
+    <packet name="SigGen5" id="19" level="3">
         <channel name="SG5.PairOutput"/>
         <channel name="SG5.History"/>
         <channel name="SG5.PairHistory"/>

Ref/Top/RefTopology.cpp

@@ -10,6 +10,7 @@
 // ======================================================================
 // Provides access to autocoded functions
 #include <Ref/Top/RefTopologyAc.hpp>
+#include <Ref/Top/RefPacketsAc.hpp>
 
 // Necessary project-specified types
 #include <Fw/Types/MallocAllocator.hpp>
@@ -60,7 +61,7 @@ enum TopologyConstants {
 // Ping entries are autocoded, however; this code is not properly exported. Thus, it is copied here.
 Svc::Health::PingEntry pingEntries[] = {
     {PingEntries::blockDrv::WARN, PingEntries::blockDrv::FATAL, "blockDrv"},
-    {PingEntries::chanTlm::WARN, PingEntries::chanTlm::FATAL, "chanTlm"},
+    {PingEntries::tlmSend::WARN, PingEntries::tlmSend::FATAL, "chanTlm"},
     {PingEntries::cmdDisp::WARN, PingEntries::cmdDisp::FATAL, "cmdDisp"},
     {PingEntries::cmdSeq::WARN, PingEntries::cmdSeq::FATAL, "cmdSeq"},
     {PingEntries::eventLogger::WARN, PingEntries::eventLogger::FATAL, "eventLogger"},
@@ -114,6 +115,9 @@ void configureTopology() {
     // Framer and Deframer components need to be passed a protocol handler
     downlink.setup(framing);
     uplink.setup(deframing);
+
+    // Note: Uncomment when using Svc:TlmPacketizer
+    //tlmSend.setPacketList(RefPacketsPkts, RefPacketsIgnore, 1);
 }
 
 // Public functions for use in main program are namespaced with deployment name Ref

Ref/Top/RefTopologyDefs.hpp

@@ -56,7 +56,7 @@ namespace PingEntries {
 namespace blockDrv {
 enum { WARN = 3, FATAL = 5 };
 }
-namespace chanTlm {
+namespace tlmSend {
 enum { WARN = 3, FATAL = 5 };
 }
 namespace cmdDisp {

Ref/Top/instances.fpp

@@ -68,11 +68,20 @@ module Ref {
     stack size Default.STACK_SIZE \
     priority 98
 
-  instance chanTlm: Svc.TlmChan base id 0x0C00 \
+  # comment in Svc.TlmChan or Svc.TlmPacketizer
+  # depending on which form of telemetry downlink
+  # you wish to use
+
+  instance tlmSend: Svc.TlmChan base id 0x0C00 \
     queue size Default.QUEUE_SIZE \
     stack size Default.STACK_SIZE \
     priority 97
 
+  #instance tlmSend: Svc.TlmPacketizer base id 0x0C00 \
+  #    queue size Default.QUEUE_SIZE \
+  #    stack size Default.STACK_SIZE \
+  #    priority 97
+
   instance prmDb: Svc.PrmDb base id 0x0D00 \
     queue size Default.QUEUE_SIZE \
     stack size Default.STACK_SIZE \

Ref/Top/topology.fpp

@@ -28,7 +28,7 @@ module Ref {
     instance SG4
     instance SG5
     instance blockDrv
-    instance chanTlm
+    instance tlmSend
     instance cmdDisp
     instance cmdSeq
     instance comm
@@ -64,7 +64,7 @@ module Ref {
 
     param connections instance prmDb
 
-    telemetry connections instance chanTlm
+    telemetry connections instance tlmSend
 
     text event connections instance textLogger
 
@@ -78,7 +78,7 @@ module Ref {
 
     connections Downlink {
 
-      chanTlm.PktSend -> downlink.comIn
+      tlmSend.PktSend -> downlink.comIn
       eventLogger.PktSend -> downlink.comIn
       fileDownlink.bufferSendOut -> downlink.bufferIn
 
@@ -103,7 +103,7 @@ module Ref {
       rateGroupDriverComp.CycleOut[Ports_RateGroups.rateGroup1] -> rateGroup1Comp.CycleIn
       rateGroup1Comp.RateGroupMemberOut[0] -> SG1.schedIn
       rateGroup1Comp.RateGroupMemberOut[1] -> SG2.schedIn
-      rateGroup1Comp.RateGroupMemberOut[2] -> chanTlm.Run
+      rateGroup1Comp.RateGroupMemberOut[2] -> tlmSend.Run
       rateGroup1Comp.RateGroupMemberOut[3] -> fileDownlink.Run
       rateGroup1Comp.RateGroupMemberOut[4] -> systemResources.run
 

Svc/TlmPacketizer/TlmPacketizer.cpp

@@ -8,9 +8,9 @@
 // ALL RIGHTS RESERVED.  United States Government Sponsorship
 // acknowledged.
 
-#include <Svc/TlmPacketizer/TlmPacketizer.hpp>
 #include <FpConfig.hpp>
 #include <Fw/Com/ComPacket.hpp>
+#include <Svc/TlmPacketizer/TlmPacketizer.hpp>
 
 namespace Svc {
 
@@ -18,16 +18,8 @@ namespace Svc {
 // Construction, initialization, and destruction
 // ----------------------------------------------------------------------
 
-  TlmPacketizer ::
+TlmPacketizer ::TlmPacketizer(const char* const compName)
-    TlmPacketizer(
+    : TlmPacketizerComponentBase(compName), m_numPackets(0), m_configured(false), m_startLevel(0), m_maxLevel(0) {
-        const char *const compName
-    ) :
-      TlmPacketizerComponentBase(compName)
-    ,m_numPackets(0)
-    ,m_configured(false)
-    ,m_startLevel(0)
-    ,m_maxLevel(0)
-  {
     // clear slot pointers
     for (NATIVE_UINT_TYPE entry = 0; entry < TLMPACKETIZER_NUM_TLM_HASH_SLOTS; entry++) {
         this->m_tlmEntries.slots[entry] = nullptr;
@@ -55,26 +47,15 @@ namespace Svc {
     }
 }
 
-  void TlmPacketizer ::
+void TlmPacketizer ::init(const NATIVE_INT_TYPE queueDepth, const NATIVE_INT_TYPE instance) {
-    init(
-        const NATIVE_INT_TYPE queueDepth,
-        const NATIVE_INT_TYPE instance
-    )
-  {
     TlmPacketizerComponentBase::init(queueDepth, instance);
 }
 
-  TlmPacketizer ::
+TlmPacketizer ::~TlmPacketizer() {}
-    ~TlmPacketizer()
-  {
 
-  }
+void TlmPacketizer::setPacketList(const TlmPacketizerPacketList& packetList,
-
-  void TlmPacketizer::setPacketList(
-          const TlmPacketizerPacketList& packetList,
                                   const Svc::TlmPacketizerPacket& ignoreList,
                                   const NATIVE_UINT_TYPE startLevel) {
-
     FW_ASSERT(packetList.list);
     FW_ASSERT(ignoreList.list);
     FW_ASSERT(packetList.numEntries <= MAX_PACKETIZER_PACKETS, packetList.numEntries);
@@ -82,7 +63,8 @@ namespace Svc {
     // table
     for (NATIVE_UINT_TYPE pktEntry = 0; pktEntry < packetList.numEntries; pktEntry++) {
         // Initial size is packetized telemetry descriptor + size of time tag + sizeof packet ID
-          NATIVE_UINT_TYPE packetLen = sizeof(FwPacketDescriptorType) + Fw::Time::SERIALIZED_SIZE + sizeof(FwTlmPacketizeIdType);
+        NATIVE_UINT_TYPE packetLen =
+            sizeof(FwPacketDescriptorType) + Fw::Time::SERIALIZED_SIZE + sizeof(FwTlmPacketizeIdType);
         FW_ASSERT(packetList.list[pktEntry]->list, pktEntry);
         // add up entries for each defined packet
         for (NATIVE_UINT_TYPE tlmEntry = 0; tlmEntry < packetList.list[pktEntry]->numEntries; tlmEntry++) {
@@ -105,7 +87,8 @@ namespace Svc {
         // clear contents
         memset(this->m_fillBuffers[pktEntry].buffer.getBuffAddr(), 0, packetLen);
         // serialize packet descriptor and packet ID now since it will always be the same
-          Fw::SerializeStatus stat = this->m_fillBuffers[pktEntry].buffer.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM));
+        Fw::SerializeStatus stat = this->m_fillBuffers[pktEntry].buffer.serialize(
+            static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM));
         FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, stat);
         stat = this->m_fillBuffers[pktEntry].buffer.serialize(packetList.list[pktEntry]->id);
         FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, stat);
@@ -192,26 +175,19 @@ namespace Svc {
         for (NATIVE_UINT_TYPE pktOffsetEntry = 0; pktOffsetEntry < MAX_PACKETIZER_PACKETS; pktOffsetEntry++) {
             entryToUse->packetOffset[pktOffsetEntry] = -1;
         }
-
     }
 
     return entryToUse;
 }
 
-
-
 // ----------------------------------------------------------------------
 // Handler implementations for user-defined typed input ports
 // ----------------------------------------------------------------------
 
-  void TlmPacketizer ::
+void TlmPacketizer ::TlmRecv_handler(const NATIVE_INT_TYPE portNum,
-    TlmRecv_handler(
-        const NATIVE_INT_TYPE portNum,
                                      FwChanIdType id,
                                      Fw::Time& timeTag,
-        Fw::TlmBuffer &val
+                                     Fw::TlmBuffer& val) {
-    )
-  {
     FW_ASSERT(this->m_configured);
     // get hash value for id
     NATIVE_UINT_TYPE index = this->doHash(id);
@@ -258,15 +234,9 @@ namespace Svc {
             this->m_lock.unLock();
         }
     }
-
 }
 
-  void TlmPacketizer ::
+void TlmPacketizer ::Run_handler(const NATIVE_INT_TYPE portNum, NATIVE_UINT_TYPE context) {
-    Run_handler(
-        const NATIVE_INT_TYPE portNum,
-        NATIVE_UINT_TYPE context
-    )
-  {
     FW_ASSERT(this->m_configured);
 
     // Only write packets if connected
@@ -280,16 +250,15 @@ namespace Svc {
     // copy buffers from fill side to send side
     for (NATIVE_UINT_TYPE pkt = 0; pkt < this->m_numPackets; pkt++) {
         if ((this->m_fillBuffers[pkt].updated) and
-                  ((this->m_fillBuffers[pkt].level <= this->m_startLevel) or
+            ((this->m_fillBuffers[pkt].level <= this->m_startLevel) or (this->m_fillBuffers[pkt].requested))) {
-                   (this->m_fillBuffers[pkt].requested))) {
-
             this->m_sendBuffers[pkt] = this->m_fillBuffers[pkt];
             if (PACKET_UPDATE_ON_CHANGE == PACKET_UPDATE_MODE) {
                 this->m_fillBuffers[pkt].updated = false;
             }
             this->m_fillBuffers[pkt].requested = false;
             // PACKET_UPDATE_AFTER_FIRST_CHANGE will be this case - updated flag will not be cleared
-          } else if ((PACKET_UPDATE_ALWAYS == PACKET_UPDATE_MODE) and (this->m_fillBuffers[pkt].level <= this->m_startLevel)) {
+        } else if ((PACKET_UPDATE_ALWAYS == PACKET_UPDATE_MODE) and
+                   (this->m_fillBuffers[pkt].level <= this->m_startLevel)) {
             this->m_sendBuffers[pkt] = this->m_fillBuffers[pkt];
             this->m_sendBuffers[pkt].updated = true;
         } else {
@@ -302,21 +271,19 @@ namespace Svc {
     for (NATIVE_UINT_TYPE pkt = 0; pkt < this->m_numPackets; pkt++) {
         if (this->m_sendBuffers[pkt].updated) {
             // serialize time into time offset in packet
-              Fw::ExternalSerializeBuffer buff(&this->m_sendBuffers[pkt].buffer.getBuffAddr()
+            Fw::ExternalSerializeBuffer buff(
-                      [sizeof(FwPacketDescriptorType)+ sizeof(FwTlmPacketizeIdType)],Fw::Time::SERIALIZED_SIZE);
+                &this->m_sendBuffers[pkt]
+                     .buffer.getBuffAddr()[sizeof(FwPacketDescriptorType) + sizeof(FwTlmPacketizeIdType)],
+                Fw::Time::SERIALIZED_SIZE);
             Fw::SerializeStatus stat = buff.serialize(this->m_sendBuffers[pkt].latestTime);
             FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, stat);
+
             this->PktSend_out(0, this->m_sendBuffers[pkt].buffer, 0);
         }
     }
 }
 
-  void TlmPacketizer ::
+void TlmPacketizer ::pingIn_handler(const NATIVE_INT_TYPE portNum, U32 key) {
-    pingIn_handler(
-        const NATIVE_INT_TYPE portNum,
-        U32 key
-    )
-  {
     // return key
     this->pingOut_out(0, key);
 }
@@ -325,13 +292,7 @@ namespace Svc {
 // Command handler implementations
 // ----------------------------------------------------------------------
 
-  void TlmPacketizer ::
+void TlmPacketizer ::SET_LEVEL_cmdHandler(const FwOpcodeType opCode, const U32 cmdSeq, U32 level) {
-    SET_LEVEL_cmdHandler(
-        const FwOpcodeType opCode,
-        const U32 cmdSeq,
-        U32 level
-    )
-  {
     this->m_startLevel = level;
     if (level > this->m_maxLevel) {
         this->log_WARNING_LO_MaxLevelExceed(level, this->m_maxLevel);
@@ -341,17 +302,10 @@ namespace Svc {
     this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
 }
 
-  void TlmPacketizer ::
+void TlmPacketizer ::SEND_PKT_cmdHandler(const FwOpcodeType opCode, const U32 cmdSeq, U32 id) {
-    SEND_PKT_cmdHandler(
-        const FwOpcodeType opCode,
-        const U32 cmdSeq,
-        U32 id
-    )
-  {
     NATIVE_UINT_TYPE pkt = 0;
     for (pkt = 0; pkt < this->m_numPackets; pkt++) {
         if (this->m_fillBuffers[pkt].id == id) {
-
             this->m_lock.lock();
             this->m_fillBuffers[pkt].updated = true;
             this->m_fillBuffers[pkt].latestTime = this->getTime();
@@ -373,7 +327,6 @@ namespace Svc {
     this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
 }
 
-
 NATIVE_UINT_TYPE TlmPacketizer::doHash(FwChanIdType id) {
     return (id % TLMPACKETIZER_HASH_MOD_VALUE) % TLMPACKETIZER_NUM_TLM_HASH_SLOTS;
 }
@@ -391,8 +344,6 @@ namespace Svc {
             return;
         }
     }
-
 }
 
-
 }  // end namespace Svc

Svc/TlmPacketizer/TlmPacketizer.hpp

@@ -11,33 +11,27 @@
 #ifndef TlmPacketizer_HPP
 #define TlmPacketizer_HPP
 
+#include "Os/Mutex.hpp"
 #include "Svc/TlmPacketizer/TlmPacketizerComponentAc.hpp"
 #include "Svc/TlmPacketizer/TlmPacketizerTypes.hpp"
-#include "Svc/TlmPacketizer/TlmPacketizerComponentImplCfg.hpp"
+#include "TlmPacketizerCfg.hpp"
-#include "Os/Mutex.hpp"
 
 namespace Svc {
 
-  class TlmPacketizer :
+class TlmPacketizer : public TlmPacketizerComponentBase {
-    public TlmPacketizerComponentBase
-  {
-
   public:
-
     // ----------------------------------------------------------------------
     // Construction, initialization, and destruction
     // ----------------------------------------------------------------------
 
     //! Construct object TlmPacketizer
     //!
-      TlmPacketizer(
+    TlmPacketizer(const char* const compName /*!< The component name*/
-          const char *const compName /*!< The component name*/
     );
 
     //! Initialize object TlmPacketizer
     //!
-      void init(
+    void init(const NATIVE_INT_TYPE queueDepth,  /*!< The queue depth*/
-          const NATIVE_INT_TYPE queueDepth, /*!< The queue depth*/
               const NATIVE_INT_TYPE instance = 0 /*!< The instance number*/
     );
 
@@ -51,15 +45,13 @@ namespace Svc {
     ~TlmPacketizer(void);
 
   PRIVATE:
-
     // ----------------------------------------------------------------------
     // Handler implementations for user-defined typed input ports
     // ----------------------------------------------------------------------
 
     //! Handler implementation for TlmRecv
     //!
-      void TlmRecv_handler(
+    void TlmRecv_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
                          FwChanIdType id,               /*!< Telemetry Channel ID*/
                          Fw::Time& timeTag,             /*!< Time Tag*/
                          Fw::TlmBuffer& val             /*!< Buffer containing serialized telemetry value*/
@@ -67,30 +59,26 @@ namespace Svc {
 
     //! Handler implementation for Run
     //!
-      void Run_handler(
+    void Run_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
                      NATIVE_UINT_TYPE context       /*!< The call order*/
     );
 
     //! Handler implementation for pingIn
     //!
-      void pingIn_handler(
+    void pingIn_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
                         U32 key                        /*!< Value to return to pinger*/
     );
 
     //! Implementation for SET_LEVEL command handler
     //! Set telemetry send leve
-      void SET_LEVEL_cmdHandler(
+    void SET_LEVEL_cmdHandler(const FwOpcodeType opCode, /*!< The opcode*/
-          const FwOpcodeType opCode, /*!< The opcode*/
                               const U32 cmdSeq,          /*!< The command sequence number*/
                               U32 level                  /*!< The I32 command argument*/
     );
 
     //! Implementation for SEND_PKT command handler
     //! Force a packet to be sent
-      void SEND_PKT_cmdHandler(
+    void SEND_PKT_cmdHandler(const FwOpcodeType opCode, /*!< The opcode*/
-          const FwOpcodeType opCode, /*!< The opcode*/
                              const U32 cmdSeq,          /*!< The command sequence number*/
                              U32 id                     /*!< The packet ID*/
     );
@@ -149,7 +137,6 @@ namespace Svc {
 
     NATIVE_UINT_TYPE m_startLevel;  //!< initial level for sending packets
     NATIVE_UINT_TYPE m_maxLevel;    //!< maximum level in all packets
-
 };
 
 }  // end namespace Svc

Svc/TlmPacketizer/TlmPacketizerComponentImplCfg.hpp

@@ -1,42 +0,0 @@
-/*
- * TlmPacketizerComponentImplCfg.hpp
- *
- *  Created on: Dec 10, 2017
- *      Author: tim
- */
-
-// \copyright
-// Copyright 2009-2015, by the California Institute of Technology.
-// ALL RIGHTS RESERVED.  United States Government Sponsorship
-// acknowledged.
-
-
-#ifndef SVC_TLMPACKETIZER_TLMPACKETIZERCOMPONENTIMPLCFG_HPP_
-#define SVC_TLMPACKETIZER_TLMPACKETIZERCOMPONENTIMPLCFG_HPP_
-
-#include <FpConfig.hpp>
-
-namespace Svc {
-    static const NATIVE_UINT_TYPE MAX_PACKETIZER_PACKETS = 200;
-    static const NATIVE_UINT_TYPE TLMPACKETIZER_NUM_TLM_HASH_SLOTS = 15; // !< Number of slots in the hash table.
-                                    // Works best when set to about twice the number of components producing telemetry
-    static const NATIVE_UINT_TYPE TLMPACKETIZER_HASH_MOD_VALUE = 99;    // !< The modulo value of the hashing function.
-                                    // Should be set to a little below the ID gaps to spread the entries around
-
-    static const NATIVE_UINT_TYPE TLMPACKETIZER_HASH_BUCKETS = 1000;       // !< Buckets assignable to a hash slot.
-                                    // Buckets must be >= number of telemetry channels in system
-    static const NATIVE_UINT_TYPE TLMPACKETIZER_MAX_MISSING_TLM_CHECK = 25;    // !< Maximum number of missing telemetry channel checks
-
-    // packet update mode
-    enum PacketUpdateMode {
-        PACKET_UPDATE_ALWAYS, // Always send packets, even if no changes to channel data
-        PACKET_UPDATE_ON_CHANGE, // Only send packets if any of the channels updates
-        PACKET_UPDATE_AFTER_FIRST_CHANGE, // Always send packets, but only after first channel has been updated
-    };
-
-    static const PacketUpdateMode PACKET_UPDATE_MODE = PACKET_UPDATE_ON_CHANGE;
-}
-
-
-
-#endif /* SVC_TLMPACKETIZER_TLMPACKETIZERCOMPONENTIMPLCFG_HPP_ */

Svc/TlmPacketizer/TlmPacketizerTypes.hpp

@@ -10,12 +10,11 @@
 // ALL RIGHTS RESERVED.  United States Government Sponsorship
 // acknowledged.
 
-
 #ifndef SVC_TLMPACKETIZER_TLMPACKETIZERTYPES_HPP_
 #define SVC_TLMPACKETIZER_TLMPACKETIZERTYPES_HPP_
 
 #include <FpConfig.hpp>
-#include <Svc/TlmPacketizer/TlmPacketizerComponentImplCfg.hpp>
+#include <TlmPacketizerCfg.hpp>
 
 namespace Svc {
 
@@ -35,6 +34,6 @@ namespace Svc {
     const TlmPacketizerPacket* list[MAX_PACKETIZER_PACKETS];  //!<
     NATIVE_UINT_TYPE numEntries;
 };
-}
+}  // namespace Svc
 
 #endif /* SVC_TLMPACKETIZER_TLMPACKETIZERTYPES_HPP_ */

Svc/TlmPacketizer/test/ut/Tester.cpp

@@ -22,21 +22,12 @@ namespace Svc {
 // Construction and destruction
 // ----------------------------------------------------------------------
 
-  Tester ::
+Tester ::Tester() : TlmPacketizerGTestBase("Tester", MAX_HISTORY_SIZE), component("TlmPacketizer"), m_timeSent(false) {
-    Tester() :
-      TlmPacketizerGTestBase("Tester", MAX_HISTORY_SIZE),
-      component("TlmPacketizer")
-      ,m_timeSent(false)
-  {
     this->initComponents();
     this->connectPorts();
 }
 
-  Tester ::
+Tester ::~Tester() {}
-    ~Tester()
-  {
-
-  }
 
 // ----------------------------------------------------------------------
 // Tests
@@ -44,45 +35,25 @@ namespace Svc {
 
 // Some Test tables
 
-  TlmPacketizerChannelEntry packet1List[] = {
+TlmPacketizerChannelEntry packet1List[] = {{10, 4}, {100, 2}, {333, 1}};
-          {10, 4},
-          {100, 2},
-          {333, 1}
-  };
 
-  TlmPacketizerChannelEntry packet2List[] = {
+TlmPacketizerChannelEntry packet2List[] = {{10, 4}, {13, 8}, {250, 2}, {22, 1}};
-          {10, 4},
-          {13, 8},
-          {250, 2},
-          {22,1}
-  };
 
 TlmPacketizerPacket packet1 = {packet1List, 4, 1, FW_NUM_ARRAY_ELEMENTS(packet1List)};
 
 TlmPacketizerPacket packet2 = {packet2List, 8, 2, FW_NUM_ARRAY_ELEMENTS(packet2List)};
 
-  TlmPacketizerPacketList packetList = {
+TlmPacketizerPacketList packetList = {{&packet1, &packet2}, 2};
-              {&packet1, &packet2},
-              2
-          };
 
-  TlmPacketizerChannelEntry ignoreList[] = {
+TlmPacketizerChannelEntry ignoreList[] = {{25, 0}, {50, 0}};
-          {25, 0},
-          {50, 0}
-  };
 
 TlmPacketizerPacket ignore = {ignoreList, 0, 0, FW_NUM_ARRAY_ELEMENTS(ignoreList)};
 
-  void Tester ::
+void Tester ::initTest() {
-    initTest()
-  {
     this->component.setPacketList(packetList, ignore, 2);
-
 }
 
-  void Tester ::
+void Tester ::pushTlmTest() {
-    pushTlmTest()
-  {
     this->component.setPacketList(packetList, ignore, 2);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -114,13 +85,9 @@ namespace Svc {
     buff.resetSer();
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, buff.serialize(static_cast<U8>(15)));
     this->invoke_to_TlmRecv(0, 22, ts, buff);
-
 }
 
-
+void Tester ::sendPacketsTest() {
-  void Tester ::
-    sendPacketsTest()
-  {
     this->component.setPacketList(packetList, ignore, 2);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -165,7 +132,8 @@ namespace Svc {
     // construct the packet buffers and make sure they are correct
 
     Fw::ComBuffer comBuff;
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -175,7 +143,8 @@ namespace Svc {
     ASSERT_from_PktSend(0, comBuff, static_cast<U32>(0));
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -184,12 +153,9 @@ namespace Svc {
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U8>(15)));
 
     ASSERT_from_PktSend(1, comBuff, static_cast<U32>(0));
-
 }
 
-  void Tester ::
+void Tester ::sendPacketLevelsTest() {
-    sendPacketLevelsTest()
-  {
     this->component.setPacketList(packetList, ignore, 1);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -234,7 +200,8 @@ namespace Svc {
     // construct the packet buffers and make sure they are correct
 
     Fw::ComBuffer comBuff;
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -244,7 +211,8 @@ namespace Svc {
     ASSERT_from_PktSend(0, comBuff, static_cast<U32>(0));
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -253,12 +221,9 @@ namespace Svc {
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U8>(15)));
 
     ASSERT_from_PktSend(1, comBuff, static_cast<U32>(0));
-
 }
 
-  void Tester ::
+void Tester ::updatePacketsTest() {
-    updatePacketsTest()
-  {
     this->component.setPacketList(packetList, ignore, 2);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -285,7 +250,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(2);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -295,7 +261,8 @@ namespace Svc {
     ASSERT_from_PktSend(0, comBuff, static_cast<U32>(0));
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -322,7 +289,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -343,7 +311,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -363,7 +332,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -386,7 +356,8 @@ namespace Svc {
     comBuff.resetSer();
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -407,7 +378,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -431,7 +403,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(2);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(1000)));
@@ -441,7 +414,8 @@ namespace Svc {
     ASSERT_from_PktSend(0, comBuff, static_cast<U32>(0));
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(1000)));
@@ -464,7 +438,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(1000)));
@@ -484,7 +459,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(1000)));
@@ -504,7 +480,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(1000)));
@@ -525,7 +502,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(1000)));
@@ -546,7 +524,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(1);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(1000)));
@@ -555,12 +534,9 @@ namespace Svc {
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U8>(65)));
 
     ASSERT_from_PktSend(0, comBuff, static_cast<U32>(0));
-
 }
 
-  void Tester ::
+void Tester ::ignoreTest() {
-     ignoreTest()
-  {
     this->component.setPacketList(packetList, ignore, 2);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -587,7 +563,8 @@ namespace Svc {
     ASSERT_from_PktSend_SIZE(2);
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -597,7 +574,8 @@ namespace Svc {
     ASSERT_from_PktSend(0, comBuff, static_cast<U32>(0));
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(ts));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -622,12 +600,9 @@ namespace Svc {
 
     // no packets should be pushed
     ASSERT_from_PktSend_SIZE(0);
-
 }
 
-  void Tester ::
+void Tester ::sendManualPacketTest() {
-     sendManualPacketTest()
-  {
     this->component.setPacketList(packetList, ignore, 2);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -672,7 +647,8 @@ namespace Svc {
     // construct the packet buffers and make sure they are correct
 
     Fw::ComBuffer comBuff1;
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff1.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff1.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff1.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff1.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff1.serialize(static_cast<U32>(20)));
@@ -682,7 +658,8 @@ namespace Svc {
     ASSERT_from_PktSend(0, comBuff1, static_cast<U32>(0));
 
     Fw::ComBuffer comBuff2;
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff2.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff2.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff2.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff2.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff2.serialize(static_cast<U32>(20)));
@@ -744,12 +721,9 @@ namespace Svc {
     ASSERT_EVENTS_PacketNotFound(0, 20);
     ASSERT_CMD_RESPONSE_SIZE(1);
     ASSERT_CMD_RESPONSE(0, TlmPacketizerComponentBase::OPCODE_SEND_PKT, 12, Fw::CmdResponse::VALIDATION_ERROR);
-
 }
 
-  void Tester ::
+void Tester ::setPacketLevelTest() {
-     setPacketLevelTest()
-  {
     this->component.setPacketList(packetList, ignore, 0);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -845,7 +819,8 @@ namespace Svc {
     // Should be packet 4
 
     Fw::ComBuffer comBuff1;
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff1.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff1.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff1.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff1.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff1.serialize(static_cast<U32>(0x20)));
@@ -862,7 +837,8 @@ return;
     // construct the packet buffers and make sure they are correct
 
     Fw::ComBuffer comBuff;
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(4)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -872,7 +848,8 @@ return;
     ASSERT_from_PktSend(0, comBuff, static_cast<U32>(0));
 
     comBuff.resetSer();
-      ASSERT_EQ(Fw::FW_SERIALIZE_OK,comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
+    ASSERT_EQ(Fw::FW_SERIALIZE_OK,
+              comBuff.serialize(static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_PACKETIZED_TLM)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<FwTlmPacketizeIdType>(8)));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(this->m_testTime));
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U32>(20)));
@@ -881,12 +858,9 @@ return;
     ASSERT_EQ(Fw::FW_SERIALIZE_OK, comBuff.serialize(static_cast<U8>(15)));
 
     ASSERT_from_PktSend(1, comBuff, static_cast<U32>(0));
-
 }
 
-  void Tester ::
+void Tester ::nonPacketizedChannelTest() {
-    nonPacketizedChannelTest() {
-
     this->component.setPacketList(packetList, ignore, 2);
     Fw::Time ts;
     Fw::TlmBuffer buff;
@@ -914,12 +888,9 @@ return;
         ASSERT_EVENTS_SIZE(0);
         ASSERT_EVENTS_NoChan_SIZE(0);
     }
-
 }
 
-  void Tester ::
+void Tester ::pingTest() {
-    pingTest() {
-
     this->component.setPacketList(packetList, ignore, 2);
     // ping component
     this->clearFromPortHistory();
@@ -927,39 +898,22 @@ return;
     this->component.doDispatch();
     ASSERT_from_pingOut_SIZE(1);
     ASSERT_from_pingOut(0, static_cast<U32>(0x1234));
-
 }
 
 // ----------------------------------------------------------------------
 // Handlers for typed from ports
 // ----------------------------------------------------------------------
 
-  void Tester ::
+void Tester ::from_Time_handler(const NATIVE_INT_TYPE portNum, Fw::Time& time) {
-    from_Time_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::Time &time
-    )
-  {
     time = this->m_testTime;
     this->m_timeSent = true;
 }
 
-  void Tester ::
+void Tester ::from_PktSend_handler(const NATIVE_INT_TYPE portNum, Fw::ComBuffer& data, U32 context) {
-    from_PktSend_handler(
-        const NATIVE_INT_TYPE portNum,
-        Fw::ComBuffer &data,
-        U32 context
-    )
-  {
     this->pushFromPortEntry_PktSend(data, context);
 }
 
-  void Tester ::
+void Tester ::from_pingOut_handler(const NATIVE_INT_TYPE portNum, U32 key) {
-    from_pingOut_handler(
-        const NATIVE_INT_TYPE portNum,
-        U32 key
-    )
-  {
     this->pushFromPortEntry_pingOut(key);
 }
 
@@ -967,82 +921,42 @@ return;
 // Helper methods
 // ----------------------------------------------------------------------
 
-  void Tester ::
+void Tester ::connectPorts() {
-    connectPorts()
-  {
-
     // PktSend
-    this->component.set_PktSend_OutputPort(
+    this->component.set_PktSend_OutputPort(0, this->get_from_PktSend(0));
-        0,
-        this->get_from_PktSend(0)
-    );
 
     // Run
-    this->connect_to_Run(
+    this->connect_to_Run(0, this->component.get_Run_InputPort(0));
-        0,
-        this->component.get_Run_InputPort(0)
-    );
 
     // TlmRecv
-    this->connect_to_TlmRecv(
+    this->connect_to_TlmRecv(0, this->component.get_TlmRecv_InputPort(0));
-        0,
-        this->component.get_TlmRecv_InputPort(0)
-    );
 
     // cmdIn
-    this->connect_to_cmdIn(
+    this->connect_to_cmdIn(0, this->component.get_cmdIn_InputPort(0));
-        0,
-        this->component.get_cmdIn_InputPort(0)
-    );
 
     // cmdRegOut
-    this->component.set_cmdRegOut_OutputPort(
+    this->component.set_cmdRegOut_OutputPort(0, this->get_from_cmdRegOut(0));
-        0,
-        this->get_from_cmdRegOut(0)
-    );
 
     // cmdResponseOut
-    this->component.set_cmdResponseOut_OutputPort(
+    this->component.set_cmdResponseOut_OutputPort(0, this->get_from_cmdResponseOut(0));
-        0,
-        this->get_from_cmdResponseOut(0)
-    );
 
     // eventOut
-    this->component.set_eventOut_OutputPort(
+    this->component.set_eventOut_OutputPort(0, this->get_from_eventOut(0));
-        0,
-        this->get_from_eventOut(0)
-    );
 
     // pingIn
-    this->connect_to_pingIn(
+    this->connect_to_pingIn(0, this->component.get_pingIn_InputPort(0));
-        0,
-        this->component.get_pingIn_InputPort(0)
-    );
 
     // pingOut
-    this->component.set_pingOut_OutputPort(
+    this->component.set_pingOut_OutputPort(0, this->get_from_pingOut(0));
-        0,
-        this->get_from_pingOut(0)
-    );
 
     // textEventOut
-    this->component.set_textEventOut_OutputPort(
+    this->component.set_textEventOut_OutputPort(0, this->get_from_textEventOut(0));
-        0,
-        this->get_from_textEventOut(0)
-    );
 
     // timeGetOut
-    this->component.set_timeGetOut_OutputPort(
+    this->component.set_timeGetOut_OutputPort(0, this->get_from_timeGetOut(0));
-        0,
-        this->get_from_timeGetOut(0)
-    );
 
     // tlmOut
-    this->component.set_tlmOut_OutputPort(
+    this->component.set_tlmOut_OutputPort(0, this->get_from_tlmOut(0));
-        0,
-        this->get_from_tlmOut(0)
-    );
-
 }
 
 void Tester::textLogIn(const FwEventIdType id,          //!< The event ID
@@ -1055,14 +969,9 @@ return;
     printTextLogHistoryEntry(e, stdout);
 }
 
-
+void Tester ::initComponents() {
-  void Tester ::
-    initComponents()
-  {
     this->init();
-    this->component.init(
+    this->component.init(QUEUE_DEPTH, INSTANCE);
-        QUEUE_DEPTH, INSTANCE
-    );
 }
 
 }  // end namespace Svc

Svc/TlmPacketizer/test/ut/Tester.hpp

@@ -16,16 +16,12 @@
 
 namespace Svc {
 
-  class Tester :
+class Tester : public TlmPacketizerGTestBase {
-    public TlmPacketizerGTestBase
-  {
-
     // ----------------------------------------------------------------------
     // Construction and destruction
     // ----------------------------------------------------------------------
 
   public:
-
     //! Construct object Tester
     //!
     Tester(void);
@@ -35,7 +31,6 @@ namespace Svc {
     ~Tester(void);
 
   public:
-
     // ----------------------------------------------------------------------
     // Tests
     // ----------------------------------------------------------------------
@@ -81,43 +76,36 @@ namespace Svc {
     void setPacketLevelTest(void);
 
   private:
-
     // ----------------------------------------------------------------------
     // Handlers for typed from ports
     // ----------------------------------------------------------------------
 
     //! Handler for from_Time
     //!
-      void from_Time_handler(
+    void from_Time_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
                            Fw::Time& time                 /*!< The U32 cmd argument*/
     );
 
     //! Handler for from_PktSend
     //!
-      void from_PktSend_handler(
+    void from_PktSend_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
                               Fw::ComBuffer& data,           /*!< Buffer containing packet data*/
                               U32 context                    /*!< Call context value; meaning chosen by user*/
     );
 
     //! Handler for from_pingOut
     //!
-      void from_pingOut_handler(
+    void from_pingOut_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
-          const NATIVE_INT_TYPE portNum, /*!< The port number*/
                               U32 key                        /*!< Value to return to pinger*/
     );
 
-      virtual void textLogIn(
+    virtual void textLogIn(const FwEventIdType id,         /*!< The event ID*/
-          const FwEventIdType id, /*!< The event ID*/
                            Fw::Time& timeTag,              /*!< The time*/
                            const Fw::LogSeverity severity, /*!< The severity*/
                            const Fw::TextLogString& text   /*!< The event string*/
     );
 
-
   private:
-
     // ----------------------------------------------------------------------
     // Helper methods
     // ----------------------------------------------------------------------
@@ -131,7 +119,6 @@ namespace Svc {
     void initComponents(void);
 
   private:
-
     // ----------------------------------------------------------------------
     // Variables
     // ----------------------------------------------------------------------
@@ -142,7 +129,6 @@ namespace Svc {
 
     Fw::Time m_testTime;  //!< store test time for packets
     bool m_timeSent;      //!< flag when time was sent
-
 };
 
 }  // end namespace Svc

Svc/TlmPacketizer/test/ut/main.cpp

@@ -3,28 +3,23 @@
 // ALL RIGHTS RESERVED.  United States Government Sponsorship
 // acknowledged.
 
-
-#include "Tester.hpp"
 #include <gtest/gtest.h>
 #include <Fw/Test/UnitTest.hpp>
+#include "Tester.hpp"
 
 TEST(TestNominal, Initialization) {
-
     TEST_CASE(100.1.1, "Initialization");
     Svc::Tester tester;
     tester.initTest();
 }
 
-
 TEST(TestNominal, PushTlm) {
-
     TEST_CASE(100.1.2, "Push Telemetry");
     Svc::Tester tester;
     tester.pushTlmTest();
 }
 
 TEST(TestNominal, SendPackets) {
-
     TEST_CASE(100.1.2, "Send Packets");
     Svc::Tester tester;
     tester.sendPacketsTest();
@@ -38,28 +33,24 @@ TEST(TestNominal,SendPackets) {
 // }
 
 TEST(TestNominal, UpdatePacketsTest) {
-
     TEST_CASE(100.1.4, "Update Packets");
     Svc::Tester tester;
     tester.updatePacketsTest();
 }
 
 TEST(TestNominal, PingTest) {
-
     TEST_CASE(100.1.5, "Ping");
     Svc::Tester tester;
     tester.pingTest();
 }
 
 TEST(TestNominal, IgnoredChannelTest) {
-
     TEST_CASE(100.1.6, "Ignored Channels");
     Svc::Tester tester;
     tester.ignoreTest();
 }
 
 TEST(TestNominal, SendPacketTest) {
-
     TEST_CASE(100.1.7, "Manually sent packets");
     Svc::Tester tester;
     tester.sendManualPacketTest();
@@ -73,7 +64,6 @@ TEST(TestNominal,SetPacketLevelTest) {
 }
 #endif
 TEST(TestOffNominal, NonPacketizedChannelTest) {
-
     TEST_CASE(100.2.1, "Non-packetized Channels");
     Svc::Tester tester;
     tester.nonPacketizedChannelTest();

cmake/FPrime.cmake

@@ -69,6 +69,7 @@ register_fprime_target(target/fpp_locs)
 register_fprime_target(target/build)
 register_fprime_build_autocoder(autocoder/fpp)
 register_fprime_build_autocoder(autocoder/ai_xml)
+register_fprime_build_autocoder(autocoder/packets)
 register_fprime_target(target/noop)
 register_fprime_target(target/version)
 register_fprime_target(target/dict)

cmake/autocoder/packets.cmake

@@ -0,0 +1,63 @@
+####
+# autocoder/packets.cmake
+#
+# Packets autocoder.
+#####
+include(utilities)
+include(autocoder/helpers)
+include(autocoder/ai-shared)
+
+set(PACKETS_AUTOCODER_SCRIPT "${FPRIME_FRAMEWORK_PATH}/Autocoders/Python/bin/tlm_packet_gen.py")
+
+autocoder_setup_for_individual_sources()
+####
+# `packets_is_supported`:
+#
+# Required function, processes Ai.xml files.
+# `AC_INPUT_FILE` potential input to the autocoder
+# ...: any number of arguments representing a list of previously generated files
+####
+function(packets_is_supported AC_INPUT_FILE)
+    autocoder_support_by_suffix("Packets.xml" "${AC_INPUT_FILE}" TRUE)
+endfunction (packets_is_supported)
+
+####
+# `determine_topology_files`:
+#
+# Get topology determined from packet file.
+####
+function(determine_topology_files AC_INPUT_FILE)
+    file(READ "${AC_INPUT_FILE}" FILE_CONTENTS)
+    string(REGEX REPLACE ".*<import_topology>([^>]*)</import_topology>.*" "\\1" TOPOLOGY_FILE "${FILE_CONTENTS}")
+    # This will work as long as the topology ai file is not part of the fprime core "library" code
+    set(FULL_TOPOLOGY_FILE "${CMAKE_BINARY_DIR}/${TOPOLOGY_FILE}" PARENT_SCOPE)
+endfunction(determine_topology_files)
+
+####
+# `packets_setup_autocode`:
+#
+# Required function, sets up a custom command to produce Ac.hpp and Ac.cpp files.
+####
+function(packets_setup_autocode AC_INPUT_FILE)
+    determine_topology_files("${AC_INPUT_FILE}")
+    get_filename_component(AC_INPUT_FILE_NO_PATH "${AC_INPUT_FILE}" NAME)
+
+    string(REPLACE ";" ":" FPRIME_BUILD_LOCATIONS_SEP "${FPRIME_BUILD_LOCATIONS}")
+    string(REPLACE "Packets.xml" "PacketsAc.cpp" CPP_FILE "${AC_INPUT_FILE_NO_PATH}")
+    string(REPLACE "Packets.xml" "PacketsAc.hpp" HPP_FILE "${AC_INPUT_FILE_NO_PATH}")
+
+    set(GENERATED_FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/${CPP_FILE}"
+        "${CMAKE_CURRENT_BINARY_DIR}/${HPP_FILE}"
+    )
+    add_custom_command(
+        OUTPUT ${GENERATED_FILES}
+        COMMAND
+            PYTHONPATH=${PYTHON_AUTOCODER_DIR}/src:${PYTHON_AUTOCODER_DIR}/utils
+            BUILD_ROOT=${FPRIME_BUILD_LOCATIONS_SEP}:${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/F-Prime
+            "${PYTHON}" "${PACKETS_AUTOCODER_SCRIPT}" "${AC_INPUT_FILE}"
+        DEPENDS "${AC_INPUT_FILE}" "${FULL_TOPOLOGY_FILE}"
+    )
+    set(AUTOCODER_GENERATED "${GENERATED_FILES}" PARENT_SCOPE)
+    set(AUTOCODER_DEPENDENCIES "" PARENT_SCOPE)
+endfunction(packets_setup_autocode)

cmake/utilities.cmake

@@ -385,6 +385,22 @@ function (read_from_lines CONTENT)
     endforeach()
 endfunction()
 
+####
+# Function `full_path_from_build_relative_path`:
+#
+# Creates a full path from the shortened build-relative path.
+# -**SHORT_PATH:** build relative path
+# Return: full path from relative path
+####
+function(full_path_from_build_relative_path SHORT_PATH OUTPUT_VARIABLE)
+    foreach(FPRIME_LOCATION IN LISTS FPRIME_BUILD_LOCATIONS)
+        if (EXISTS "${FPRIME_LOCATION}/${SHORT_PATH}")
+            set("${OUTPUT_VARIABLE}" "${FPRIME_LOCATION}/${SHORT_PATH}" PARENT_SCOPE)
+            return()
+        endif()
+    endforeach()
+    set("${OUTPUT_VARIABLE}" "" PARENT_SCOPE)
+endfunction(full_path_from_build_relative_path)
 
 ####
 # Function `get_nearest_build_root`:

config/TlmPacketizerCfg.hpp

@@ -0,0 +1,43 @@
+/*
+ * TlmPacketizerComponentImplCfg.hpp
+ *
+ *  Created on: Dec 10, 2017
+ *      Author: tim
+ */
+
+// \copyright
+// Copyright 2009-2015, by the California Institute of Technology.
+// ALL RIGHTS RESERVED.  United States Government Sponsorship
+// acknowledged.
+
+#ifndef SVC_TLMPACKETIZER_TLMPACKETIZERCOMPONENTIMPLCFG_HPP_
+#define SVC_TLMPACKETIZER_TLMPACKETIZERCOMPONENTIMPLCFG_HPP_
+
+#include <FpConfig.hpp>
+
+namespace Svc {
+static const NATIVE_UINT_TYPE MAX_PACKETIZER_PACKETS = 200;
+static const NATIVE_UINT_TYPE TLMPACKETIZER_NUM_TLM_HASH_SLOTS =
+    15;  // !< Number of slots in the hash table.
+         // Works best when set to about twice the number of components producing telemetry
+static const NATIVE_UINT_TYPE TLMPACKETIZER_HASH_MOD_VALUE =
+    99;  // !< The modulo value of the hashing function.
+         // Should be set to a little below the ID gaps to spread the entries around
+
+static const NATIVE_UINT_TYPE TLMPACKETIZER_HASH_BUCKETS =
+    1000;  // !< Buckets assignable to a hash slot.
+           // Buckets must be >= number of telemetry channels in system
+static const NATIVE_UINT_TYPE TLMPACKETIZER_MAX_MISSING_TLM_CHECK =
+    25;  // !< Maximum number of missing telemetry channel checks
+
+// packet update mode
+enum PacketUpdateMode {
+    PACKET_UPDATE_ALWAYS,              // Always send packets, even if no changes to channel data
+    PACKET_UPDATE_ON_CHANGE,           // Only send packets if any of the channels updates
+    PACKET_UPDATE_AFTER_FIRST_CHANGE,  // Always send packets, but only after first channel has been updated
+};
+
+static const PacketUpdateMode PACKET_UPDATE_MODE = PACKET_UPDATE_ON_CHANGE;
+}  // namespace Svc
+
+#endif /* SVC_TLMPACKETIZER_TLMPACKETIZERCOMPONENTIMPLCFG_HPP_ */

requirements.txt

@@ -14,8 +14,8 @@ Flask==1.1.4
 Flask-Compress==1.12
 Flask-RESTful==0.3.9
 fprime-fpp==1.1.0
-fprime-gds==3.1.4
+fprime-gds==3.1.5a1
-fprime-tools==3.1.1
+fprime-tools==3.1.2a1
 gcovr==5.1
 idna==3.3
 importlib-metadata==4.11.4