nasa/fprime
1
0
Fork 0
mirror of https://github.com/nasa/fprime.git synced 2025-12-11 04:35:25 -06:00
Code Issues Packages Projects Releases 34 Wiki Activity

Add packetized telemetry option (#1776)

Browse Source 
* 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>
This commit is contained in:
Timothy Canham 2022-11-29 14:00:20 -08:00 committed by GitHub
parent 9409139668
commit b7a25920a3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 1672 additions and 1727 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

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

58
Autocoders/Python/bin/tlm_packet_gen.py
View File

@ -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":
return size
if type_name == "string":
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(
"Ai", ""
)
file_dir = os.path.dirname(xml_filename).replace(
get_nearest_build_root(xml_filename) + os.sep, ""
)
output_file_base = os.path.splitext(os.path.basename(xml_filename))[0]
nearest_build_root = get_nearest_build_root(xml_filename)
file_dir = os.path.relpath(os.path.dirname(xml_filename), nearest_build_root)
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

14
Autocoders/Python/bin/tlm_packet_gen.sh Executable file
View File

@ -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

2
Autocoders/Python/src/fprime_ac/parsers/XmlSerializeParser.py
View File

@ -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

1
Autocoders/Python/src/fprime_ac/utils/buildroot.py
View File

@ -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()
)

1
Ref/Top/CMakeLists.txt
View File

@ -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"
)

55
Ref/Top/RefPacketsAi.xml → Ref/Top/RefPackets.xml
View File

@ -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"/>

6
Ref/Top/RefTopology.cpp
View File

@ -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

2
Ref/Top/RefTopologyDefs.hpp
View File

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

11
Ref/Top/instances.fpp
View File

@ -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 \

8
Ref/Top/topology.fpp
View File

@ -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

97
Svc/TlmPacketizer/TlmPacketizer.cpp
View File

