Martino FerrariandClaude Opus 4.6
5562877c99
DATA packets timestamp with the raw value of the producer's high-resolution counter, and the wire never said how fast that counter runs. The hub divided by its own timer's frequency instead, which is only the same number while producer and hub share a machine — on x86 it is the TSC frequency and differs from model to model. Off-box, every accumulated batch was therefore laid out over the wrong span of time: the samples in it drift away from where they belong and start colliding with the next packet's, which is the "same" symptom as a stale time base even though nothing is out of order. CONFIG now carries the rate as a trailing uint64, alongside the publish-mode byte and read the same tolerant way: absent or zero means the producer did not say, and the hub falls back to its own timer as before. Anything below 1 kHz is not a high-resolution timer and is refused, so a mis-parsed payload cannot stretch a millisecond batch across seconds. The Accumulate DATA payload is unchanged, so this costs nothing per packet and the period *within* a batch is still estimated from the gap between packets. The Go, C and browser parsers already ignore trailer bytes they do not know, so they read the new CONFIG unchanged; none of them uses the HRT timestamp. Also corrects the Accumulate DATA layout in all three protocol documents: they described it as one snapshot per array signal, where it has always been one per accumulated cycle. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2162 lines
74 KiB
C++
2162 lines
74 KiB
C++
/**
|
||
* @file UDPStreamerTest.cpp
|
||
* @brief Source file for class UDPStreamerTest
|
||
* @date 13/05/2026
|
||
* @author Martino Ferrari
|
||
*
|
||
* @copyright Copyright 2015 F4E | European Joint Undertaking for ITER and
|
||
* the Development of Fusion Energy ('Fusion for Energy').
|
||
* Licensed under the EUPL, Version 1.1 or - as soon they will be approved
|
||
* by the European Commission - subsequent versions of the EUPL (the "Licence")
|
||
* You may not use this work except in compliance with the Licence.
|
||
* You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl
|
||
*
|
||
* @warning Unless required by applicable law or agreed to in writing,
|
||
* software distributed under the Licence is distributed on an "AS IS"
|
||
* basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
|
||
* or implied. See the Licence permissions and limitations under the Licence.
|
||
*
|
||
* @details This source file contains the definition of all the methods for
|
||
* the class UDPStreamerTest (public, protected, and private). Be aware that some
|
||
* methods, such as those inline could be defined on the header file, instead.
|
||
*/
|
||
|
||
#define DLL_API
|
||
|
||
/*---------------------------------------------------------------------------*/
|
||
/* Standard header includes */
|
||
/*---------------------------------------------------------------------------*/
|
||
|
||
/*---------------------------------------------------------------------------*/
|
||
/* Project header includes */
|
||
/*---------------------------------------------------------------------------*/
|
||
#include "AdvancedErrorManagement.h"
|
||
#include "BasicTCPSocket.h"
|
||
#include "BasicUDPSocket.h"
|
||
#include "ConfigurationDatabase.h"
|
||
#include "GAM.h"
|
||
#include "GAMScheduler.h"
|
||
#include "HighResolutionTimer.h"
|
||
#include "MemoryOperationsHelper.h"
|
||
#include "ObjectRegistryDatabase.h"
|
||
#include "RealTimeApplication.h"
|
||
#include "Sleep.h"
|
||
#include "StandardParser.h"
|
||
#include "UDPSClient.h"
|
||
#include "UDPStreamer.h"
|
||
#include "UDPStreamerTest.h"
|
||
|
||
/*---------------------------------------------------------------------------*/
|
||
/* Static definitions */
|
||
/*---------------------------------------------------------------------------*/
|
||
|
||
/**
|
||
* @brief Simple output GAM that writes fixed values to its output signals.
|
||
*/
|
||
class UDPStreamerTestOutputGAM : public MARTe::GAM {
|
||
public:
|
||
CLASS_REGISTER_DECLARATION()
|
||
|
||
UDPStreamerTestOutputGAM() :
|
||
GAM() {
|
||
}
|
||
|
||
~UDPStreamerTestOutputGAM() {
|
||
}
|
||
|
||
bool Execute() {
|
||
/* Write a fixed value to the first output signal if any */
|
||
for (MARTe::uint32 i = 0u; i < GetNumberOfOutputSignals(); i++) {
|
||
void *mem = GetOutputSignalMemory(i);
|
||
if (mem != NULL_PTR(void *)) {
|
||
MARTe::uint32 sz = 0u;
|
||
GetSignalByteSize(MARTe::OutputSignals, i, sz);
|
||
(void) MARTe::MemoryOperationsHelper::Set(mem, 0xAB, sz);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool Setup() {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
CLASS_REGISTER(UDPStreamerTestOutputGAM, "1.0")
|
||
|
||
/**
|
||
* @brief Helper: build a RealTimeApplication from an MARTe2 config string.
|
||
* Returns the application reference (invalid if parsing failed).
|
||
*/
|
||
static MARTe::ReferenceT<MARTe::RealTimeApplication> LoadApplication(
|
||
const MARTe::char8 *const config) {
|
||
using namespace MARTe;
|
||
|
||
ConfigurationDatabase cdb;
|
||
StreamString cfgStr = config;
|
||
(void) cfgStr.Seek(0LLU);
|
||
StandardParser parser(cfgStr, cdb);
|
||
if (!parser.Parse()) {
|
||
return ReferenceT<RealTimeApplication>();
|
||
}
|
||
|
||
ObjectRegistryDatabase *god = ObjectRegistryDatabase::Instance();
|
||
god->Purge();
|
||
if (!god->Initialise(cdb)) {
|
||
return ReferenceT<RealTimeApplication>();
|
||
}
|
||
|
||
ReferenceT<RealTimeApplication> app = god->Find("Test");
|
||
if (!app.IsValid()) {
|
||
return ReferenceT<RealTimeApplication>();
|
||
}
|
||
if (!app->ConfigureApplication()) {
|
||
return ReferenceT<RealTimeApplication>();
|
||
}
|
||
return app;
|
||
}
|
||
|
||
/**
|
||
* @brief Minimal MARTe2 configuration template for UDPStreamer tests.
|
||
* Replace __DATASOURCE_CONFIG__ with signal-level config.
|
||
*/
|
||
static const MARTe::char8 *const CONFIG_TEMPLATE =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Counter = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44600\n"
|
||
" MaxPayloadSize = 1400\n"
|
||
" Signals = {\n"
|
||
" Counter = {\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
/*---------------------------------------------------------------------------*/
|
||
/* Method definitions */
|
||
/*---------------------------------------------------------------------------*/
|
||
|
||
bool UDPStreamerTest::TestConstructor() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
bool ok = (ds.GetPort() == 44500u);
|
||
ok &= (ds.GetMaxPayloadSize() == 1400u);
|
||
ok &= !ds.IsClientConnected();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_Valid() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44501u);
|
||
cdb.Write("MaxPayloadSize", 1200u);
|
||
cdb.Write("CPUMask", 0x1u);
|
||
cdb.Write("StackSize", 524288u);
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = ds.Initialise(cdb);
|
||
ok &= (ds.GetPort() == 44501u);
|
||
ok &= (ds.GetMaxPayloadSize() == 1200u);
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_DefaultPort() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
/* Port intentionally omitted */
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = ds.Initialise(cdb);
|
||
ok &= (ds.GetPort() == 44500u);
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_InvalidMaxPayloadSize() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("MaxPayloadSize", 5u); /* Less than header size */
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = !ds.Initialise(cdb); /* Must fail */
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_ZeroStackSize() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("StackSize", 0u);
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = !ds.Initialise(cdb); /* Must fail */
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_AutoMode_Valid() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44502u);
|
||
cdb.Write("PublishingMode", "Accumulate");
|
||
cdb.Write("MinRefreshRate", 120.0);
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
return ds.Initialise(cdb);
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_AutoMode_MissingRefreshRate() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44503u);
|
||
cdb.Write("PublishingMode", "Accumulate");
|
||
/* MinRefreshRate intentionally omitted */
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
return !ds.Initialise(cdb); /* Must fail */
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_UnknownPublishingMode() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44504u);
|
||
cdb.Write("PublishingMode", "Invalid");
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
return !ds.Initialise(cdb); /* Must fail */
|
||
}
|
||
|
||
bool UDPStreamerTest::TestGetBrokerName_Output() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
StreamString brokerName = ds.GetBrokerName(cdb, OutputSignals);
|
||
return (brokerName == "MemoryMapSynchronisedOutputBroker");
|
||
}
|
||
|
||
bool UDPStreamerTest::TestGetBrokerName_Input() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
StreamString brokerName = ds.GetBrokerName(cdb, InputSignals);
|
||
return (brokerName == "");
|
||
}
|
||
|
||
bool UDPStreamerTest::TestAllocateMemory() {
|
||
using namespace MARTe;
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(CONFIG_TEMPLATE);
|
||
bool ok = app.IsValid();
|
||
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_BasicSignals() {
|
||
return TestAllocateMemory();
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_Quantized() {
|
||
using namespace MARTe;
|
||
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Pressure = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = float32\n"
|
||
" NumberOfElements = 4\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44602\n"
|
||
" Signals = {\n"
|
||
" Pressure = {\n"
|
||
" Type = float32\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 4\n"
|
||
" Unit = Pa\n"
|
||
" RangeMin = 0.0\n"
|
||
" RangeMax = 1000000.0\n"
|
||
" QuantizedType = uint16\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = app.IsValid();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_InvalidQuantOnInteger() {
|
||
using namespace MARTe;
|
||
|
||
/* Configure a uint32 signal with QuantizedType - must fail */
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44603u);
|
||
|
||
/* Build a minimal signalsDatabase-like config by direct UDPStreamer construction */
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase initCdb;
|
||
initCdb.Write("Port", 44603u);
|
||
initCdb.CreateRelative("Signals");
|
||
initCdb.CreateRelative("Counter");
|
||
initCdb.Write("Type", "uint32");
|
||
initCdb.Write("QuantizedType", "uint16");
|
||
initCdb.MoveToRoot();
|
||
|
||
/* Initialise should pass, but SetConfiguredDatabase would normally catch this.
|
||
We test the validation that happens during full application setup. */
|
||
bool ok = ds.Initialise(initCdb);
|
||
|
||
/* The invalid quant config will be caught during SetConfiguredDatabase
|
||
which happens as part of ConfigureApplication. We can't easily unit-test
|
||
SetConfiguredDatabase in isolation without a full app, so this test
|
||
verifies that Initialise passes and delegates validation to SetConfiguredDatabase. */
|
||
return ok; /* Initialise itself should succeed */
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_UnknownQuantType() {
|
||
using namespace MARTe;
|
||
/* We verify that an unknown QuantizedType string fails gracefully.
|
||
In a unit-test context without full app setup, we test the
|
||
signal metadata parsing logic via the Initialise path. */
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase initCdb;
|
||
initCdb.Write("Port", 44604u);
|
||
initCdb.CreateRelative("Signals");
|
||
initCdb.MoveToRoot();
|
||
bool ok = ds.Initialise(initCdb);
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_TimeModePacket() {
|
||
return TestAllocateMemory(); /* Default TimeMode is PacketTime; basic config uses it */
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_TimeModeFullArray() {
|
||
using namespace MARTe;
|
||
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Time = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint64\n"
|
||
" NumberOfElements = 4\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = float32\n"
|
||
" NumberOfElements = 4\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44605\n"
|
||
" Signals = {\n"
|
||
" Time = {\n"
|
||
" Type = uint64\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 4\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" Type = float32\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 4\n"
|
||
" TimeMode = FullArray\n"
|
||
" TimeSignal = Time\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = app.IsValid();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_TimeModeFirstSample() {
|
||
using namespace MARTe;
|
||
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" T0 = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint64\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = float32\n"
|
||
" NumberOfElements = 10\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44606\n"
|
||
" Signals = {\n"
|
||
" T0 = {\n"
|
||
" Type = uint64\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" Type = float32\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 10\n"
|
||
" TimeMode = FirstSample\n"
|
||
" TimeSignal = T0\n"
|
||
" SamplingRate = 1000.0\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = app.IsValid();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_MissingSamplingRate() {
|
||
using namespace MARTe;
|
||
|
||
/* Same as TimeModeFirstSample but without SamplingRate - must fail at SetConfiguredDatabase */
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" T0 = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint64\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = float32\n"
|
||
" NumberOfElements = 10\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44607\n"
|
||
" Signals = {\n"
|
||
" T0 = {\n"
|
||
" Type = uint64\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" Type = float32\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 10\n"
|
||
" TimeMode = FirstSample\n"
|
||
" TimeSignal = T0\n"
|
||
" /* SamplingRate intentionally omitted */\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = !app.IsValid(); /* Must fail */
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_InvalidTimeSignal() {
|
||
using namespace MARTe;
|
||
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Data = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = float32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44608\n"
|
||
" Signals = {\n"
|
||
" Data = {\n"
|
||
" Type = float32\n"
|
||
" TimeMode = FullArray\n"
|
||
" TimeSignal = DoesNotExist\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = !app.IsValid(); /* Must fail */
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSetConfiguredDatabase_FullArrayMismatch() {
|
||
using namespace MARTe;
|
||
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Time = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint64\n"
|
||
" NumberOfElements = 2\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = float32\n"
|
||
" NumberOfElements = 4\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44609\n"
|
||
" Signals = {\n"
|
||
" Time = {\n"
|
||
" Type = uint64\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 2\n"
|
||
" }\n"
|
||
" Data = {\n"
|
||
" Type = float32\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 4\n"
|
||
" TimeMode = FullArray\n"
|
||
" TimeSignal = Time\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = !app.IsValid(); /* Must fail */
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestPrepareNextState() {
|
||
using namespace MARTe;
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(CONFIG_TEMPLATE);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == MARTe::ErrorManagement::NoError);
|
||
}
|
||
|
||
/* Allow the background thread a moment to start */
|
||
Sleep::MSec(50u);
|
||
|
||
/* Verify the DataSource is accessible */
|
||
if (ok) {
|
||
ReferenceT<UDPStreamer> ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid();
|
||
if (ok) {
|
||
ok = !ds->IsClientConnected(); /* No client has connected yet */
|
||
}
|
||
}
|
||
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestSynchronise_NoClient() {
|
||
using namespace MARTe;
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(CONFIG_TEMPLATE);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == MARTe::ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(20u);
|
||
|
||
if (ok) {
|
||
ReferenceT<UDPStreamer> ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid();
|
||
if (ok) {
|
||
/* Synchronise with no client connected must succeed without crash */
|
||
ok = ds->Synchronise();
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(20u);
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestExecute_ConnectDataDisconnect() {
|
||
using namespace MARTe;
|
||
|
||
/* Use a dedicated port to avoid conflicts */
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Counter = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44610\n"
|
||
" MaxPayloadSize = 1400\n"
|
||
" Signals = {\n"
|
||
" Counter = {\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == MARTe::ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(50u);
|
||
|
||
/* Create a mock client socket: bind to a known port so the server knows where to reply */
|
||
BasicUDPSocket clientSock;
|
||
uint16 clientPort = 44611u;
|
||
bool sockOk = false;
|
||
if (ok) {
|
||
sockOk = clientSock.Open() && clientSock.Listen(clientPort);
|
||
ok &= sockOk;
|
||
}
|
||
|
||
/* Send CONNECT command from the bound client socket */
|
||
if (ok) {
|
||
sockOk = clientSock.Connect("127.0.0.1", 44610u);
|
||
if (sockOk) {
|
||
UDPSPacketHeader connectHdr;
|
||
connectHdr.magic = UDPS_MAGIC;
|
||
connectHdr.type = UDPS_TYPE_CONNECT;
|
||
connectHdr.counter = 0u;
|
||
connectHdr.fragmentIdx = 0u;
|
||
connectHdr.totalFragments = 1u;
|
||
connectHdr.payloadBytes = 0u;
|
||
uint32 sendSize = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
sockOk = clientSock.Write(reinterpret_cast<const char8 *>(&connectHdr), sendSize);
|
||
}
|
||
ok &= sockOk;
|
||
}
|
||
|
||
/* Wait for CONFIG to arrive */
|
||
Sleep::MSec(100u);
|
||
|
||
if (ok) {
|
||
uint8 recvBuf[2048u];
|
||
uint32 recvSize = static_cast<uint32>(sizeof(recvBuf));
|
||
TimeoutType timeout(500u);
|
||
bool received = clientSock.Read(reinterpret_cast<char8 *>(recvBuf), recvSize, timeout);
|
||
ok &= received;
|
||
if (received && (recvSize >= static_cast<uint32>(sizeof(UDPSPacketHeader)))) {
|
||
const UDPSPacketHeader *hdr =
|
||
reinterpret_cast<const UDPSPacketHeader *>(recvBuf);
|
||
ok &= (hdr->magic == UDPS_MAGIC);
|
||
ok &= (hdr->type == UDPS_TYPE_CONFIG);
|
||
|
||
/* The CONFIG trailer must carry this host's HRT tick rate: DATA
|
||
* packets timestamp with the raw counter, so a receiver on another
|
||
* machine has nothing to convert it with otherwise. */
|
||
const uint8 *payload = recvBuf + UDPS_HEADER_SIZE;
|
||
uint32 numSigs = 0u;
|
||
if (ok && (hdr->payloadBytes >= 4u)) {
|
||
(void) memcpy(&numSigs, payload, 4u);
|
||
}
|
||
const uint32 freqOff =
|
||
4u + (numSigs * UDPS_SIGNAL_DESC_SIZE) + 1u;
|
||
ok &= (hdr->payloadBytes >= (freqOff + 8u));
|
||
if (ok) {
|
||
uint64 wireFreq = 0u;
|
||
(void) memcpy(&wireFreq, payload + freqOff, 8u);
|
||
ok &= (wireFreq == HighResolutionTimer::Frequency());
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Trigger a Synchronise to generate a DATA packet */
|
||
if (ok) {
|
||
Sleep::MSec(20u);
|
||
ReferenceT<UDPStreamer> ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid();
|
||
if (ok) {
|
||
ok = ds->IsClientConnected();
|
||
}
|
||
if (ok) {
|
||
ok = ds->Synchronise();
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(50u);
|
||
|
||
/* Read the DATA packet */
|
||
if (ok) {
|
||
uint8 recvBuf[2048u];
|
||
uint32 recvSize = static_cast<uint32>(sizeof(recvBuf));
|
||
TimeoutType timeout(500u);
|
||
bool received = clientSock.Read(reinterpret_cast<char8 *>(recvBuf), recvSize, timeout);
|
||
ok &= received;
|
||
if (received && (recvSize >= static_cast<uint32>(sizeof(UDPSPacketHeader)))) {
|
||
const UDPSPacketHeader *hdr =
|
||
reinterpret_cast<const UDPSPacketHeader *>(recvBuf);
|
||
ok &= (hdr->magic == UDPS_MAGIC);
|
||
ok &= (hdr->type == UDPS_TYPE_DATA);
|
||
}
|
||
}
|
||
|
||
/* Send DISCONNECT from the same client socket */
|
||
if (ok) {
|
||
UDPSPacketHeader discHdr;
|
||
discHdr.magic = UDPS_MAGIC;
|
||
discHdr.type = UDPS_TYPE_DISCONNECT;
|
||
discHdr.counter = 0u;
|
||
discHdr.fragmentIdx = 0u;
|
||
discHdr.totalFragments = 1u;
|
||
discHdr.payloadBytes = 0u;
|
||
uint32 sendSize = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
(void) clientSock.Write(reinterpret_cast<const char8 *>(&discHdr), sendSize);
|
||
}
|
||
|
||
Sleep::MSec(50u);
|
||
(void) clientSock.Close();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestExecute_Fragmentation() {
|
||
using namespace MARTe;
|
||
|
||
/* Create a streamer with small MaxPayloadSize and a large signal to force fragmentation */
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" LargeSignal = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = float32\n"
|
||
" NumberOfElements = 512\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44620\n"
|
||
" MaxPayloadSize = 200\n"
|
||
" Signals = {\n"
|
||
" LargeSignal = {\n"
|
||
" Type = float32\n"
|
||
" NumberOfDimensions = 1\n"
|
||
" NumberOfElements = 512\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == MARTe::ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(50u);
|
||
|
||
/* Client socket bound so the server knows where to send fragments */
|
||
BasicUDPSocket clientSock;
|
||
if (ok) {
|
||
ok = clientSock.Open() && clientSock.Listen(44621u);
|
||
}
|
||
|
||
/* Send CONNECT from the bound client socket */
|
||
if (ok) {
|
||
bool s = clientSock.Connect("127.0.0.1", 44620u);
|
||
if (s) {
|
||
UDPSPacketHeader connectHdr;
|
||
connectHdr.magic = UDPS_MAGIC;
|
||
connectHdr.type = UDPS_TYPE_CONNECT;
|
||
connectHdr.counter = 0u;
|
||
connectHdr.fragmentIdx = 0u;
|
||
connectHdr.totalFragments = 1u;
|
||
connectHdr.payloadBytes = 0u;
|
||
uint32 sendSize = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
(void) clientSock.Write(reinterpret_cast<const char8 *>(&connectHdr), sendSize);
|
||
}
|
||
else {
|
||
ok = false;
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(100u);
|
||
|
||
/* Drain the CONFIG packet */
|
||
if (ok) {
|
||
uint8 buf[2048u];
|
||
uint32 sz = static_cast<uint32>(sizeof(buf));
|
||
TimeoutType to(500u);
|
||
bool received = true;
|
||
while (received) {
|
||
sz = static_cast<uint32>(sizeof(buf));
|
||
received = clientSock.Read(reinterpret_cast<char8 *>(buf), sz, TimeoutType(50u));
|
||
}
|
||
}
|
||
|
||
/* Trigger a data cycle */
|
||
if (ok) {
|
||
ReferenceT<UDPStreamer> ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid() && ds->IsClientConnected();
|
||
if (ok) {
|
||
ok = ds->Synchronise();
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(100u);
|
||
|
||
/* Count fragments received */
|
||
uint32 fragmentCount = 0u;
|
||
uint16 expectedTotal = 0u;
|
||
if (ok) {
|
||
bool receiving = true;
|
||
while (receiving) {
|
||
uint8 buf[512u];
|
||
uint32 sz = static_cast<uint32>(sizeof(buf));
|
||
receiving = clientSock.Read(reinterpret_cast<char8 *>(buf), sz, TimeoutType(50u));
|
||
if (receiving && (sz >= static_cast<uint32>(sizeof(UDPSPacketHeader)))) {
|
||
const UDPSPacketHeader *hdr =
|
||
reinterpret_cast<const UDPSPacketHeader *>(buf);
|
||
if (hdr->type == UDPS_TYPE_DATA) {
|
||
fragmentCount++;
|
||
expectedTotal = hdr->totalFragments;
|
||
}
|
||
}
|
||
}
|
||
/* 512 floats = 2048 bytes + 8 timestamp = 2056 bytes payload.
|
||
MaxPayloadSize=200, so chunk = 200-17=183 bytes. frags = ceil(2056/183) = 12 */
|
||
ok = (fragmentCount > 1u);
|
||
ok &= (fragmentCount == static_cast<uint32>(expectedTotal));
|
||
}
|
||
|
||
(void) clientSock.Close();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestQuantization_Uint16Extremes() {
|
||
using namespace MARTe;
|
||
|
||
/* Build a minimal UDPStreamer and invoke QuantizeAndSerialize directly via the
|
||
integration path: prepare a known signal value and verify the quantized output. */
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44630u);
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
|
||
/* We can't call SetConfiguredDatabase without a full app; test quantization
|
||
formula directly by computing expected values. */
|
||
float32 valueAtMin = 0.0f; /* should map to 0 */
|
||
float32 valueAtMax = 1000.0f; /* should map to 65535 */
|
||
float64 rMin = 0.0;
|
||
float64 rMax = 1000.0;
|
||
float64 rRange = rMax - rMin;
|
||
|
||
float64 normMin = (static_cast<float64>(valueAtMin) - rMin) / rRange;
|
||
float64 normMax = (static_cast<float64>(valueAtMax) - rMin) / rRange;
|
||
uint16 qMin = static_cast<uint16>(normMin * 65535.0);
|
||
uint16 qMax = static_cast<uint16>(normMax * 65535.0);
|
||
|
||
return (qMin == 0u) && (qMax == 65535u);
|
||
}
|
||
|
||
bool UDPStreamerTest::TestQuantization_Uint8Clamping() {
|
||
using namespace MARTe;
|
||
|
||
/* Test that out-of-range values are clamped to [0.0, 1.0] */
|
||
float64 rMin = 0.0;
|
||
float64 rRange = 100.0;
|
||
|
||
/* Value below min */
|
||
float64 rawBelow = -10.0;
|
||
float64 normBelow = (rawBelow - rMin) / rRange;
|
||
if (normBelow < 0.0) { normBelow = 0.0; }
|
||
uint8 qBelow = static_cast<uint8>(normBelow * 255.0);
|
||
|
||
/* Value above max */
|
||
float64 rawAbove = 200.0;
|
||
float64 normAbove = (rawAbove - rMin) / rRange;
|
||
if (normAbove > 1.0) { normAbove = 1.0; }
|
||
uint8 qAbove = static_cast<uint8>(normAbove * 255.0);
|
||
|
||
return (qBelow == 0u) && (qAbove == 255u);
|
||
}
|
||
|
||
bool UDPStreamerTest::TestGetPort() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 55000u);
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = ds.Initialise(cdb);
|
||
ok &= (ds.GetPort() == 55000u);
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestGetMaxPayloadSize() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("MaxPayloadSize", 800u);
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = ds.Initialise(cdb);
|
||
ok &= (ds.GetMaxPayloadSize() == 800u);
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestIsClientConnected_InitiallyFalse() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
return !ds.IsClientConnected();
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------*/
|
||
/* High-frequency packed-signal tests (4 × int16[1000] at 1 MSps) */
|
||
/*---------------------------------------------------------------------------*/
|
||
|
||
/* Reusable signal block for the high-frequency tests.
|
||
* 5 signals:
|
||
* T0 – uint64 scalar (time reference)
|
||
* Ch1-Ch4 – int16[1000], TimeMode = FirstSample, TimeSignal = T0, SR = 1 MSps
|
||
* Wire payload per DATA packet:
|
||
* 8 B (HRT prefix) + 8 B (T0) + 4 × 2000 B (int16[1000]) = 8016 B
|
||
* Fragment count at MaxPayloadSize=1400:
|
||
* chunk = 1400 - 17 = 1383 B → ceil(8016 / 1383) = 6 fragments
|
||
*/
|
||
/* MARTe2 StandardParser uses whitespace/newlines as delimiters.
|
||
* Semicolons are NOT statement separators — they are consumed as part of
|
||
* token values. All inline { key = val; key = val } blocks below have been
|
||
* rewritten to use one key-value pair per line. */
|
||
|
||
#define HF_FUNCTIONS_BLOCK \
|
||
" +Functions = {\n" \
|
||
" Class = ReferenceContainer\n" \
|
||
" +Writer = {\n" \
|
||
" Class = UDPStreamerTestOutputGAM\n" \
|
||
" OutputSignals = {\n" \
|
||
" T0 = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = uint64\n" \
|
||
" }\n" \
|
||
" Ch1 = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" }\n" \
|
||
" Ch2 = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" }\n" \
|
||
" Ch3 = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" }\n" \
|
||
" Ch4 = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" }\n"
|
||
|
||
#define HF_SIGNALS_BLOCK \
|
||
" Signals = {\n" \
|
||
" T0 = {\n" \
|
||
" Type = uint64\n" \
|
||
" }\n" \
|
||
" Ch1 = {\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfDimensions = 1\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" TimeMode = FirstSample\n" \
|
||
" TimeSignal = T0\n" \
|
||
" SamplingRate = 1000000.0\n" \
|
||
" }\n" \
|
||
" Ch2 = {\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfDimensions = 1\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" TimeMode = FirstSample\n" \
|
||
" TimeSignal = T0\n" \
|
||
" SamplingRate = 1000000.0\n" \
|
||
" }\n" \
|
||
" Ch3 = {\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfDimensions = 1\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" TimeMode = FirstSample\n" \
|
||
" TimeSignal = T0\n" \
|
||
" SamplingRate = 1000000.0\n" \
|
||
" }\n" \
|
||
" Ch4 = {\n" \
|
||
" Type = int16\n" \
|
||
" NumberOfDimensions = 1\n" \
|
||
" NumberOfElements = 1000\n" \
|
||
" TimeMode = FirstSample\n" \
|
||
" TimeSignal = T0\n" \
|
||
" SamplingRate = 1000000.0\n" \
|
||
" }\n" \
|
||
" }\n"
|
||
|
||
#define HF_TAIL_BLOCK \
|
||
" +Timings = {\n" \
|
||
" Class = TimingDataSource\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" +States = {\n" \
|
||
" Class = ReferenceContainer\n" \
|
||
" +State1 = {\n" \
|
||
" Class = RealTimeState\n" \
|
||
" +Threads = {\n" \
|
||
" Class = ReferenceContainer\n" \
|
||
" +Thread1 = {\n" \
|
||
" Class = RealTimeThread\n" \
|
||
" Functions = { Writer }\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" +Scheduler = {\n" \
|
||
" Class = GAMScheduler\n" \
|
||
" TimingDataSource = Timings\n" \
|
||
" }\n" \
|
||
"}\n"
|
||
|
||
static const MARTe::char8 *const HF_CFG_ALLOC =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
HF_FUNCTIONS_BLOCK
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44650\n"
|
||
" MaxPayloadSize = 1400\n"
|
||
HF_SIGNALS_BLOCK
|
||
" }\n"
|
||
HF_TAIL_BLOCK;
|
||
|
||
static const MARTe::char8 *const HF_CFG_FRAG =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
HF_FUNCTIONS_BLOCK
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44651\n"
|
||
" MaxPayloadSize = 1400\n"
|
||
HF_SIGNALS_BLOCK
|
||
" }\n"
|
||
HF_TAIL_BLOCK;
|
||
|
||
static const MARTe::char8 *const HF_CFG_INTEGRITY =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
HF_FUNCTIONS_BLOCK
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44653\n"
|
||
" MaxPayloadSize = 1400\n"
|
||
HF_SIGNALS_BLOCK
|
||
" }\n"
|
||
HF_TAIL_BLOCK;
|
||
|
||
bool UDPStreamerTest::TestHighFrequency_AllocateMemory() {
|
||
using namespace MARTe;
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(HF_CFG_ALLOC);
|
||
bool ok = app.IsValid();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestHighFrequency_Fragmentation() {
|
||
using namespace MARTe;
|
||
|
||
/* Expected payload size:
|
||
* 8 bytes HRT timestamp prefix
|
||
* + 8 bytes T0 (uint64)
|
||
* + 4 × 1000 × 2 bytes (Ch1-Ch4, int16[1000])
|
||
* = 8016 bytes
|
||
*
|
||
* MaxPayloadSize = 1400 → usable per fragment = 1400 - 17 = 1383 bytes
|
||
* Fragments = ceil(8016 / 1383) = 6
|
||
*/
|
||
static const uint16 EXPECTED_FRAGS = 6u;
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(HF_CFG_FRAG);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == MARTe::ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(50u);
|
||
|
||
BasicUDPSocket clientSock;
|
||
if (ok) {
|
||
ok = clientSock.Open() && clientSock.Listen(44652u);
|
||
}
|
||
if (ok) {
|
||
bool s = clientSock.Connect("127.0.0.1", 44651u);
|
||
if (s) {
|
||
UDPSPacketHeader connectHdr;
|
||
connectHdr.magic = UDPS_MAGIC;
|
||
connectHdr.type = UDPS_TYPE_CONNECT;
|
||
connectHdr.counter = 0u;
|
||
connectHdr.fragmentIdx = 0u;
|
||
connectHdr.totalFragments = 1u;
|
||
connectHdr.payloadBytes = 0u;
|
||
uint32 sz = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
(void) clientSock.Write(reinterpret_cast<const char8 *>(&connectHdr), sz);
|
||
}
|
||
else {
|
||
ok = false;
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(100u);
|
||
|
||
/* Drain CONFIG fragments */
|
||
if (ok) {
|
||
uint8 buf[2048u];
|
||
uint32 sz = static_cast<uint32>(sizeof(buf));
|
||
bool received = true;
|
||
while (received) {
|
||
sz = static_cast<uint32>(sizeof(buf));
|
||
received = clientSock.Read(reinterpret_cast<char8 *>(buf), sz, TimeoutType(50u));
|
||
}
|
||
}
|
||
|
||
/* Trigger one data cycle */
|
||
if (ok) {
|
||
ReferenceT<UDPStreamer> ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid() && ds->IsClientConnected();
|
||
if (ok) {
|
||
ok = ds->Synchronise();
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(100u);
|
||
|
||
/* Count DATA fragments */
|
||
uint32 fragmentCount = 0u;
|
||
uint16 reportedTotal = 0u;
|
||
if (ok) {
|
||
bool receiving = true;
|
||
while (receiving) {
|
||
uint8 buf[1500u];
|
||
uint32 sz = static_cast<uint32>(sizeof(buf));
|
||
receiving = clientSock.Read(reinterpret_cast<char8 *>(buf), sz, TimeoutType(50u));
|
||
if (receiving && sz >= static_cast<uint32>(sizeof(UDPSPacketHeader))) {
|
||
const UDPSPacketHeader *hdr =
|
||
reinterpret_cast<const UDPSPacketHeader *>(buf);
|
||
if (hdr->type == UDPS_TYPE_DATA) {
|
||
fragmentCount++;
|
||
reportedTotal = hdr->totalFragments;
|
||
}
|
||
}
|
||
}
|
||
ok = (fragmentCount == static_cast<uint32>(EXPECTED_FRAGS));
|
||
ok &= (reportedTotal == EXPECTED_FRAGS);
|
||
}
|
||
|
||
(void) clientSock.Close();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestHighFrequency_DataIntegrity() {
|
||
using namespace MARTe;
|
||
|
||
/* Reassemble all 6 DATA fragments and verify the total payload is 8016 bytes. */
|
||
static const uint32 EXPECTED_PAYLOAD = 8016u;
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(HF_CFG_INTEGRITY);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == MARTe::ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(50u);
|
||
|
||
BasicUDPSocket clientSock;
|
||
if (ok) {
|
||
ok = clientSock.Open() && clientSock.Listen(44654u);
|
||
}
|
||
if (ok) {
|
||
bool s = clientSock.Connect("127.0.0.1", 44653u);
|
||
if (s) {
|
||
UDPSPacketHeader connectHdr;
|
||
connectHdr.magic = UDPS_MAGIC;
|
||
connectHdr.type = UDPS_TYPE_CONNECT;
|
||
connectHdr.counter = 0u;
|
||
connectHdr.fragmentIdx = 0u;
|
||
connectHdr.totalFragments = 1u;
|
||
connectHdr.payloadBytes = 0u;
|
||
uint32 sz = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
(void) clientSock.Write(reinterpret_cast<const char8 *>(&connectHdr), sz);
|
||
}
|
||
else {
|
||
ok = false;
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(100u);
|
||
|
||
/* Drain CONFIG */
|
||
if (ok) {
|
||
uint8 buf[4096u];
|
||
uint32 sz;
|
||
bool received = true;
|
||
while (received) {
|
||
sz = static_cast<uint32>(sizeof(buf));
|
||
received = clientSock.Read(reinterpret_cast<char8 *>(buf), sz, TimeoutType(50u));
|
||
}
|
||
}
|
||
|
||
/* Trigger data */
|
||
if (ok) {
|
||
ReferenceT<UDPStreamer> ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid() && ds->IsClientConnected();
|
||
if (ok) {
|
||
ok = ds->Synchronise();
|
||
}
|
||
}
|
||
|
||
Sleep::MSec(100u);
|
||
|
||
/* Collect and reassemble DATA fragments */
|
||
uint32 reassembledBytes = 0u;
|
||
if (ok) {
|
||
/* Maximum possible payload: 8016 bytes */
|
||
static const uint32 MAX_PAYLOAD = 10000u;
|
||
uint8 assembled[MAX_PAYLOAD];
|
||
(void) MemoryOperationsHelper::Set(assembled, 0, MAX_PAYLOAD);
|
||
|
||
bool receiving = true;
|
||
uint16 totalFrags = 0u;
|
||
uint32 receivedFrags = 0u;
|
||
|
||
while (receiving) {
|
||
uint8 buf[1500u];
|
||
uint32 sz = static_cast<uint32>(sizeof(buf));
|
||
receiving = clientSock.Read(reinterpret_cast<char8 *>(buf), sz, TimeoutType(100u));
|
||
if (!receiving || sz < static_cast<uint32>(sizeof(UDPSPacketHeader))) {
|
||
continue;
|
||
}
|
||
const UDPSPacketHeader *hdr =
|
||
reinterpret_cast<const UDPSPacketHeader *>(buf);
|
||
if (hdr->type != UDPS_TYPE_DATA) {
|
||
continue;
|
||
}
|
||
|
||
totalFrags = hdr->totalFragments;
|
||
receivedFrags++;
|
||
|
||
/* Copy this fragment's payload into the assembly buffer */
|
||
uint32 fragPayload = hdr->payloadBytes;
|
||
uint32 fragOffset = static_cast<uint32>(hdr->fragmentIdx) *
|
||
(1400u - static_cast<uint32>(sizeof(UDPSPacketHeader)));
|
||
if ((fragOffset + fragPayload) <= MAX_PAYLOAD) {
|
||
(void) MemoryOperationsHelper::Copy(
|
||
&assembled[fragOffset],
|
||
buf + sizeof(UDPSPacketHeader),
|
||
fragPayload);
|
||
reassembledBytes += fragPayload;
|
||
}
|
||
}
|
||
|
||
ok = (receivedFrags == static_cast<uint32>(totalFrags));
|
||
ok &= (reassembledBytes == EXPECTED_PAYLOAD);
|
||
}
|
||
|
||
(void) clientSock.Close();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
/* ============================================================
|
||
* Multicast mode tests (ports 44710-44729)
|
||
* ============================================================ */
|
||
|
||
bool UDPStreamerTest::TestInitialise_MulticastMode_Valid() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44710u);
|
||
cdb.Write("MulticastGroup", "239.0.0.1");
|
||
cdb.Write("Interface", "127.0.0.1");
|
||
cdb.Write("DataPort", 44711u);
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = ds.Initialise(cdb);
|
||
ok &= ds.IsMulticast();
|
||
ok &= (ds.GetPort() == 44710u);
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_MulticastMode_DefaultDataPort() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44712u);
|
||
cdb.Write("MulticastGroup", "239.0.0.1");
|
||
cdb.Write("Interface", "127.0.0.1");
|
||
/* DataPort intentionally omitted: should default to 44713 */
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
bool ok = ds.Initialise(cdb);
|
||
ok &= ds.IsMulticast();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestInitialise_MulticastMode_InvalidDataPort() {
|
||
using namespace MARTe;
|
||
UDPStreamer ds;
|
||
ConfigurationDatabase cdb;
|
||
cdb.Write("Port", 44714u);
|
||
cdb.Write("MulticastGroup", "239.0.0.1");
|
||
/* Interface is mandatory for multicast; supply it so the rejection below
|
||
* is provably caused by DataPort == Port and not by a missing Interface. */
|
||
cdb.Write("Interface", "127.0.0.1");
|
||
cdb.Write("DataPort", 44714u); /* same as Port — must be rejected */
|
||
cdb.CreateRelative("Signals");
|
||
cdb.MoveToRoot();
|
||
return !ds.Initialise(cdb);
|
||
}
|
||
|
||
bool UDPStreamerTest::TestPrepareNextState_Multicast() {
|
||
using namespace MARTe;
|
||
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Counter = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44716\n"
|
||
" MulticastGroup = \"239.0.0.1\"\n"
|
||
" Interface = \"127.0.0.1\"\n"
|
||
" DataPort = 44717\n"
|
||
" MaxPayloadSize = 1400\n"
|
||
" Signals = {\n"
|
||
" Counter = {\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(50u);
|
||
|
||
ReferenceT<UDPStreamer> ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
if (ok) {
|
||
ok = ds.IsValid();
|
||
}
|
||
if (ok) {
|
||
ok = ds->IsMulticast();
|
||
}
|
||
if (ok) {
|
||
ok = !ds->IsClientConnected(); /* no client connected yet */
|
||
}
|
||
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
bool UDPStreamerTest::TestExecute_MulticastConnectDataDisconnect() {
|
||
using namespace MARTe;
|
||
|
||
static const char8 *const cfg =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
" +Functions = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Writer = {\n"
|
||
" Class = UDPStreamerTestOutputGAM\n"
|
||
" OutputSignals = {\n"
|
||
" Counter = {\n"
|
||
" DataSource = Streamer\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44720\n"
|
||
" MulticastGroup = \"239.0.0.1\"\n"
|
||
" Interface = \"127.0.0.1\"\n"
|
||
" DataPort = 44721\n"
|
||
" MaxPayloadSize = 1400\n"
|
||
" Signals = {\n"
|
||
" Counter = {\n"
|
||
" Type = uint32\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Timings = {\n"
|
||
" Class = TimingDataSource\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +States = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +State1 = {\n"
|
||
" Class = RealTimeState\n"
|
||
" +Threads = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Thread1 = {\n"
|
||
" Class = RealTimeThread\n"
|
||
" Functions = { Writer }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
" +Scheduler = {\n"
|
||
" Class = GAMScheduler\n"
|
||
" TimingDataSource = Timings\n"
|
||
" }\n"
|
||
"}\n";
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(cfg);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(100u);
|
||
|
||
/* Step 1: TCP CONNECT to control port 44720 */
|
||
BasicTCPSocket clientTCP;
|
||
if (ok) {
|
||
ok = clientTCP.Open();
|
||
}
|
||
if (ok) {
|
||
ok = clientTCP.Connect("127.0.0.1", 44720u, TimeoutType(2000u));
|
||
}
|
||
|
||
/* Send CONNECT packet over TCP */
|
||
if (ok) {
|
||
UDPSPacketHeader connectHdr;
|
||
connectHdr.magic = UDPS_MAGIC;
|
||
connectHdr.type = UDPS_TYPE_CONNECT;
|
||
connectHdr.counter = 0u;
|
||
connectHdr.fragmentIdx = 0u;
|
||
connectHdr.totalFragments = 1u;
|
||
connectHdr.payloadBytes = 0u;
|
||
uint32 sendSz = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
ok = clientTCP.Write(reinterpret_cast<const char8 *>(&connectHdr), sendSz);
|
||
}
|
||
|
||
/* Step 2: Read CONFIG from TCP (header then payload) */
|
||
if (ok) {
|
||
uint8 cfgHdrBuf[sizeof(UDPSPacketHeader)];
|
||
uint32 recvSz = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
ok = clientTCP.Read(reinterpret_cast<char8 *>(cfgHdrBuf), recvSz, TimeoutType(2000u));
|
||
if (ok) {
|
||
const UDPSPacketHeader *cfgHdr =
|
||
reinterpret_cast<const UDPSPacketHeader *>(cfgHdrBuf);
|
||
ok = (cfgHdr->magic == UDPS_MAGIC) && (cfgHdr->type == UDPS_TYPE_CONFIG);
|
||
if (ok && (cfgHdr->payloadBytes > 0u)) {
|
||
/* Drain the payload so the TCP stream is clean */
|
||
HeapI *heap = GlobalObjectsDatabase::Instance()->GetStandardHeap();
|
||
uint8 *payload = reinterpret_cast<uint8 *>(
|
||
heap->Malloc(cfgHdr->payloadBytes));
|
||
uint32 plSz = cfgHdr->payloadBytes;
|
||
(void) clientTCP.Read(reinterpret_cast<char8 *>(payload), plSz,
|
||
TimeoutType(2000u));
|
||
heap->Free(reinterpret_cast<void *&>(payload));
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Step 3: Join multicast group 239.0.0.1 on data port 44721 */
|
||
BasicUDPSocket mcastReader;
|
||
if (ok) {
|
||
ok = mcastReader.Open();
|
||
}
|
||
if (ok) {
|
||
ok = mcastReader.Listen(44721u);
|
||
}
|
||
if (ok) {
|
||
/* Join on the same interface the streamer sends from (Interface =
|
||
* 127.0.0.1 sets IP_MULTICAST_IF on the server's data socket). The
|
||
* single-argument Join() would pass INADDR_ANY, letting the kernel
|
||
* pick the default-route interface, and the datagram would never
|
||
* reach this socket. */
|
||
ok = mcastReader.Join("239.0.0.1", "127.0.0.1");
|
||
}
|
||
|
||
/* Step 4: Trigger Synchronise() to generate a DATA packet */
|
||
if (ok) {
|
||
ReferenceT<UDPStreamer> ds =
|
||
ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid() && ds->IsClientConnected();
|
||
if (ok) {
|
||
ok = ds->Synchronise();
|
||
}
|
||
}
|
||
Sleep::MSec(100u);
|
||
|
||
/* Step 5: Receive at least one DATA fragment from the multicast group */
|
||
if (ok) {
|
||
uint8 dataBuf[2048u];
|
||
uint32 dataSz = static_cast<uint32>(sizeof(dataBuf));
|
||
bool received = mcastReader.Read(reinterpret_cast<char8 *>(dataBuf), dataSz,
|
||
TimeoutType(500u));
|
||
ok = received;
|
||
if (ok && (dataSz >= static_cast<uint32>(sizeof(UDPSPacketHeader)))) {
|
||
const UDPSPacketHeader *dHdr =
|
||
reinterpret_cast<const UDPSPacketHeader *>(dataBuf);
|
||
ok = (dHdr->magic == UDPS_MAGIC) && (dHdr->type == UDPS_TYPE_DATA);
|
||
}
|
||
}
|
||
|
||
/* Step 6: Send DISCONNECT via TCP */
|
||
if (clientTCP.IsValid()) {
|
||
UDPSPacketHeader disPkt;
|
||
disPkt.magic = UDPS_MAGIC;
|
||
disPkt.type = UDPS_TYPE_DISCONNECT;
|
||
disPkt.counter = 0u;
|
||
disPkt.fragmentIdx = 0u;
|
||
disPkt.totalFragments = 1u;
|
||
disPkt.payloadBytes = 0u;
|
||
uint32 disSz = static_cast<uint32>(sizeof(UDPSPacketHeader));
|
||
(void) clientTCP.Write(reinterpret_cast<const char8 *>(&disPkt), disSz);
|
||
(void) clientTCP.Close();
|
||
}
|
||
(void) mcastReader.Close();
|
||
Sleep::MSec(50u);
|
||
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------*/
|
||
/* Accumulate publication continuity */
|
||
/*---------------------------------------------------------------------------*/
|
||
|
||
/* Four float64 scalars, no quantisation: 32 wire bytes per RT cycle.
|
||
* With MaxPayloadSize = 60 the accumulate header (8 B HRT + 4 B count) leaves
|
||
* room for exactly one cycle, so the size condition flushes on every single
|
||
* Synchronise() — the maximum number of hand-offs to the sender thread, each
|
||
* one a chance for a promoted batch to be skipped. */
|
||
#define ACC_FUNCTIONS_BLOCK \
|
||
" +Functions = {\n" \
|
||
" Class = ReferenceContainer\n" \
|
||
" +Writer = {\n" \
|
||
" Class = UDPStreamerTestOutputGAM\n" \
|
||
" OutputSignals = {\n" \
|
||
" A = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = float64\n" \
|
||
" }\n" \
|
||
" B = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = float64\n" \
|
||
" }\n" \
|
||
" C = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = float64\n" \
|
||
" }\n" \
|
||
" D = {\n" \
|
||
" DataSource = Streamer\n" \
|
||
" Type = float64\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" }\n" \
|
||
" }\n"
|
||
|
||
static const MARTe::char8 *const ACC_CFG_CONTINUITY =
|
||
"+Test = {\n"
|
||
" Class = RealTimeApplication\n"
|
||
ACC_FUNCTIONS_BLOCK
|
||
" +Data = {\n"
|
||
" Class = ReferenceContainer\n"
|
||
" +Streamer = {\n"
|
||
" Class = UDPStreamer\n"
|
||
" Port = 44680\n"
|
||
" MaxPayloadSize = 60\n"
|
||
" PublishingMode = Accumulate\n"
|
||
" MinRefreshRate = 1000.0\n"
|
||
" Signals = {\n"
|
||
" A = {\n"
|
||
" Type = float64\n"
|
||
" }\n"
|
||
" B = {\n"
|
||
" Type = float64\n"
|
||
" }\n"
|
||
" C = {\n"
|
||
" Type = float64\n"
|
||
" }\n"
|
||
" D = {\n"
|
||
" Type = float64\n"
|
||
" }\n"
|
||
" }\n"
|
||
" }\n"
|
||
HF_TAIL_BLOCK;
|
||
|
||
namespace {
|
||
|
||
/** Cycles driven by TestAccumulate_EveryPublishedCycleReachesTheWire. */
|
||
static const MARTe::uint32 ACC_CONTINUITY_CYCLES = 3000u;
|
||
|
||
/**
|
||
* @brief Records which RT cycles reached the wire, and how often.
|
||
*
|
||
* The test stamps signal A with the cycle index before every Synchronise(),
|
||
* and the config is sized so each Accumulate batch carries exactly one cycle.
|
||
* The payload is [8 B HRT][4 B numSamples][A][B][C][D], so A of the single
|
||
* slot sits at offset 12 and identifies the cycle unambiguously.
|
||
*
|
||
* Counting distinct cycles (rather than summing numSamples) is what makes this
|
||
* able to tell a lost publication from a re-sent one: a sender that never
|
||
* consumes its ready buffer emits the right *number* of packets while
|
||
* repeating a stale batch, which shows up here as duplicates plus missing
|
||
* cycles instead of a clean tally.
|
||
*/
|
||
class AccumRampRecorder: public MARTe::UDPSClientListener {
|
||
public:
|
||
AccumRampRecorder() :
|
||
packets(0u), duplicates(0u), malformed(0u) {
|
||
mux.Create();
|
||
for (MARTe::uint32 i = 0u; i < ACC_CONTINUITY_CYCLES; i++) {
|
||
seen[i] = false;
|
||
}
|
||
}
|
||
|
||
virtual void OnUDPSData(const MARTe::uint8 *payload, MARTe::uint32 payloadSize) {
|
||
MARTe::uint32 n = 0u;
|
||
MARTe::float64 v = 0.0;
|
||
if (payloadSize >= 20u) {
|
||
(void) MARTe::MemoryOperationsHelper::Copy(&n, &payload[8], 4u);
|
||
(void) MARTe::MemoryOperationsHelper::Copy(&v, &payload[12], 8u);
|
||
}
|
||
(void) mux.FastLock();
|
||
packets++;
|
||
if ((payloadSize < 20u) || (n != 1u)) {
|
||
malformed++;
|
||
}
|
||
else {
|
||
MARTe::uint32 idx = static_cast<MARTe::uint32>(v);
|
||
if ((static_cast<MARTe::float64>(idx) != v) || (idx >= ACC_CONTINUITY_CYCLES)) {
|
||
malformed++;
|
||
}
|
||
else if (seen[idx]) {
|
||
duplicates++;
|
||
}
|
||
else {
|
||
seen[idx] = true;
|
||
}
|
||
}
|
||
mux.FastUnLock();
|
||
}
|
||
|
||
MARTe::uint32 DistinctCycles() {
|
||
(void) mux.FastLock();
|
||
MARTe::uint32 n = 0u;
|
||
for (MARTe::uint32 i = 0u; i < ACC_CONTINUITY_CYCLES; i++) {
|
||
if (seen[i]) {
|
||
n++;
|
||
}
|
||
}
|
||
mux.FastUnLock();
|
||
return n;
|
||
}
|
||
|
||
MARTe::uint32 Packets() {
|
||
(void) mux.FastLock();
|
||
MARTe::uint32 n = packets;
|
||
mux.FastUnLock();
|
||
return n;
|
||
}
|
||
|
||
MARTe::uint32 Duplicates() {
|
||
(void) mux.FastLock();
|
||
MARTe::uint32 n = duplicates;
|
||
mux.FastUnLock();
|
||
return n;
|
||
}
|
||
|
||
MARTe::uint32 Malformed() {
|
||
(void) mux.FastLock();
|
||
MARTe::uint32 n = malformed;
|
||
mux.FastUnLock();
|
||
return n;
|
||
}
|
||
|
||
private:
|
||
MARTe::FastPollingMutexSem mux;
|
||
bool seen[ACC_CONTINUITY_CYCLES];
|
||
MARTe::uint32 packets;
|
||
MARTe::uint32 duplicates;
|
||
MARTe::uint32 malformed;
|
||
};
|
||
|
||
} // namespace
|
||
|
||
bool UDPStreamerTest::TestAccumulate_EveryPublishedCycleReachesTheWire() {
|
||
using namespace MARTe;
|
||
|
||
/* One-cycle batches every 200 us: ~5000 small packets/s, which the sender
|
||
* thread handles comfortably. The period has to be this short because a
|
||
* wake-up can only be swallowed while the sender is mid-send; at 1 ms the
|
||
* sender is always back in its wait before the next Synchronise() and the
|
||
* defect never fires at all. */
|
||
const uint32 CYCLES = ACC_CONTINUITY_CYCLES;
|
||
static const float64 CYCLE_SEC = 200e-6;
|
||
|
||
/* Tolerance, as a fraction of CYCLES, for cycles that never reach the wire.
|
||
* It is not zero: this is an ordinary userspace thread on a general-purpose
|
||
* kernel, so it can occasionally be descheduled past a 200 us slot, and the
|
||
* last batch may still be in the accumulation buffer when the loop ends.
|
||
* It is small because the defect this guards against is not marginal — a
|
||
* sender that decides what to send from the semaphore edge fails to consume
|
||
* essentially every batch (~100% here), so a 1% ceiling separates the two
|
||
* regimes with three orders of magnitude to spare. */
|
||
const uint32 MAX_LOST = CYCLES / 100u;
|
||
|
||
ReferenceT<RealTimeApplication> app = LoadApplication(ACC_CFG_CONTINUITY);
|
||
bool ok = app.IsValid();
|
||
if (ok) {
|
||
ok = (app->PrepareNextState("State1") == ErrorManagement::NoError);
|
||
}
|
||
Sleep::MSec(50u);
|
||
|
||
AccumRampRecorder counter;
|
||
UDPSClient client;
|
||
ReferenceT<UDPStreamer> ds;
|
||
if (ok) {
|
||
ConfigurationDatabase clientCfg;
|
||
ok = clientCfg.Write("ServerAddr", "127.0.0.1");
|
||
ok = ok && clientCfg.Write("Port", 44680u);
|
||
ok = ok && clientCfg.Write("SilenceTimeout", 0.0f);
|
||
ok = ok && clientCfg.Write("KeepAliveInterval", 0u);
|
||
client.SetListener(&counter);
|
||
ok = ok && client.Initialise(clientCfg);
|
||
ok = ok && client.Start();
|
||
}
|
||
|
||
/* Wait for the CONNECT to register on the streamer side. */
|
||
if (ok) {
|
||
ds = ObjectRegistryDatabase::Instance()->Find("Test.Data.Streamer");
|
||
ok = ds.IsValid();
|
||
}
|
||
if (ok) {
|
||
uint32 waited = 0u;
|
||
while ((waited < 3000u) && !ds->IsClientConnected()) {
|
||
Sleep::MSec(20u);
|
||
waited += 20u;
|
||
}
|
||
ok = ds->IsClientConnected();
|
||
}
|
||
|
||
/* Signal A carries the cycle index, so every packet identifies exactly
|
||
* which RT cycle produced it. Synchronise() snapshots the DataSource
|
||
* memory, so writing straight into it is equivalent to a GAM having
|
||
* produced the value. */
|
||
float64 *sigA = NULL_PTR(float64 *);
|
||
if (ok) {
|
||
void *addr = NULL_PTR(void *);
|
||
ok = ds->GetSignalMemoryBuffer(0u, 0u, addr);
|
||
sigA = reinterpret_cast<float64 *>(addr);
|
||
ok = ok && (sigA != NULL_PTR(float64 *));
|
||
}
|
||
|
||
/* Drive the RT cycles. */
|
||
if (ok) {
|
||
for (uint32 i = 0u; (i < CYCLES) && ok; i++) {
|
||
*sigA = static_cast<float64>(i);
|
||
ok = ds->Synchronise();
|
||
Sleep::Sec(CYCLE_SEC);
|
||
}
|
||
}
|
||
|
||
/* Let the last packets drain. */
|
||
Sleep::MSec(300u);
|
||
|
||
uint32 distinct = counter.DistinctCycles();
|
||
uint32 packets = counter.Packets();
|
||
uint32 duplicates = counter.Duplicates();
|
||
uint32 malformed = counter.Malformed();
|
||
uint32 dropped = (ds.IsValid()) ? ds->GetDroppedPublications() : 0u;
|
||
|
||
if (ok) {
|
||
ok = (malformed == 0u);
|
||
if (!ok) {
|
||
REPORT_ERROR_STATIC(ErrorManagement::FatalError,
|
||
"%u of %u DATA packets did not carry exactly one "
|
||
"decodable cycle index.", malformed, packets);
|
||
}
|
||
}
|
||
if (ok) {
|
||
/* A cycle that never arrives is a hole in the consumer's time series. */
|
||
ok = (distinct + MAX_LOST) >= CYCLES;
|
||
if (!ok) {
|
||
REPORT_ERROR_STATIC(ErrorManagement::FatalError,
|
||
"Accumulate lost cycles: %u of %u reached the wire "
|
||
"in %u packets (%u duplicates, %u publications "
|
||
"overwritten before being sent).",
|
||
distinct, CYCLES, packets, duplicates, dropped);
|
||
}
|
||
}
|
||
if (ok) {
|
||
/* A cycle that arrives twice means the sender re-sent a ready buffer it
|
||
* had already transmitted, which lands the same samples on the receiver
|
||
* under two different time bases. */
|
||
ok = (duplicates == 0u);
|
||
if (!ok) {
|
||
REPORT_ERROR_STATIC(ErrorManagement::FatalError,
|
||
"%u of %u DATA packets repeated a cycle already sent.",
|
||
duplicates, packets);
|
||
}
|
||
}
|
||
if (ok) {
|
||
/* Same ceiling from the producer's side: it sees the overwrite directly
|
||
* and does not depend on the packet reaching the loopback socket. */
|
||
ok = (dropped <= MAX_LOST);
|
||
if (!ok) {
|
||
REPORT_ERROR_STATIC(ErrorManagement::FatalError,
|
||
"%u of %u publications were overwritten before the "
|
||
"sender thread took them.", dropped, CYCLES);
|
||
}
|
||
}
|
||
|
||
(void) client.Stop();
|
||
ObjectRegistryDatabase::Instance()->Purge();
|
||
return ok;
|
||
}
|