@ -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(
const char *const compName
) :
TlmPacketizerComponentBase(compName)
,m_numPackets(0)
,m_configured(false)
,m_startLevel(0)
,m_maxLevel(0)
{
TlmPacketizer ::TlmPacketizer(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 ::
init(
const NATIVE_INT_TYPE queueDepth,
const NATIVE_INT_TYPE instance
)
{
void TlmPacketizer ::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 ::
TlmRecv_handler(
const NATIVE_INT_TYPE portNum,
void TlmPacketizer ::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 ::
Run_handler(
const NATIVE_INT_TYPE portNum,
NATIVE_UINT_TYPE context
)
{
void TlmPacketizer ::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].requested))) {
((this->m_fillBuffers[pkt].level <= this->m_startLevel) or (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()
[sizeof(FwPacketDescriptorType)+ sizeof(FwTlmPacketizeIdType)],Fw::Time::SERIALIZED_SIZE);
Fw::ExternalSerializeBuffer buff(
&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 ::
pingIn_handler(
const NATIVE_INT_TYPE portNum,
U32 key
)
{
void TlmPacketizer ::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 ::
SET_LEVEL_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
U32 level
)
{
void TlmPacketizer ::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 ::
SEND_PKT_cmdHandler(
const FwOpcodeType opCode,
const U32 cmdSeq,
U32 id
)
{
void TlmPacketizer ::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

33
Svc/TlmPacketizer/TlmPacketizer.hpp
View File

@ -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 "Os/Mutex.hpp"
#include "TlmPacketizerCfg.hpp"
namespace Svc {
class TlmPacketizer :
public TlmPacketizerComponentBase
{
class TlmPacketizer : public TlmPacketizerComponentBase {
public:
// ----------------------------------------------------------------------
// Construction, initialization, and destruction
// ----------------------------------------------------------------------
//! Construct object TlmPacketizer
//!
TlmPacketizer(
const char *const compName /*!< The component name*/
TlmPacketizer(const char* const compName /*!< The component name*/
);
//! Initialize object TlmPacketizer
//!
void init(
const NATIVE_INT_TYPE queueDepth, /*!< The queue depth*/
void init(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(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
void TlmRecv_handler(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(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
void Run_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
NATIVE_UINT_TYPE context /*!< The call order*/
);
//! Handler implementation for pingIn
//!
void pingIn_handler(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
void pingIn_handler(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(
const FwOpcodeType opCode, /*!< The opcode*/
void SET_LEVEL_cmdHandler(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(
const FwOpcodeType opCode, /*!< The opcode*/
void SEND_PKT_cmdHandler(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

42
Svc/TlmPacketizer/TlmPacketizerComponentImplCfg.hpp
View File

@ -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_ */

5
Svc/TlmPacketizer/TlmPacketizerTypes.hpp
View File

@ -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_ */

259
Svc/TlmPacketizer/test/ut/Tester.cpp
View File

@ -22,21 +22,12 @@ namespace Svc {
// Construction and destruction
// ----------------------------------------------------------------------
Tester ::
Tester() :
TlmPacketizerGTestBase("Tester", MAX_HISTORY_SIZE),
component("TlmPacketizer")
,m_timeSent(false)
{
Tester ::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[] = {
{10, 4},
{100, 2},
{333, 1}
};
TlmPacketizerChannelEntry packet1List[] = {{10, 4}, {100, 2}, {333, 1}};
TlmPacketizerChannelEntry packet2List[] = {
{10, 4},
{13, 8},
{250, 2},
{22,1}
};
TlmPacketizerChannelEntry packet2List[] = {{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 = {
{&packet1, &packet2},
2
};
TlmPacketizerPacketList packetList = {{&packet1, &packet2}, 2};
TlmPacketizerChannelEntry ignoreList[] = {
{25, 0},
{50, 0}
};
TlmPacketizerChannelEntry ignoreList[] = {{25, 0}, {50, 0}};
TlmPacketizerPacket ignore = {ignoreList, 0, 0, FW_NUM_ARRAY_ELEMENTS(ignoreList)};
void Tester ::
initTest()
{
void Tester ::initTest() {
this->component.setPacketList(packetList, ignore, 2);
}
void Tester ::
pushTlmTest()
{
void Tester ::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 ::
sendPacketLevelsTest()
{
void Tester ::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 ::
updatePacketsTest()
{
void Tester ::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 ::
ignoreTest()
{
void Tester ::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 ::
sendManualPacketTest()
{
void Tester ::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 ::
setPacketLevelTest()
{
void Tester ::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 ::
nonPacketizedChannelTest() {
void Tester ::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 ::
pingTest() {
void Tester ::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 ::
from_Time_handler(
const NATIVE_INT_TYPE portNum,
Fw::Time &time
)
{
void Tester ::from_Time_handler(const NATIVE_INT_TYPE portNum, Fw::Time& time) {
time = this->m_testTime;
this->m_timeSent = true;
}
void Tester ::
from_PktSend_handler(
const NATIVE_INT_TYPE portNum,
Fw::ComBuffer &data,
U32 context
)
{
void Tester ::from_PktSend_handler(const NATIVE_INT_TYPE portNum, Fw::ComBuffer& data, U32 context) {
this->pushFromPortEntry_PktSend(data, context);
}
void Tester ::
from_pingOut_handler(
const NATIVE_INT_TYPE portNum,
U32 key
)
{
void Tester ::from_pingOut_handler(const NATIVE_INT_TYPE portNum, U32 key) {
this->pushFromPortEntry_pingOut(key);
}
@ -967,82 +921,42 @@ return;
// Helper methods
// ----------------------------------------------------------------------
void Tester ::
connectPorts()
{
void Tester ::connectPorts() {
// PktSend
this->component.set_PktSend_OutputPort(
0,
this->get_from_PktSend(0)
);
this->component.set_PktSend_OutputPort(0, this->get_from_PktSend(0));
// Run
this->connect_to_Run(
0,
this->component.get_Run_InputPort(0)
);
this->connect_to_Run(0, this->component.get_Run_InputPort(0));
// TlmRecv
this->connect_to_TlmRecv(
0,
this->component.get_TlmRecv_InputPort(0)
);
this->connect_to_TlmRecv(0, this->component.get_TlmRecv_InputPort(0));
// cmdIn
this->connect_to_cmdIn(
0,
this->component.get_cmdIn_InputPort(0)
);
this->connect_to_cmdIn(0, this->component.get_cmdIn_InputPort(0));
// cmdRegOut
this->component.set_cmdRegOut_OutputPort(
0,
this->get_from_cmdRegOut(0)
);
this->component.set_cmdRegOut_OutputPort(0, this->get_from_cmdRegOut(0));
// cmdResponseOut
this->component.set_cmdResponseOut_OutputPort(
0,
this->get_from_cmdResponseOut(0)
);
this->component.set_cmdResponseOut_OutputPort(0, this->get_from_cmdResponseOut(0));
// eventOut
this->component.set_eventOut_OutputPort(
0,
this->get_from_eventOut(0)
);
this->component.set_eventOut_OutputPort(0, this->get_from_eventOut(0));
// pingIn
this->connect_to_pingIn(
0,
this->component.get_pingIn_InputPort(0)
);
this->connect_to_pingIn(0, this->component.get_pingIn_InputPort(0));
// pingOut
this->component.set_pingOut_OutputPort(
0,
this->get_from_pingOut(0)
);
this->component.set_pingOut_OutputPort(0, this->get_from_pingOut(0));
// textEventOut
this->component.set_textEventOut_OutputPort(
0,
this->get_from_textEventOut(0)
);
this->component.set_textEventOut_OutputPort(0, this->get_from_textEventOut(0));
// timeGetOut
this->component.set_timeGetOut_OutputPort(
0,
this->get_from_timeGetOut(0)
);
this->component.set_timeGetOut_OutputPort(0, this->get_from_timeGetOut(0));
// tlmOut
this->component.set_tlmOut_OutputPort(
0,
this->get_from_tlmOut(0)
);
this->component.set_tlmOut_OutputPort(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(
QUEUE_DEPTH, INSTANCE
);
this->component.init(QUEUE_DEPTH, INSTANCE);
}
} // end namespace Svc

24
Svc/TlmPacketizer/test/ut/Tester.hpp
View File

@ -16,16 +16,12 @@
namespace Svc {
class Tester :
public TlmPacketizerGTestBase
{
class Tester : 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(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
void from_Time_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
Fw::Time& time /*!< The U32 cmd argument*/
);
//! Handler for from_PktSend
//!
void from_PktSend_handler(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
void from_PktSend_handler(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(
const NATIVE_INT_TYPE portNum, /*!< The port number*/
void from_pingOut_handler(const NATIVE_INT_TYPE portNum, /*!< The port number*/
U32 key /*!< Value to return to pinger*/
);
virtual void textLogIn(
const FwEventIdType id, /*!< The event ID*/
virtual void textLogIn(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

12
Svc/TlmPacketizer/test/ut/main.cpp
View File

@ -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();

1
cmake/FPrime.cmake
View File

@ -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)

63
cmake/autocoder/packets.cmake Normal file
View File

@ -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)

16
cmake/utilities.cmake
View File

@ -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`:

43
config/TlmPacketizerCfg.hpp Normal file
View File

@ -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_ */

4
requirements.txt
View File

@ -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-tools==3.1.1
fprime-gds==3.1.5a1
fprime-tools==3.1.2a1
gcovr==5.1
idna==3.3
importlib-metadata==4.11.4