implemented array support on client and server

CMakeLists.txt

@@ -1,60 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project(marte_dev)
-
-if(NOT DEFINED ENV{MARTe2_DIR})
-    message(FATAL_ERROR "MARTe2_DIR not set. Please source env.sh")
-endif()
-
-set(MARTe2_DIR $ENV{MARTe2_DIR})
-set(MARTe2_Components_DIR $ENV{MARTe2_Components_DIR})
-set(TARGET $ENV{TARGET})
-
-# Define Architecture macros
-add_definitions(-DARCHITECTURE=x86_gcc)
-add_definitions(-DENVIRONMENT=Linux)
-add_definitions(-DMARTe2_TEST_ENVIRONMENT=GTest) # Optional
-add_definitions(-DUSE_PTHREAD)
-
-# Add -pthread flag
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-
-include_directories(
-    ${MARTe2_DIR}/Source/Core/BareMetal/L0Types
-    ${MARTe2_DIR}/Source/Core/BareMetal/L1Portability
-    ${MARTe2_DIR}/Source/Core/BareMetal/L2Objects
-    ${MARTe2_DIR}/Source/Core/BareMetal/L3Streams
-    ${MARTe2_DIR}/Source/Core/BareMetal/L4Configuration
-    ${MARTe2_DIR}/Source/Core/BareMetal/L4Events
-    ${MARTe2_DIR}/Source/Core/BareMetal/L4Logger
-    ${MARTe2_DIR}/Source/Core/BareMetal/L4Messages
-    ${MARTe2_DIR}/Source/Core/BareMetal/L5FILES
-    ${MARTe2_DIR}/Source/Core/BareMetal/L5GAMs
-    ${MARTe2_DIR}/Source/Core/BareMetal/L6App
-    ${MARTe2_DIR}/Source/Core/Scheduler/L1Portability
-    ${MARTe2_DIR}/Source/Core/Scheduler/L3Services
-    ${MARTe2_DIR}/Source/Core/Scheduler/L4LoggerService
-    ${MARTe2_DIR}/Source/Core/FileSystem/L1Portability
-    ${MARTe2_DIR}/Source/Core/FileSystem/L3Streams
-    ${MARTe2_DIR}/Source/Core/Scheduler/L5GAMs 
-    ${MARTe2_Components_DIR}/Source/Components/DataSources/EpicsDataSource
-    ${MARTe2_Components_DIR}/Source/Components/DataSources/FileDataSource
-    ${MARTe2_Components_DIR}/Source/Components/GAMs/IOGAM
-    Source
-    Headers
-)
-
-file(GLOB_RECURSE SOURCES "Source/*.cpp")
-
-add_library(${PROJECT_NAME} SHARED ${SOURCES})
-
-# Target MARTe2 library
-set(MARTe2_LIB ${MARTe2_DIR}/Build/${TARGET}/Core/libMARTe2.so)
-set(IOGAM_LIB ${MARTe2_Components_DIR}/Build/${TARGET}/Components/GAMs/IOGAM/libIOGAM.so)
-set(LinuxTimer_LIB ${MARTe2_Components_DIR}/Build/${TARGET}/Components/DataSources/LinuxTimer/libLinuxTimer.so)
-
-target_link_libraries(${PROJECT_NAME}
-    ${MARTe2_LIB}
-)
-
-add_subdirectory(Test/UnitTests)
-add_subdirectory(Test/Integration)

Headers/DebugBrokerWrapper.h

@@ -1,165 +0,0 @@
-#ifndef DEBUGBROKERWRAPPER_H
-#define DEBUGBROKERWRAPPER_H
-
-#include "DebugService.h"
-#include "BrokerI.h"
-#include "MemoryMapBroker.h"
-#include "ObjectRegistryDatabase.h"
-#include "ObjectBuilder.h"
-
-// Original broker headers
-#include "MemoryMapInputBroker.h"
-#include "MemoryMapOutputBroker.h"
-#include "MemoryMapSynchronisedInputBroker.h"
-#include "MemoryMapSynchronisedOutputBroker.h"
-#include "MemoryMapInterpolatedInputBroker.h"
-#include "MemoryMapMultiBufferInputBroker.h"
-#include "MemoryMapMultiBufferOutputBroker.h"
-#include "MemoryMapSynchronisedMultiBufferInputBroker.h"
-#include "MemoryMapSynchronisedMultiBufferOutputBroker.h"
-
-namespace MARTe {
-
-/**
- * @brief Base implementation for all debug brokers.
- */
-class DebugBrokerHelper {
-public:
-    static void Process(BrokerI* broker, DebugService* service, DebugSignalInfo** signalInfoPointers, uint32 numSignals) {
-        if (service == NULL_PTR(DebugService*)) return;
-
-        while (service->IsPaused()) {
-            Sleep::MSec(10);
-        }
-
-        if (signalInfoPointers != NULL_PTR(DebugSignalInfo**)) {
-            for (uint32 i = 0; i < numSignals; i++) {
-                DebugSignalInfo *s = signalInfoPointers[i];
-                if (s != NULL_PTR(DebugSignalInfo*)) {
-                    if (s->isTracing || s->isForcing) {
-                        uint32 size = broker->GetCopyByteSize(i);
-                        service->ProcessSignal(s, size);
-                    }
-                }
-            }
-        }
-    }
-
-    static void InitSignals(MemoryMapBroker* broker, DataSourceI &dataSourceIn, DebugService* &service, DebugSignalInfo** &signalInfoPointers, uint32 &numSignals, MemoryMapBrokerCopyTableEntry* copyTable, const char8* functionName, SignalDirection direction) {
-        numSignals = broker->GetNumberOfCopies();
-        if (numSignals > 0) {
-            signalInfoPointers = new DebugSignalInfo*[numSignals];
-            for (uint32 i=0; i<numSignals; i++) signalInfoPointers[i] = NULL_PTR(DebugSignalInfo*);
-        }
-
-        ReferenceContainer *root = ObjectRegistryDatabase::Instance();
-        Reference serviceRef = root->Find("DebugService");
-        if (serviceRef.IsValid()) {
-            service = dynamic_cast<DebugService*>(serviceRef.operator->());
-        }
-
-        if (service && (copyTable != NULL_PTR(MemoryMapBrokerCopyTableEntry*))) {
-            StreamString dsPath;
-            DebugService::GetFullObjectName(dataSourceIn, dsPath);
-
-            for (uint32 i = 0; i < numSignals; i++) {
-                void *addr = copyTable[i].dataSourcePointer;
-                TypeDescriptor type = copyTable[i].type;
-                
-                uint32 dsIdx = broker->GetDSCopySignalIndex(i);
-                StreamString signalName;
-                if (!dataSourceIn.GetSignalName(dsIdx, signalName)) signalName = "Unknown";
-                
-                // 1. Register canonical DataSource name (Absolute, No Root prefix)
-                StreamString dsFullName;
-                dsFullName.Printf("%s.%s", dsPath.Buffer(), signalName.Buffer());
-                service->RegisterSignal(addr, type, dsFullName.Buffer()); 
-
-                // 2. Also register absolute GAM alias
-                if (functionName != NULL_PTR(const char8*)) {
-                    StreamString gamFullName;
-                    const char8* dirStr = (direction == InputSignals) ? "In" : "Out";
-                    Reference gamRef = ObjectRegistryDatabase::Instance()->Find(functionName);
-                    if (gamRef.IsValid()) {
-                        StreamString absGamPath;
-                        DebugService::GetFullObjectName(*(gamRef.operator->()), absGamPath);
-                        gamFullName.Printf("%s.%s.%s", absGamPath.Buffer(), dirStr, signalName.Buffer());
-                    } else {
-                        gamFullName.Printf("%s.%s.%s", functionName, dirStr, signalName.Buffer());
-                    }
-                    signalInfoPointers[i] = service->RegisterSignal(addr, type, gamFullName.Buffer());
-                } else {
-                    signalInfoPointers[i] = service->RegisterSignal(addr, type, dsFullName.Buffer());
-                }
-            }
-        }
-    }
-};
-
-#define DECLARE_DEBUG_BROKER_COMMON(BaseClass) \
-    Debug##BaseClass() : BaseClass() { \
-        service = NULL_PTR(DebugService*); \
-        signalInfoPointers = NULL_PTR(DebugSignalInfo**); \
-        numSignals = 0; \
-    } \
-    virtual ~Debug##BaseClass() { \
-        if (signalInfoPointers) delete[] signalInfoPointers; \
-    } \
-    virtual bool Execute() { \
-        bool ret = BaseClass::Execute(); \
-        if (ret) DebugBrokerHelper::Process(this, service, signalInfoPointers, numSignals); \
-        return ret; \
-    } \
-private: \
-    DebugService *service; \
-    DebugSignalInfo **signalInfoPointers; \
-    uint32 numSignals;
-
-#define DECLARE_DEBUG_BROKER(BaseClass) \
-class Debug##BaseClass : public BaseClass { \
-public: \
-    DECLARE_DEBUG_BROKER_COMMON(BaseClass) \
-    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) { \
-        bool ret = BaseClass::Init(direction, ds, name, gamMem); \
-        if (ret) DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction); \
-        return ret; \
-    } \
-    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem, const bool optim) { \
-        bool ret = BaseClass::Init(direction, ds, name, gamMem, optim); \
-        if (ret) DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction); \
-        return ret; \
-    } \
-}; \
-class Debug##BaseClass##Builder : public ObjectBuilder { \
-public: \
-    virtual Object *Build(HeapI* const heap) const { return new (heap) Debug##BaseClass(); } \
-};
-
-#define DECLARE_DEBUG_BROKER_NO_OPTIM(BaseClass) \
-class Debug##BaseClass : public BaseClass { \
-public: \
-    DECLARE_DEBUG_BROKER_COMMON(BaseClass) \
-    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) { \
-        bool ret = BaseClass::Init(direction, ds, name, gamMem); \
-        if (ret) DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction); \
-        return ret; \
-    } \
-}; \
-class Debug##BaseClass##Builder : public ObjectBuilder { \
-public: \
-    virtual Object *Build(HeapI* const heap) const { return new (heap) Debug##BaseClass(); } \
-};
-
-DECLARE_DEBUG_BROKER(MemoryMapInputBroker)
-DECLARE_DEBUG_BROKER(MemoryMapOutputBroker)
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedInputBroker)
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedOutputBroker)
-DECLARE_DEBUG_BROKER_NO_OPTIM(MemoryMapInterpolatedInputBroker)
-DECLARE_DEBUG_BROKER(MemoryMapMultiBufferInputBroker)
-DECLARE_DEBUG_BROKER(MemoryMapMultiBufferOutputBroker)
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedMultiBufferInputBroker)
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedMultiBufferOutputBroker)
-
-}
-
-#endif

Headers/DebugFastScheduler.h

@@ -1,32 +0,0 @@
-#ifndef DEBUGFASTSCHEDULER_H
-#define DEBUGFASTSCHEDULER_H
-
-#include "FastScheduler.h"
-#include "DebugService.h"
-
-namespace MARTe {
-
-class DebugFastScheduler : public FastScheduler {
-public:
-    CLASS_REGISTER_DECLARATION()
-
-    DebugFastScheduler();
-    virtual ~DebugFastScheduler();
-
-    virtual bool Initialise(StructuredDataI & data);
-
-    ErrorManagement::ErrorType Execute(ExecutionInfo &information);
-
-protected:
-    virtual void CustomPrepareNextState();
-
-private:
-    ErrorManagement::ErrorType DebugSetupThreadMap();
-
-    EmbeddedServiceMethodBinderT<DebugFastScheduler> debugBinder;
-    DebugService *debugService;
-};
-
-}
-
-#endif

Headers/DebugService.h

@@ -1,108 +0,0 @@
-#ifndef DEBUGSERVICE_H
-#define DEBUGSERVICE_H
-
-#include "MessageI.h"
-#include "StreamString.h"
-#include "BasicUDPSocket.h"
-#include "BasicTCPSocket.h"
-#include "ReferenceContainer.h"
-#include "SingleThreadService.h"
-#include "EmbeddedServiceMethodBinderI.h"
-#include "Object.h"
-#include "DebugCore.h"
-
-namespace MARTe {
-
-struct SignalAlias {
-    StreamString name;
-    uint32 signalIndex;
-};
-
-class DebugService : public ReferenceContainer, public MessageI, public EmbeddedServiceMethodBinderI {
-public:
-    CLASS_REGISTER_DECLARATION()
-
-    DebugService();
-    virtual ~DebugService();
-
-    virtual bool Initialise(StructuredDataI & data);
-
-    DebugSignalInfo* RegisterSignal(void* memoryAddress, TypeDescriptor type, const char8* name);
-    void ProcessSignal(DebugSignalInfo* signalInfo, uint32 size);
-
-    virtual ErrorManagement::ErrorType Execute(ExecutionInfo & info);
-
-    bool IsPaused() const { return isPaused; }
-    void SetPaused(bool paused) { isPaused = paused; }
-
-    static bool GetFullObjectName(const Object &obj, StreamString &fullPath);
-
-    uint32 ForceSignal(const char8* name, const char8* valueStr);
-    uint32 UnforceSignal(const char8* name);
-    uint32 TraceSignal(const char8* name, bool enable, uint32 decimation = 1);
-    void Discover(BasicTCPSocket *client);
-    void ListNodes(const char8* path, BasicTCPSocket *client);
-    void InfoNode(const char8* path, BasicTCPSocket *client);
-
-private:
-    void HandleCommand(StreamString cmd, BasicTCPSocket *client);
-    
-    uint32 ExportTree(ReferenceContainer *container, StreamString &json);
-    void PatchRegistry();
-    
-    ErrorManagement::ErrorType Server(ExecutionInfo & info);
-    ErrorManagement::ErrorType Streamer(ExecutionInfo & info);
-
-    uint16 controlPort;
-    uint16 streamPort;
-    StreamString streamIP;
-    bool isServer; 
-    bool suppressTimeoutLogs;
-    volatile bool isPaused;
-
-    BasicTCPSocket tcpServer;
-    BasicUDPSocket udpSocket;
-    
-    class ServiceBinder : public EmbeddedServiceMethodBinderI {
-    public:
-        enum ServiceType { ServerType, StreamerType };
-        ServiceBinder(DebugService *parent, ServiceType type) : parent(parent), type(type) {}
-        virtual ErrorManagement::ErrorType Execute(ExecutionInfo & info) {
-            if (type == StreamerType) return parent->Streamer(info);
-            return parent->Server(info);
-        }
-    private:
-        DebugService *parent;
-        ServiceType type;
-    };
-    
-    ServiceBinder binderServer;
-    ServiceBinder binderStreamer;
-
-    SingleThreadService threadService;
-    SingleThreadService streamerService;
-    
-    ThreadIdentifier serverThreadId;
-    ThreadIdentifier streamerThreadId;
-
-    static const uint32 MAX_SIGNALS = 4096;
-    DebugSignalInfo signals[MAX_SIGNALS];
-    uint32 numberOfSignals;
-
-    static const uint32 MAX_ALIASES = 8192;
-    SignalAlias aliases[MAX_ALIASES];
-    uint32 numberOfAliases;
-
-    FastPollingMutexSem mutex;
-    TraceRingBuffer traceBuffer;
-
-    static const uint32 MAX_CLIENTS = 16;
-    BasicTCPSocket* activeClients[MAX_CLIENTS];
-    FastPollingMutexSem clientsMutex;
-
-    static DebugService* instance;
-};
-
-}
-
-#endif

Makefile

@@ -1,10 +0,0 @@
-all: build
-
-build:
-	mkdir -p Build && cd Build && . ../env.sh && cmake -DCMAKE_BUILD_TYPE=Debug .. && make
-	ln -sf libmarte_dev.so Build/DebugService.so
-
-clean:
-	rm -rf Build
-
-.PHONY: all build clean

Makefile.gcc

@@ -0,0 +1,26 @@
+#############################################################
+#
+# 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
+#
+# 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 for the specific language governing 
+# permissions and limitations under the Licence. 
+#
+#############################################################
+export TARGET=x86-linux
+
+include Makefile.inc

Makefile.inc

@@ -0,0 +1,76 @@
+#############################################################
+#
+# 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
+#
+# 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 for the specific language governing
+# permissions and limitations under the Licence.
+#
+# $Id: Makefile.inc 3 2012-01-15 16:26:07Z aneto $
+#
+#############################################################
+#Subprojects w.r.t. the main directory only (important to allow setting SPBM as an export variable).
+#If SPB is directly exported as an environment variable it will also be evaluated as part of the subprojects SPB, thus
+#potentially overriding its value
+#Main target subprojects. May be overridden by shell definition.
+SPBM?=Source/Components/Interfaces.x
+SPBMT?=Test.x
+	
+	
+
+
+#This really has to be defined locally.
+SUBPROJMAIN=$(SPBM:%.x=%.spb)
+SUBPROJMAINTEST=$(SPBMT:%.x=%.spb)
+SUBPROJMAINCLEAN=$(SPBM:%.x=%.spc)
+SUBPROJMAINTESTCLEAN=$(SPBMT:%.x=%.spc)
+
+
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+
+ROOT_DIR=.
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+all: $(OBJS) core test
+	echo  $(OBJS)
+
+compile_commands.json:
+	bear -- make -f Makefile.gcc
+
+core: $(SUBPROJMAIN) check-env
+	echo  $(SUBPROJMAIN)
+
+test: $(SUBPROJMAINTEST)
+	echo  $(SUBPROJMAINTEST)
+
+
+
+clean:: $(SUBPROJMAINCLEAN) $(SUBPROJMAINTESTCLEAN) clean_wipe_old
+#clean:: $(SUBPROJMAINCLEAN) $(SUBPROJMAINTESTCLEAN) clean_wipe_old
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)
+
+check-marte:
+ifndef MARTe2_DIR
+    $(error MARTe2_DIR is undefined)
+endif
+
+check-env:
+ifndef MARTe2_DIR
+    $(error MARTe2_DIR is undefined)
+endif
+

README.md

@@ -7,15 +7,12 @@ An interactive observability and debugging suite for the MARTe2 real-time framew
 ### 1. Build the project
 ```bash
 . ./env.sh
-cd Build
+make -f Makefile.gcc
-cmake ..
-make -j$(nproc)
 ```
 
 ### 2. Run Integration Tests
 ```bash
-./Test/Integration/ValidationTest # Verifies 100Hz tracing
+./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex # Runs all tests
-./Test/Integration/SchedulerTest  # Verifies execution control
 ```
 
 ### 3. Launch GUI

SPECS.md

@@ -1,24 +1,64 @@
 # MARTe2 Debug Suite Specifications
 
-## 1. Goal
+**Version:** 1.2  
-Implement a "Zero-Code-Change" observability layer for the MARTe2 real-time framework, providing live telemetry, signal forcing, and execution control without modifying existing application source code.
+**Status:** Active / Implemented
 
-## 2. Requirements
+## 1. Executive Summary
-### 2.1 Functional Requirements (FR)
+This project implements a "Zero-Code-Change" observability and debugging layer for the MARTe2 real-time framework. The system allows developers to Trace, Force, and Monitor any signal in a running MARTe2 application without modifying existing source code.
-- **FR-01 (Discovery):** Discover the full MARTe2 object hierarchy at runtime.
+
-- **FR-02 (Telemetry):** Stream high-frequency signal data (verified up to 100Hz) to a remote client.
+## 2. System Architecture
+- **The Universal Debug Service (C++ Core):** A singleton MARTe2 Object that patches the registry and manages communication.
+- **The Broker Injection Layer (C++ Templates):** Templated wrappers that intercept `Execute()` and `Init()` calls for tracing, forcing, and execution control.
+- **The Remote Analyser (Rust/egui):** A high-performance, multi-threaded GUI for visualization and control.
+- **Network Stack:**
+    - **Port 8080 (TCP):** Commands and Metadata.
+    - **Port 8081 (UDP):** High-Speed Telemetry for Oscilloscope.
+    - **Port 8082 (TCP):** Independent Real-Time Log Stream via `TcpLogger`.
+
+## 3. Requirements
+
+### 3.1 Functional Requirements (FR)
+- **FR-01 (Discovery):** Discover the full MARTe2 object hierarchy at runtime. The GUI client SHALL request the full application tree upon connection and display it in a hierarchical tree view.
+- **FR-02 (Telemetry):** Stream high-frequency signal data (verified up to 100Hz+) to a remote client via UDP.
 - **FR-03 (Forcing):** Allow manual override of signal values in memory during execution.
-- **FR-04 (Logs):** Stream global framework logs to a dedicated terminal via a standalone `TcpLogger` service.
+- **FR-04 (Logs):** Stream global framework logs to a dedicated terminal/client via a standalone `TcpLogger` service.
-- **FR-05 (Execution Control):** Pause and resume the real-time execution threads via scheduler injection.
+- **FR-05 (Log Filtering):** The client must support filtering logs by type (Debug, Information, Warning, FatalError) and by content using regular expressions.
-- **FR-06 (UI):** Provide a native, immediate-mode GUI for visualization (Oscilloscope).
+- **FR-06 (Execution Control):** Provide a mechanism to pause and resume the execution of all patched real-time threads (via Brokers), allowing for static inspection of the system state.
+- **FR-07 (Session Management):** Support runtime re-configuration and "Apply & Reconnect" logic. The GUI provides a "Disconnect" button to close active network streams.
+- **FR-08 (Decoupled Tracing):** Tracing activates telemetry; data is buffered and shown as a "Last Value" in the sidebar, but not plotted until manually assigned.
+- **FR-09 (Advanced Plotting):** 
+    - Support multiple plot panels with perfectly synchronized time (X) axes.
+    - Drag-and-drop signals from the traced list into specific plots.
+    - Plot modes: Standard (Time Series) and Logic Analyzer (Stacked rows).
+    - Signal transformations: Gain, offset, units, and custom labels.
+- **FR-10 (Navigation & Scope):** 
+    - Context menus for resetting zoom (X, Y, or both).
+    - "Fit to View" functionality that automatically scales both axes.
+    - High-performance oscilloscope mode with configurable time windows (10ms to 10s).
+    - Triggered acquisition (Single/Continuous, rising/falling edges).
+- **FR-11 (Data Recording):** Record any traced signal to disk in Parquet format with a visual recording indicator in the GUI.
+- **FR-12 (Configuration Awareness):** The DebugService SHALL store a complete copy of the application's configuration provided at initialization.
+- **FR-13 (Metadata Enrichment):** Metadata returned by `INFO` and `DISCOVER` SHALL be enriched with additional fields from the stored configuration (e.g., Frequency, PVNames, Units).
+- **FR-14 (Configuration Serving):** Provide a `CONFIG` command to serve the full stored configuration in JSON format to the client.
 
-### 2.2 Technical Constraints (TC)
+### 3.2 Technical Constraints (TC)
 - **TC-01:** No modifications allowed to the MARTe2 core library or component source code.
 - **TC-02:** Instrumentation must use Runtime Class Registry Patching.
 - **TC-03:** Real-time threads must remain lock-free; use `FastPollingMutexSem` or atomic operations for synchronization.
 - **TC-04:** Telemetry must be delivered via UDP to minimize impact on real-time jitter.
 
-## 3. Performance Metrics
+## 4. Performance Metrics
 - **Latency:** Telemetry dispatch overhead < 5 microseconds per signal.
 - **Throughput:** Support for 100Hz+ sampling rates with zero packet loss on local networks.
 - **Scalability:** Handle up to 4096 unique signals and 16 simultaneous client connections.
+- **Code Quality:** Maintain a minimum of **85% code coverage** across all core service and broker logic.
+
+## 5. Communication Protocol (Port 8080)
+- **LS [Path]:** List nodes at the specified path.
+- **TREE:** Returns a full recursive JSON structure representing the entire application tree.
+- **INFO [Path]:** Returns detailed metadata for a specific node or signal.
+- **PAUSE / RESUME:** Global execution control.
+- **TRACE <Signal> <1/0> [Decimation]:** Enable/disable telemetry for a signal.
+- **FORCE <Signal> <Value>:** Persistent signal override.
+- **UNFORCE <Signal>:** Remove override.
+- **LOG <Level> <Msg>:** Streaming format used on Port 8082.

Source/Components/Interfaces/DebugService/DebugBrokerWrapper.h

@@ -0,0 +1,433 @@
+#ifndef DEBUGBROKERWRAPPER_H
+#define DEBUGBROKERWRAPPER_H
+
+#include "BrokerI.h"
+#include "DataSourceI.h"
+#include "DebugService.h"
+#include "FastPollingMutexSem.h"
+#include "HighResolutionTimer.h"
+#include "MemoryMapBroker.h"
+#include "ObjectBuilder.h"
+#include "ObjectRegistryDatabase.h"
+#include "Vec.h"
+
+// Original broker headers
+#include "MemoryMapAsyncOutputBroker.h"
+#include "MemoryMapAsyncTriggerOutputBroker.h"
+#include "MemoryMapInputBroker.h"
+#include "MemoryMapInterpolatedInputBroker.h"
+#include "MemoryMapMultiBufferInputBroker.h"
+#include "MemoryMapMultiBufferOutputBroker.h"
+#include "MemoryMapOutputBroker.h"
+#include "MemoryMapSynchronisedInputBroker.h"
+#include "MemoryMapSynchronisedMultiBufferInputBroker.h"
+#include "MemoryMapSynchronisedMultiBufferOutputBroker.h"
+#include "MemoryMapSynchronisedOutputBroker.h"
+
+namespace MARTe {
+
+/**
+ * @brief Helper for optimized signal processing within brokers.
+ */
+class DebugBrokerHelper {
+public:
+  static void Process(DebugService *service,
+                      DebugSignalInfo **signalInfoPointers,
+                      Vec<uint32> &activeIndices, Vec<uint32> &activeSizes,
+                      FastPollingMutexSem &activeMutex) {
+    if (service == NULL_PTR(DebugService *))
+      return;
+
+    // Re-establish break logic
+    while (service->IsPaused()) {
+      Sleep::MSec(10);
+    }
+
+    activeMutex.FastLock();
+    uint32 n = activeIndices.Size();
+    if (n > 0 && signalInfoPointers != NULL_PTR(DebugSignalInfo **)) {
+      // Capture timestamp ONCE per broker cycle for lowest impact
+      uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() *
+                           HighResolutionTimer::Period() * 1000000.0);
+
+      for (uint32 i = 0; i < n; i++) {
+        uint32 idx = activeIndices[i];
+        uint32 size = activeSizes[i];
+        DebugSignalInfo *s = signalInfoPointers[idx];
+        if (s != NULL_PTR(DebugSignalInfo *)) {
+          service->ProcessSignal(s, size, ts);
+        }
+      }
+    }
+    activeMutex.FastUnLock();
+  }
+
+  // Pass numCopies explicitly so we can mock it
+  static void
+  InitSignals(BrokerI *broker, DataSourceI &dataSourceIn,
+              DebugService *&service, DebugSignalInfo **&signalInfoPointers,
+              uint32 numCopies, MemoryMapBrokerCopyTableEntry *copyTable,
+              const char8 *functionName, SignalDirection direction,
+              volatile bool *anyActiveFlag, Vec<uint32> *activeIndices,
+              Vec<uint32> *activeSizes, FastPollingMutexSem *activeMutex) {
+    if (numCopies > 0) {
+      signalInfoPointers = new DebugSignalInfo *[numCopies];
+      for (uint32 i = 0; i < numCopies; i++)
+        signalInfoPointers[i] = NULL_PTR(DebugSignalInfo *);
+    }
+
+    ReferenceContainer *root = ObjectRegistryDatabase::Instance();
+    Reference serviceRef = root->Find("DebugService");
+    if (serviceRef.IsValid()) {
+      service = dynamic_cast<DebugService *>(serviceRef.operator->());
+    }
+
+    if (service && (copyTable != NULL_PTR(MemoryMapBrokerCopyTableEntry *))) {
+
+      StreamString dsPath;
+      DebugService::GetFullObjectName(dataSourceIn, dsPath);
+      fprintf(stderr, ">> %s broker for %s [%d]\n",
+              direction == InputSignals ? "Input" : "Output", dsPath.Buffer(),
+              numCopies);
+      MemoryMapBroker *mmb = dynamic_cast<MemoryMapBroker *>(broker);
+      if (mmb == NULL_PTR(MemoryMapBroker *)) {
+        fprintf(stderr, ">> Impossible to get broker pointer!!\n");
+      }
+
+      for (uint32 i = 0; i < numCopies; i++) {
+        void *addr = copyTable[i].dataSourcePointer;
+        TypeDescriptor type = copyTable[i].type;
+
+        uint32 dsIdx = i;
+        if (mmb != NULL_PTR(MemoryMapBroker *)) {
+          dsIdx = mmb->GetDSCopySignalIndex(i);
+        }
+
+        StreamString signalName;
+        if (!dataSourceIn.GetSignalName(dsIdx, signalName))
+          signalName = "Unknown";
+        fprintf(stderr, ">> registering %s.%s [%p]\n", dsPath.Buffer(),
+                signalName.Buffer(), mmb);
+
+        uint8 dims = 0;
+        uint32 elems = 1;
+        (void)dataSourceIn.GetSignalNumberOfDimensions(dsIdx, dims);
+        (void)dataSourceIn.GetSignalNumberOfElements(dsIdx, elems);
+
+        // Register canonical name
+        StreamString dsFullName;
+        dsFullName.Printf("%s.%s", dsPath.Buffer(), signalName.Buffer());
+        service->RegisterSignal(addr, type, dsFullName.Buffer(), dims, elems);
+
+        // Register alias
+        if (functionName != NULL_PTR(const char8 *)) {
+          StreamString gamFullName;
+          const char8 *dirStr =
+              (direction == InputSignals) ? "InputSignals" : "OutputSignals";
+          const char8 *dirStrShort = (direction == InputSignals) ? "In" : "Out";
+
+          // Try to find the GAM with different path variations
+          Reference gamRef =
+              ObjectRegistryDatabase::Instance()->Find(functionName);
+          if (!gamRef.IsValid()) {
+            // Try with "App.Functions." prefix
+            StreamString tryPath;
+            tryPath.Printf("App.Functions.%s", functionName);
+            gamRef = ObjectRegistryDatabase::Instance()->Find(tryPath.Buffer());
+          }
+          if (!gamRef.IsValid()) {
+            // Try with "Functions." prefix
+            StreamString tryPath;
+            tryPath.Printf("Functions.%s", functionName);
+            gamRef = ObjectRegistryDatabase::Instance()->Find(tryPath.Buffer());
+          }
+
+          if (gamRef.IsValid()) {
+            StreamString absGamPath;
+            DebugService::GetFullObjectName(*(gamRef.operator->()), absGamPath);
+            // Register short path (In/Out) for GUI compatibility
+            gamFullName.Printf("%s.%s.%s", absGamPath.Buffer(), dirStrShort,
+                               signalName.Buffer());
+            signalInfoPointers[i] =
+                service->RegisterSignal(addr, type, gamFullName.Buffer(), dims, elems);
+          } else {
+            // Fallback to short form
+            gamFullName.Printf("%s.%s.%s", functionName, dirStrShort,
+                               signalName.Buffer());
+            signalInfoPointers[i] =
+                service->RegisterSignal(addr, type, gamFullName.Buffer(), dims, elems);
+          }
+        } else {
+          signalInfoPointers[i] =
+              service->RegisterSignal(addr, type, dsFullName.Buffer(), dims, elems);
+        }
+      }
+
+      // Register broker in DebugService for optimized control
+      service->RegisterBroker(signalInfoPointers, numCopies, mmb, anyActiveFlag,
+                              activeIndices, activeSizes, activeMutex);
+    }
+  }
+};
+
+/**
+ * @brief Template class to instrument any MARTe2 Broker.
+ */
+template <typename BaseClass> class DebugBrokerWrapper : public BaseClass {
+public:
+  DebugBrokerWrapper() : BaseClass() {
+    service = NULL_PTR(DebugService *);
+    signalInfoPointers = NULL_PTR(DebugSignalInfo **);
+    numSignals = 0;
+    anyActive = false;
+  }
+
+  virtual ~DebugBrokerWrapper() {
+    if (signalInfoPointers)
+      delete[] signalInfoPointers;
+  }
+
+  virtual bool Execute() {
+    bool ret = BaseClass::Execute();
+    if (ret && (anyActive || (service && service->IsPaused()))) {
+      DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices,
+                                 activeSizes, activeMutex);
+    }
+    return ret;
+  }
+
+  virtual bool Init(SignalDirection direction, DataSourceI &ds,
+                    const char8 *const name, void *gamMem) {
+    bool ret = BaseClass::Init(direction, ds, name, gamMem);
+    fprintf(stderr, ">> INIT BROKER %s %s\n", name,
+            direction == InputSignals ? "In" : "Out");
+    if (ret) {
+      numSignals = this->GetNumberOfCopies();
+      DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers,
+                                     numSignals, this->copyTable, name,
+                                     direction, &anyActive, &activeIndices,
+                                     &activeSizes, &activeMutex);
+    }
+    return ret;
+  }
+
+  virtual bool Init(SignalDirection direction, DataSourceI &ds,
+                    const char8 *const name, void *gamMem, const bool optim) {
+    bool ret = BaseClass::Init(direction, ds, name, gamMem, false);
+    fprintf(stderr, ">> INIT optimized BROKER %s %s\n", name,
+            direction == InputSignals ? "In" : "Out");
+    if (ret) {
+      numSignals = this->GetNumberOfCopies();
+      DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers,
+                                     numSignals, this->copyTable, name,
+                                     direction, &anyActive, &activeIndices,
+                                     &activeSizes, &activeMutex);
+    }
+    return ret;
+  }
+
+  DebugService *service;
+  DebugSignalInfo **signalInfoPointers;
+  uint32 numSignals;
+  volatile bool anyActive;
+  Vec<uint32> activeIndices;
+  Vec<uint32> activeSizes;
+  FastPollingMutexSem activeMutex;
+};
+
+template <typename BaseClass>
+class DebugBrokerWrapperNoOptim : public BaseClass {
+public:
+  DebugBrokerWrapperNoOptim() : BaseClass() {
+    service = NULL_PTR(DebugService *);
+    signalInfoPointers = NULL_PTR(DebugSignalInfo **);
+    numSignals = 0;
+    anyActive = false;
+  }
+
+  virtual ~DebugBrokerWrapperNoOptim() {
+    if (signalInfoPointers)
+      delete[] signalInfoPointers;
+  }
+
+  virtual bool Execute() {
+    bool ret = BaseClass::Execute();
+    if (ret && (anyActive || (service && service->IsPaused()))) {
+      DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices,
+                                 activeSizes, activeMutex);
+    }
+    return ret;
+  }
+
+  virtual bool Init(SignalDirection direction, DataSourceI &ds,
+                    const char8 *const name, void *gamMem) {
+    bool ret = BaseClass::Init(direction, ds, name, gamMem);
+    if (ret) {
+      numSignals = this->GetNumberOfCopies();
+      DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers,
+                                     numSignals, this->copyTable, name,
+                                     direction, &anyActive, &activeIndices,
+                                     &activeSizes, &activeMutex);
+    }
+    return ret;
+  }
+
+  DebugService *service;
+  DebugSignalInfo **signalInfoPointers;
+  uint32 numSignals;
+  volatile bool anyActive;
+  Vec<uint32> activeIndices;
+  Vec<uint32> activeSizes;
+  FastPollingMutexSem activeMutex;
+};
+
+class DebugMemoryMapAsyncOutputBroker : public MemoryMapAsyncOutputBroker {
+public:
+  DebugMemoryMapAsyncOutputBroker() : MemoryMapAsyncOutputBroker() {
+    service = NULL_PTR(DebugService *);
+    signalInfoPointers = NULL_PTR(DebugSignalInfo **);
+    numSignals = 0;
+    anyActive = false;
+  }
+  virtual ~DebugMemoryMapAsyncOutputBroker() {
+    if (signalInfoPointers)
+      delete[] signalInfoPointers;
+  }
+  virtual bool Execute() {
+    bool ret = MemoryMapAsyncOutputBroker::Execute();
+    if (ret && (anyActive || (service && service->IsPaused()))) {
+      DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices,
+                                 activeSizes, activeMutex);
+    }
+    return ret;
+  }
+  virtual bool InitWithBufferParameters(const SignalDirection direction,
+                                        DataSourceI &dataSourceIn,
+                                        const char8 *const functionName,
+                                        void *const gamMemoryAddress,
+                                        const uint32 numberOfBuffersIn,
+                                        const ProcessorType &cpuMaskIn,
+                                        const uint32 stackSizeIn) {
+    bool ret = MemoryMapAsyncOutputBroker::InitWithBufferParameters(
+        direction, dataSourceIn, functionName, gamMemoryAddress,
+        numberOfBuffersIn, cpuMaskIn, stackSizeIn);
+    if (ret) {
+      numSignals = this->GetNumberOfCopies();
+      DebugBrokerHelper::InitSignals(
+          this, dataSourceIn, service, signalInfoPointers, numSignals,
+          this->copyTable, functionName, direction, &anyActive, &activeIndices,
+          &activeSizes, &activeMutex);
+    }
+    return ret;
+  }
+  DebugService *service;
+  DebugSignalInfo **signalInfoPointers;
+  uint32 numSignals;
+  volatile bool anyActive;
+  Vec<uint32> activeIndices;
+  Vec<uint32> activeSizes;
+  FastPollingMutexSem activeMutex;
+};
+
+class DebugMemoryMapAsyncTriggerOutputBroker
+    : public MemoryMapAsyncTriggerOutputBroker {
+public:
+  DebugMemoryMapAsyncTriggerOutputBroker()
+      : MemoryMapAsyncTriggerOutputBroker() {
+    service = NULL_PTR(DebugService *);
+    signalInfoPointers = NULL_PTR(DebugSignalInfo **);
+    numSignals = 0;
+    anyActive = false;
+  }
+  virtual ~DebugMemoryMapAsyncTriggerOutputBroker() {
+    if (signalInfoPointers)
+      delete[] signalInfoPointers;
+  }
+  virtual bool Execute() {
+    bool ret = MemoryMapAsyncTriggerOutputBroker::Execute();
+    if (ret && (anyActive || (service && service->IsPaused()))) {
+      DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices,
+                                 activeSizes, activeMutex);
+    }
+    return ret;
+  }
+  virtual bool InitWithTriggerParameters(
+      const SignalDirection direction, DataSourceI &dataSourceIn,
+      const char8 *const functionName, void *const gamMemoryAddress,
+      const uint32 numberOfBuffersIn, const uint32 preTriggerBuffersIn,
+      const uint32 postTriggerBuffersIn, const ProcessorType &cpuMaskIn,
+      const uint32 stackSizeIn) {
+    bool ret = MemoryMapAsyncTriggerOutputBroker::InitWithTriggerParameters(
+        direction, dataSourceIn, functionName, gamMemoryAddress,
+        numberOfBuffersIn, preTriggerBuffersIn, postTriggerBuffersIn, cpuMaskIn,
+        stackSizeIn);
+    if (ret) {
+      numSignals = this->GetNumberOfCopies();
+      DebugBrokerHelper::InitSignals(
+          this, dataSourceIn, service, signalInfoPointers, numSignals,
+          this->copyTable, functionName, direction, &anyActive, &activeIndices,
+          &activeSizes, &activeMutex);
+    }
+    return ret;
+  }
+  DebugService *service;
+  DebugSignalInfo **signalInfoPointers;
+  uint32 numSignals;
+  volatile bool anyActive;
+  Vec<uint32> activeIndices;
+  Vec<uint32> activeSizes;
+  FastPollingMutexSem activeMutex;
+};
+
+template <typename T> class DebugBrokerBuilder : public ObjectBuilder {
+public:
+  virtual Object *Build(HeapI *const heap) const { return new (heap) T(); }
+};
+
+typedef DebugBrokerWrapper<MemoryMapInputBroker> DebugMemoryMapInputBroker;
+// LCOV_EXCL_START
+typedef DebugBrokerWrapper<MemoryMapOutputBroker> DebugMemoryMapOutputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedInputBroker>
+    DebugMemoryMapSynchronisedInputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedOutputBroker>
+    DebugMemoryMapSynchronisedOutputBroker;
+typedef DebugBrokerWrapperNoOptim<MemoryMapInterpolatedInputBroker>
+    DebugMemoryMapInterpolatedInputBroker;
+typedef DebugBrokerWrapper<MemoryMapMultiBufferInputBroker>
+    DebugMemoryMapMultiBufferInputBroker;
+typedef DebugBrokerWrapper<MemoryMapMultiBufferOutputBroker>
+    DebugMemoryMapMultiBufferOutputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedMultiBufferInputBroker>
+    DebugMemoryMapSynchronisedMultiBufferInputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedMultiBufferOutputBroker>
+    DebugMemoryMapSynchronisedMultiBufferOutputBroker;
+// LCOV_EXCL_STOP
+
+typedef DebugBrokerBuilder<DebugMemoryMapInputBroker>
+    DebugMemoryMapInputBrokerBuilder;
+// LCOV_EXCL_START
+typedef DebugBrokerBuilder<DebugMemoryMapOutputBroker>
+    DebugMemoryMapOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedInputBroker>
+    DebugMemoryMapSynchronisedInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedOutputBroker>
+    DebugMemoryMapSynchronisedOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapInterpolatedInputBroker>
+    DebugMemoryMapInterpolatedInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapMultiBufferInputBroker>
+    DebugMemoryMapMultiBufferInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapMultiBufferOutputBroker>
+    DebugMemoryMapMultiBufferOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedMultiBufferInputBroker>
+    DebugMemoryMapSynchronisedMultiBufferInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedMultiBufferOutputBroker>
+    DebugMemoryMapSynchronisedMultiBufferOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapAsyncOutputBroker>
+    DebugMemoryMapAsyncOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapAsyncTriggerOutputBroker>
+    DebugMemoryMapAsyncTriggerOutputBrokerBuilder;
+// LCOV_EXCL_STOP
+
+} // namespace MARTe
+
+#endif

Source/Components/Interfaces/DebugService/DebugCore.h

@@ -4,6 +4,7 @@
 #include "CompilerTypes.h"
 #include "TypeDescriptor.h"
 #include "StreamString.h"
+#include <string.h> 
 
 namespace MARTe {
 
@@ -11,6 +12,8 @@ struct DebugSignalInfo {
     void* memoryAddress;
     TypeDescriptor type;
     StreamString name;
+    uint8 numberOfDimensions;
+    uint32 numberOfElements;
     volatile bool isTracing;
     volatile bool isForcing;
     uint8 forcedValue[1024]; 
@@ -28,6 +31,10 @@ struct TraceHeader {
 };
 #pragma pack(pop)
 
+/**
+ * @brief Ring buffer for high-frequency signal tracing.
+ * @details New format per sample: [ID:4][Timestamp:8][Size:4][Data:N]
+ */
 class TraceRingBuffer {
 public:
     TraceRingBuffer() {
@@ -54,43 +61,53 @@ public:
         return (buffer != NULL_PTR(uint8*));
     }
 
-    bool Push(uint32 signalID, void* data, uint32 size) {
+    bool Push(uint32 signalID, uint64 timestamp, void* data, uint32 size) {
-        uint32 packetSize = 4 + 4 + size;
+        uint32 packetSize = 4 + 8 + 4 + size; // ID + TS + Size + Data
         uint32 read = readIndex; 
         uint32 write = writeIndex;
-        uint32 available = (read <= write) ? (bufferSize - (write - read) - 1) : (read - write - 1);
+        
+        uint32 available = 0;
+        if (read <= write) {
+            available = bufferSize - (write - read) - 1;
+        } else {
+            available = read - write - 1;
+        }
 
         if (available < packetSize) return false;
 
-        // Use temporary write index to ensure atomic update
         uint32 tempWrite = write;
         WriteToBuffer(&tempWrite, &signalID, 4);
+        WriteToBuffer(&tempWrite, &timestamp, 8);
         WriteToBuffer(&tempWrite, &size, 4);
         WriteToBuffer(&tempWrite, data, size);
         
-        // Final atomic update
         writeIndex = tempWrite;
         return true;
     }
 
-    bool Pop(uint32 &signalID, void* dataBuffer, uint32 &size, uint32 maxSize) {
+    bool Pop(uint32 &signalID, uint64 &timestamp, void* dataBuffer, uint32 &size, uint32 maxSize) {
         uint32 read = readIndex;
         uint32 write = writeIndex;
         if (read == write) return false;
 
         uint32 tempRead = read;
-        uint32 tempId, tempSize;
+        uint32 tempId = 0;
+        uint64 tempTs = 0;
+        uint32 tempSize = 0;
+        
         ReadFromBuffer(&tempRead, &tempId, 4);
+        ReadFromBuffer(&tempRead, &tempTs, 8);
         ReadFromBuffer(&tempRead, &tempSize, 4);
         
         if (tempSize > maxSize) {
-            // Error case: drop data up to writeIndex
             readIndex = write;
             return false;
         }
 
         ReadFromBuffer(&tempRead, dataBuffer, tempSize);
+        
         signalID = tempId;
+        timestamp = tempTs;
         size = tempSize;
         
         readIndex = tempRead;
@@ -106,18 +123,30 @@ public:
 
 private:
     void WriteToBuffer(uint32 *idx, void* src, uint32 count) {
-        uint8* s = (uint8*)src;
+        uint32 current = *idx;
-        for (uint32 i=0; i<count; i++) {
+        uint32 spaceToEnd = bufferSize - current;
-            buffer[*idx] = s[i];
+        if (count <= spaceToEnd) {
-            *idx = (*idx + 1) % bufferSize;
+            memcpy(&buffer[current], src, count);
+            *idx = (current + count) % bufferSize;
+        } else {
+            memcpy(&buffer[current], src, spaceToEnd);
+            uint32 remaining = count - spaceToEnd;
+            memcpy(&buffer[0], (uint8*)src + spaceToEnd, remaining);
+            *idx = remaining;
         }
     }
 
     void ReadFromBuffer(uint32 *idx, void* dst, uint32 count) {
-        uint8* d = (uint8*)dst;
+        uint32 current = *idx;
-        for (uint32 i=0; i<count; i++) {
+        uint32 spaceToEnd = bufferSize - current;
-            d[i] = buffer[*idx];
+        if (count <= spaceToEnd) {
-            *idx = (*idx + 1) % bufferSize;
+            memcpy(dst, &buffer[current], count);
+            *idx = (current + count) % bufferSize;
+        } else {
+            memcpy(dst, &buffer[current], spaceToEnd);
+            uint32 remaining = count - spaceToEnd;
+            memcpy((uint8*)dst + spaceToEnd, &buffer[0], remaining);
+            *idx = remaining;
         }
     }
 

Source/Components/Interfaces/DebugService/DebugService.h

@@ -0,0 +1,157 @@
+#ifndef DEBUGSERVICE_H
+#define DEBUGSERVICE_H
+
+#include "BasicTCPSocket.h"
+#include "BasicUDPSocket.h"
+#include "ConfigurationDatabase.h"
+#include "DebugCore.h"
+#include "EmbeddedServiceMethodBinderI.h"
+#include "MessageI.h"
+#include "Object.h"
+#include "ReferenceContainer.h"
+#include "SingleThreadService.h"
+#include "StreamString.h"
+#include "Vec.h"
+
+namespace MARTe {
+
+class MemoryMapBroker;
+class DataSourceI;
+
+struct SignalAlias {
+  StreamString name;
+  uint32 signalIndex;
+};
+
+struct BrokerInfo {
+  DebugSignalInfo **signalPointers;
+  uint32 numSignals;
+  MemoryMapBroker *broker;
+  volatile bool *anyActiveFlag;
+  Vec<uint32> *activeIndices;
+  Vec<uint32> *activeSizes;
+  FastPollingMutexSem *activeMutex;
+};
+
+class DebugService : public ReferenceContainer,
+                     public MessageI,
+                     public EmbeddedServiceMethodBinderI {
+public:
+  friend class DebugServiceTest;
+  CLASS_REGISTER_DECLARATION()
+
+  DebugService();
+  virtual ~DebugService();
+
+  virtual bool Initialise(StructuredDataI &data);
+
+  DebugSignalInfo *RegisterSignal(void *memoryAddress, TypeDescriptor type,
+                                  const char8 *name, uint8 numberOfDimensions = 0,
+                                  uint32 numberOfElements = 1);
+  void ProcessSignal(DebugSignalInfo *signalInfo, uint32 size,
+                     uint64 timestamp);
+
+  void RegisterBroker(DebugSignalInfo **signalPointers, uint32 numSignals,
+                      MemoryMapBroker *broker, volatile bool *anyActiveFlag,
+                      Vec<uint32> *activeIndices, Vec<uint32> *activeSizes,
+                      FastPollingMutexSem *activeMutex);
+
+  virtual ErrorManagement::ErrorType Execute(ExecutionInfo &info);
+
+  bool IsPaused() const { return isPaused; }
+  void SetPaused(bool paused) { isPaused = paused; }
+
+  static bool GetFullObjectName(const Object &obj, StreamString &fullPath);
+
+  uint32 ForceSignal(const char8 *name, const char8 *valueStr);
+  uint32 UnforceSignal(const char8 *name);
+  uint32 TraceSignal(const char8 *name, bool enable, uint32 decimation = 1);
+  bool IsInstrumented(const char8 *fullPath, bool &traceable, bool &forcable);
+  void Discover(BasicTCPSocket *client);
+  void InfoNode(const char8 *path, BasicTCPSocket *client);
+  void ListNodes(const char8 *path, BasicTCPSocket *client);
+  void ServeConfig(BasicTCPSocket *client);
+  void SetFullConfig(ConfigurationDatabase &config);
+
+  struct MonitoredSignal {
+    ReferenceT<DataSourceI> dataSource;
+    uint32 signalIdx;
+    uint32 internalID;
+    uint32 periodMs;
+    uint64 lastPollTime;
+    uint32 size;
+    StreamString path;
+  };
+
+  uint32 RegisterMonitorSignal(const char8 *path, uint32 periodMs);
+  uint32 UnmonitorSignal(const char8 *path);
+
+private:
+  void HandleCommand(StreamString cmd, BasicTCPSocket *client);
+  void UpdateBrokersActiveStatus();
+
+  uint32 ExportTree(ReferenceContainer *container, StreamString &json, const char8 *pathPrefix);
+  void PatchRegistry();
+
+  void EnrichWithConfig(const char8 *path, StreamString &json);
+  static void JsonifyDatabase(ConfigurationDatabase &db, StreamString &json);
+
+  ErrorManagement::ErrorType Server(ExecutionInfo &info);
+  ErrorManagement::ErrorType Streamer(ExecutionInfo &info);
+
+  uint16 controlPort;
+  uint16 streamPort;
+  uint16 logPort;
+  StreamString streamIP;
+  bool isServer;
+  bool suppressTimeoutLogs;
+  volatile bool isPaused;
+
+  BasicTCPSocket tcpServer;
+  BasicUDPSocket udpSocket;
+
+  class ServiceBinder : public EmbeddedServiceMethodBinderI {
+  public:
+    enum ServiceType { ServerType, StreamerType };
+    ServiceBinder(DebugService *parent, ServiceType type)
+        : parent(parent), type(type) {}
+    virtual ErrorManagement::ErrorType Execute(ExecutionInfo &info) {
+      if (type == StreamerType) {
+        return parent->Streamer(info);
+      }
+      printf("serve TCP\n");
+      return parent->Server(info);
+    }
+
+  private:
+    DebugService *parent;
+    ServiceType type;
+  };
+
+  ServiceBinder binderServer;
+  ServiceBinder binderStreamer;
+
+  SingleThreadService threadService;
+  SingleThreadService streamerService;
+
+  ThreadIdentifier serverThreadId;
+  ThreadIdentifier streamerThreadId;
+
+  Vec<DebugSignalInfo *> signals;
+  Vec<SignalAlias> aliases;
+  Vec<BrokerInfo> brokers;
+  Vec<MonitoredSignal> monitoredSignals;
+
+  FastPollingMutexSem mutex;
+  TraceRingBuffer traceBuffer;
+
+  BasicTCPSocket *activeClient;
+
+  ConfigurationDatabase fullConfig;
+
+  static DebugService *instance;
+};
+
+} // namespace MARTe
+
+#endif

Source/Components/Interfaces/DebugService/Makefile.gcc

@@ -0,0 +1,28 @@
+#############################################################
+#
+# 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
+#
+# 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 for the specific language governing 
+# permissions and limitations under the Licence. 
+#
+# $Id: Makefile.gcc 3 2015-01-15 16:26:07Z aneto $
+#
+#############################################################
+
+
+include Makefile.inc

Source/Components/Interfaces/DebugService/Makefile.inc

@@ -0,0 +1,59 @@
+#############################################################
+#
+# 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
+#
+# 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 for the specific language governing 
+# permissions and limitations under the Licence. 
+#
+# $Id: Makefile.inc 3 2012-01-15 16:26:07Z aneto $
+#
+#############################################################
+OBJSX=DebugService.x
+
+PACKAGE=Components/Interfaces
+
+ROOT_DIR=../../../../
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Result
+INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Vec
+INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/TCPLogger
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L0Types
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L2Objects
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L3Streams
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Logger
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Configuration
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L3Services
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4LoggerService
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L3Streams
+
+all: $(OBJS) $(SUBPROJ) \
+	$(BUILD_DIR)/DebugService$(LIBEXT) \
+	$(BUILD_DIR)/DebugService$(DLLEXT)
+	    echo  $(OBJS)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)
+

Source/Components/Interfaces/Makefile.gcc

@@ -0,0 +1,26 @@
+#############################################################
+#
+# 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
+#
+# 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 for the specific language governing 
+# permissions and limitations under the Licence. 
+#
+#############################################################
+
+
+include Makefile.inc

Source/Components/Interfaces/Makefile.inc

@@ -0,0 +1,43 @@
+#############################################################
+#
+# 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
+#
+# 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 for the specific language governing
+# permissions and limitations under the Licence.
+#
+#############################################################
+
+OBJSX=
+
+SPB = TCPLogger.x DebugService.x
+
+ROOT_DIR=../../..
+
+
+PACKAGE=Components
+ROOT_DIR=../../..
+ABS_ROOT_DIR=$(abspath $(ROOT_DIR))
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+all: $(OBJS)  $(SUBPROJ)
+	echo  $(OBJS)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)
+

Source/Components/Interfaces/TCPLogger/Makefile.gcc

@@ -0,0 +1 @@
+include Makefile.inc

Source/Components/Interfaces/TCPLogger/Makefile.inc

@@ -0,0 +1,31 @@
+OBJSX=TcpLogger.x
+
+PACKAGE=Components/Interfaces
+
+ROOT_DIR=../../../../
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+INCLUDES += -I.
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L0Types
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L2Objects
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L3Streams
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Logger
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Configuration
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L3Services
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4LoggerService
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L3Streams
+
+all: $(OBJS) $(SUBPROJ) \
+	$(BUILD_DIR)/TcpLogger$(LIBEXT) \
+	$(BUILD_DIR)/TcpLogger$(DLLEXT)
+	echo  $(OBJS)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)

Source/Core/Types/Makefile.gcc

@@ -0,0 +1 @@
+include Makefile.inc

Source/Core/Types/Makefile.inc

@@ -0,0 +1,46 @@
+#############################################################
+#
+# 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
+#
+# 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 for the specific language governing
+# permissions and limitations under the Licence.
+#
+# $Id: Makefile.inc 3 2012-01-15 16:26:07Z aneto $
+#
+#############################################################
+
+SPB = 
+
+
+ROOT_DIR=../../..
+
+
+PACKAGE=Core
+ROOT_DIR=../../..
+ABS_ROOT_DIR=$(abspath $(ROOT_DIR))
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+all: $(OBJS) $(SUBPROJ)
+	echo  $(OBJS)
+
+include depends.$(TARGET)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)
+

Source/Core/Types/Result/Result.h

@@ -0,0 +1,75 @@
+#ifndef __RESULT_H
+#define __RESULT_H
+
+#include <cassert>
+
+namespace MARTe {
+
+/**
+ * @brief Namespace for result error codes.
+ */
+namespace Errors {
+enum ErrorT {
+  None = 0,
+  Generic = 1,
+  OutOfMemory = 2,
+  IndexOutOfBounds = 3,
+  ValueOutOfRange = 4,
+  WrongType = 5,
+  Empty = 6,
+};
+}
+
+/**
+ * @brief A simple Result type for error handling.
+ * @details This implementation is header-only to ensure template linkage.
+ * Requirement: T and E must have default constructors and be copyable.
+ */
+template <typename T, typename E = Errors::ErrorT> 
+class Result {
+public:
+    static Result Success(const T &t) {
+        return Result(t, true);
+    }
+
+    static Result Fail(const E &e) {
+        return Result(e, false);
+    }
+
+    Result() : state(false), val(T()), err(E()) {}
+    Result(const Result &r) : state(r.state), val(r.val), err(r.err) {}
+
+    Result& operator=(const Result &r) {
+        if (this != &r) {
+            state = r.state;
+            val = r.val;
+            err = r.err;
+        }
+        return *this;
+    }
+
+    bool Ok() const { return state; }
+    bool IsOk() const { return state; }
+    
+    // Const accessors
+    const T &Val() const { assert(state); return val; }
+    const E &Err() const { assert(!state); return err; }
+
+    // Non-const accessors
+    T &Val() { assert(state); return val; }
+    E &Err() { assert(!state); return err; }
+
+    operator bool() const { return state; }
+
+private:
+    Result(const T &v, bool s) : state(s), val(v), err(E()) {}
+    Result(const E &e, bool s) : state(s), val(T()), err(e) {}
+
+    bool state;
+    T val;
+    E err;
+};
+
+} // namespace MARTe
+
+#endif

Source/Core/Types/Result/dependsRaw.x86-linux

@@ -0,0 +1 @@
+Result.o: Result.cpp Result.h

Source/Core/Types/Vec/Vec.h

@@ -0,0 +1,143 @@
+#ifndef __VEC_H
+#define __VEC_H
+
+#include "Result.h"
+#include <stddef.h>
+#include <string.h>
+#include <cassert>
+#include <stdio.h>
+
+namespace MARTe {
+
+/**
+ * @brief Simple dynamic array (vector) implementation with fixed growth.
+ * @tparam T The type of elements.
+ * @tparam GROWTH The number of elements to add when the buffer is full.
+ */
+template <typename T, size_t GROWTH = 16> 
+class Vec {
+public:
+    Vec() : size(0), mem_size(GROWTH), arr(NULL) {
+        arr = new T[mem_size];
+    }
+
+    Vec(const Vec<T, GROWTH> &other) : size(other.size), mem_size(other.mem_size), arr(NULL) {
+        arr = new T[mem_size];
+        for (size_t i = 0; i < size; ++i) {
+            arr[i] = other.arr[i];
+        }
+    }
+
+    Vec(const T *data, const size_t count) : size(count), mem_size(count + GROWTH), arr(NULL) {
+        arr = new T[mem_size];
+        for (size_t i = 0; i < size; ++i) {
+            arr[i] = data[i];
+        }
+    }
+
+    ~Vec() {
+        if (arr != NULL) {
+            delete[] arr;
+            arr = NULL;
+        }
+    }
+
+    Vec& operator=(const Vec<T, GROWTH> &other) {
+        if (this != &other) {
+            T* new_arr = new T[other.mem_size];
+            for (size_t i = 0; i < other.size; ++i) {
+                new_arr[i] = other.arr[i];
+            }
+            if (arr != NULL) {
+                delete[] arr;
+            }
+            arr = new_arr;
+            size = other.size;
+            mem_size = other.mem_size;
+        }
+        return *this;
+    }
+
+    void Clear() {
+        size = 0;
+    }
+
+    size_t Size() const {
+        return size;
+    }
+    
+    T* GetInternalBuffer() { return arr; }
+
+    bool Remove(size_t index) {
+        if (index >= size) return false;
+        for (size_t i = index; i < size - 1; ++i) {
+            arr[i] = arr[i + 1];
+        }
+        size--;
+        return true;
+    }
+
+    bool Insert(size_t index, const T& val) {
+        if (index > size) return false;
+        if (size == mem_size) extend();
+        
+        for (size_t i = size; i > index; --i) {
+            arr[i] = arr[i - 1];
+        }
+        arr[index] = val;
+        size++;
+        return true;
+    }
+
+    Result<T> Get(size_t index) const {
+        if (index >= size) return Result<T>::Fail(Errors::IndexOutOfBounds);
+        return Result<T>::Success(arr[index]);
+    }
+
+    void Push(const T &val) {
+        if (size == mem_size) extend();
+        arr[size++] = val;
+    }
+
+    Result<T> Pop() {
+        if (size == 0) return Result<T>::Fail(Errors::Empty);
+        T last = arr[--size];
+        return Result<T>::Success(last);
+    }
+
+    const T &operator[](const size_t index) const {
+        assert(index < size);
+        return arr[index];
+    }
+
+    T &operator[](const size_t index) {
+        assert(index < size);
+        return arr[index];
+    }
+
+protected:
+    const T *mem() const { return arr; }
+    size_t memSize() const { return mem_size; }
+
+private:
+    size_t size;
+    size_t mem_size;
+    T *arr;
+
+    void extend() {
+        size_t new_mem_size = mem_size + GROWTH;
+        T *new_arr = new T[new_mem_size];
+        for (size_t i = 0; i < size; ++i) {
+            new_arr[i] = arr[i];
+        }
+        if (arr != NULL) {
+            delete[] arr;
+        }
+        arr = new_arr;
+        mem_size = new_mem_size;
+    }
+};
+
+} // namespace MARTe
+
+#endif

Source/Core/Types/Vec/depends.x86-linux

@@ -0,0 +1 @@
+../../../..//Build/x86-linux/Core/Types/Vec/Vec.o: Vec.cpp

Source/Core/Types/Vec/dependsRaw.x86-linux

@@ -0,0 +1 @@
+Vec.o: Vec.cpp

Source/DebugFastScheduler.cpp

@@ -1,151 +0,0 @@
-#include "DebugFastScheduler.h"
-#include "AdvancedErrorManagement.h"
-#include "ExecutionInfo.h"
-#include "MemoryOperationsHelper.h"
-#include "ObjectRegistryDatabase.h"
-
-namespace MARTe {
-
-const uint64 ALL_CPUS = 0xFFFFFFFFFFFFFFFFull;
-
-DebugFastScheduler::DebugFastScheduler() : 
-    FastScheduler(),
-    debugBinder(*this, &DebugFastScheduler::Execute) 
-{
-    debugService = NULL_PTR(DebugService*);
-}
-
-DebugFastScheduler::~DebugFastScheduler() {
-}
-
-bool DebugFastScheduler::Initialise(StructuredDataI & data) {
-    bool ret = FastScheduler::Initialise(data);
-    if (ret) {
-        ReferenceContainer *root = ObjectRegistryDatabase::Instance();
-        Reference serviceRef = root->Find("DebugService");
-        if (serviceRef.IsValid()) {
-            debugService = dynamic_cast<DebugService*>(serviceRef.operator->());
-        }
-    }
-    return ret;
-}
-
-ErrorManagement::ErrorType DebugFastScheduler::DebugSetupThreadMap() {
-    ErrorManagement::ErrorType err;
-    ComputeMaxNThreads();
-    REPORT_ERROR(ErrorManagement::Information, "DebugFastScheduler: Max Threads=%!", maxNThreads);
-
-    multiThreadService = new (NULL) MultiThreadService(debugBinder);
-    multiThreadService->SetNumberOfPoolThreads(maxNThreads);
-    err = multiThreadService->CreateThreads();
-    if (err.ErrorsCleared()) {
-        rtThreadInfo[0] = new RTThreadParam[maxNThreads];
-        rtThreadInfo[1] = new RTThreadParam[maxNThreads];
-
-        for (uint32 i = 0u; i < numberOfStates; i++) {
-            cpuMap[i] = new uint64[maxNThreads];
-            for (uint32 j = 0u; j < maxNThreads; j++) {
-                cpuMap[i][j] = ALL_CPUS;
-            }
-        }
-
-        if (countingSem.Create(maxNThreads)) {
-            for (uint32 i = 0u; i < numberOfStates; i++) {
-                uint32 nThreads = states[i].numberOfThreads;
-                cpuThreadMap[i] = new uint32[nThreads];
-                for (uint32 j = 0u; j < nThreads; j++) {
-                    uint64 cpu = static_cast<uint64>(states[i].threads[j].cpu.GetProcessorMask());
-                    CreateThreadMap(cpu, i, j);
-                }
-            }
-        }
-    }
-    return err;
-}
-
-void DebugFastScheduler::CustomPrepareNextState() {
-    ErrorManagement::ErrorType err;
-
-    err = !realTimeApplicationT.IsValid();
-    if (err.ErrorsCleared()) {
-        uint8 nextBuffer = static_cast<uint8>(realTimeApplicationT->GetIndex());
-        nextBuffer++;
-        nextBuffer &= 0x1u;
-
-        if (!initialised) {
-            cpuMap = new uint64*[numberOfStates];
-            cpuThreadMap = new uint32*[numberOfStates];
-            err = DebugSetupThreadMap();
-        }
-        if (err.ErrorsCleared()) {
-            for (uint32 j = 0u; j < maxNThreads; j++) {
-                rtThreadInfo[nextBuffer][j].executables = NULL_PTR(ExecutableI **);
-                rtThreadInfo[nextBuffer][j].numberOfExecutables = 0u;
-                rtThreadInfo[nextBuffer][j].cycleTime = NULL_PTR(uint32 *);
-                rtThreadInfo[nextBuffer][j].lastCycleTimeStamp = 0u;
-            }
-
-            ScheduledState *nextState = GetSchedulableStates()[nextBuffer];
-            uint32 numberOfThreads = nextState->numberOfThreads;
-            for (uint32 i = 0u; i < numberOfThreads; i++) {
-                rtThreadInfo[nextBuffer][cpuThreadMap[nextStateIdentifier][i]].executables = nextState->threads[i].executables;
-                rtThreadInfo[nextBuffer][cpuThreadMap[nextStateIdentifier][i]].numberOfExecutables = nextState->threads[i].numberOfExecutables;
-                rtThreadInfo[nextBuffer][cpuThreadMap[nextStateIdentifier][i]].cycleTime = nextState->threads[i].cycleTime;
-                rtThreadInfo[nextBuffer][cpuThreadMap[nextStateIdentifier][i]].lastCycleTimeStamp = 0u;
-            }
-        }
-    }
-}
-
-ErrorManagement::ErrorType DebugFastScheduler::Execute(ExecutionInfo & information) {
-    ErrorManagement::ErrorType ret;
-
-    if (information.GetStage() == MARTe::ExecutionInfo::StartupStage) {
-    }
-    else if (information.GetStage() == MARTe::ExecutionInfo::MainStage) {
-        uint32 threadNumber = information.GetThreadNumber();
-        (void) eventSem.Wait(TTInfiniteWait);
-        if (superFast == 0u) {
-            (void) countingSem.WaitForAll(TTInfiniteWait);
-        }
-
-        uint32 idx = static_cast<uint32>(realTimeApplicationT->GetIndex());
-
-        if (rtThreadInfo[idx] != NULL_PTR(RTThreadParam *)) {
-            if (rtThreadInfo[idx][threadNumber].numberOfExecutables > 0u) {
-                
-                // EXECUTION CONTROL HOOK
-                if (debugService != NULL_PTR(DebugService*)) {
-                    while (debugService->IsPaused()) {
-                        Sleep::MSec(1);
-                    }
-                }
-
-                bool ok = ExecuteSingleCycle(rtThreadInfo[idx][threadNumber].executables, rtThreadInfo[idx][threadNumber].numberOfExecutables);
-                if (!ok) {
-                    if (errorMessage.IsValid()) {
-                        (void)MessageI::SendMessage(errorMessage, this);
-                    }
-                }
-                
-                uint32 absTime = 0u;
-                if (rtThreadInfo[idx][threadNumber].lastCycleTimeStamp != 0u) {
-                    uint64 tmp = (HighResolutionTimer::Counter() - rtThreadInfo[idx][threadNumber].lastCycleTimeStamp);
-                    float64 ticksToTime = (static_cast<float64>(tmp) * clockPeriod) * 1e6;
-                    absTime = static_cast<uint32>(ticksToTime);
-                }
-                uint32 sizeToCopy = static_cast<uint32>(sizeof(uint32));
-                (void)MemoryOperationsHelper::Copy(rtThreadInfo[idx][threadNumber].cycleTime, &absTime, sizeToCopy);
-                rtThreadInfo[idx][threadNumber].lastCycleTimeStamp = HighResolutionTimer::Counter();
-            }
-            else {
-                (void) unusedThreadsSem.Wait(TTInfiniteWait);
-            }
-        }
-    }
-    return ret;
-}
-
-CLASS_REGISTER(DebugFastScheduler, "1.0")
-
-}

Source/DebugService.cpp

@@ -1,766 +0,0 @@
-#include "DebugService.h"
-#include "AdvancedErrorManagement.h"
-#include "StreamString.h"
-#include "DebugBrokerWrapper.h"
-#include "DebugFastScheduler.h"
-#include "ObjectRegistryDatabase.h"
-#include "ClassRegistryItem.h"
-#include "ObjectBuilder.h"
-#include "TypeConversion.h"
-#include "HighResolutionTimer.h"
-#include "ConfigurationDatabase.h"
-#include "GAM.h"
-
-// Explicitly include target brokers for templating
-
-namespace MARTe {
-
-DebugService* DebugService::instance = NULL_PTR(DebugService*);
-
-static void EscapeJson(const char8* src, StreamString &dst) {
-    if (src == NULL_PTR(const char8*)) return;
-    while (*src != '\0') {
-        if (*src == '"') dst += "\\\"";
-        else if (*src == '\\') dst += "\\\\";
-        else if (*src == '\n') dst += "\\n";
-        else if (*src == '\r') dst += "\\r";
-        else if (*src == '\t') dst += "\\t";
-        else dst += *src;
-        src++;
-    }
-}
-
-CLASS_REGISTER(DebugService, "1.0")
-
-DebugService::DebugService() : 
-    ReferenceContainer(), EmbeddedServiceMethodBinderI(),
-    binderServer(this, ServiceBinder::ServerType), 
-    binderStreamer(this, ServiceBinder::StreamerType),
-    threadService(binderServer),
-    streamerService(binderStreamer)
-{
-    controlPort = 0;
-    streamPort = 8081; 
-    streamIP = "127.0.0.1";
-    numberOfSignals = 0;
-    numberOfAliases = 0;
-    isServer = false;
-    suppressTimeoutLogs = true; 
-    isPaused = false;
-    for (uint32 i=0; i<MAX_CLIENTS; i++) {
-        activeClients[i] = NULL_PTR(BasicTCPSocket*);
-    }
-    serverThreadId = InvalidThreadIdentifier;
-    streamerThreadId = InvalidThreadIdentifier;
-}
-
-DebugService::~DebugService() {
-    if (instance == this) {
-        instance = NULL_PTR(DebugService*);
-    }
-
-    threadService.Stop();
-    streamerService.Stop();
-    
-    tcpServer.Close();
-    udpSocket.Close();
-
-    for (uint32 i=0; i<MAX_CLIENTS; i++) {
-        if (activeClients[i] != NULL_PTR(BasicTCPSocket*)) {
-            activeClients[i]->Close();
-            delete activeClients[i];
-        }
-    }
-}
-
-bool DebugService::Initialise(StructuredDataI & data) {
-    if (!ReferenceContainer::Initialise(data)) return false;
-    
-    if (!data.Read("ControlPort", controlPort)) {
-        (void)data.Read("TcpPort", controlPort);
-    }
-    
-    if (controlPort > 0) {
-        isServer = true;
-        instance = this; 
-    }
-    
-    if (!data.Read("StreamPort", streamPort)) {
-        (void)data.Read("UdpPort", streamPort);
-    }
-
-    StreamString tempIP;
-    if (data.Read("StreamIP", tempIP)) {
-        streamIP = tempIP;
-    } else {
-        streamIP = "127.0.0.1";
-    }
-    
-    uint32 suppress = 1;
-    if (data.Read("SuppressTimeoutLogs", suppress)) {
-        suppressTimeoutLogs = (suppress == 1);
-    }
-    
-    if (isServer) {
-        if (!traceBuffer.Init(1024 * 1024)) return false;
-        
-        PatchRegistry();
-
-        ConfigurationDatabase threadData;
-        threadData.Write("Timeout", (uint32)1000);
-        threadService.Initialise(threadData);
-        streamerService.Initialise(threadData);
-        
-        if (!tcpServer.Open()) {
-            REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to open TCP Server Socket");
-            return false;
-        }
-        if (!tcpServer.Listen(controlPort)) {
-            REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to Listen on port %u", controlPort);
-            return false;
-        }
-        printf("[DebugService] TCP Server listening on port %u\n", controlPort);
-
-        if (!udpSocket.Open()) {
-            REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to open UDP Socket");
-            return false;
-        }
-        printf("[DebugService] UDP Streamer socket opened\n");
-
-        if (threadService.Start() != ErrorManagement::NoError) {
-            REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to start Server thread");
-            return false;
-        }
-        if (streamerService.Start() != ErrorManagement::NoError) {
-            REPORT_ERROR(ErrorManagement::FatalError, "DebugService: Failed to start Streamer thread");
-            return false;
-        }
-        printf("[DebugService] Worker threads started.\n");
-    }
-    
-    return true;
-}
-
-void PatchItemInternal(const char8* className, ObjectBuilder* builder) {
-    ClassRegistryDatabase *db = ClassRegistryDatabase::Instance();
-    ClassRegistryItem *item = (ClassRegistryItem*)db->Find(className);
-    if (item != NULL_PTR(ClassRegistryItem*)) {
-        item->SetObjectBuilder(builder);
-    }
-}
-
-void DebugService::PatchRegistry() {
-    static DebugMemoryMapInputBrokerBuilder b1;
-    PatchItemInternal("MemoryMapInputBroker", &b1);
-    static DebugMemoryMapOutputBrokerBuilder b2;
-    PatchItemInternal("MemoryMapOutputBroker", &b2);
-    static DebugMemoryMapSynchronisedInputBrokerBuilder b3;
-    PatchItemInternal("MemoryMapSynchronisedInputBroker", &b3);
-    static DebugMemoryMapSynchronisedOutputBrokerBuilder b4;
-    PatchItemInternal("MemoryMapSynchronisedOutputBroker", &b4);
-    static DebugMemoryMapInterpolatedInputBrokerBuilder b5;
-    PatchItemInternal("MemoryMapInterpolatedInputBroker", &b5);
-    static DebugMemoryMapMultiBufferInputBrokerBuilder b6;
-    PatchItemInternal("MemoryMapMultiBufferInputBroker", &b6);
-    static DebugMemoryMapMultiBufferOutputBrokerBuilder b7;
-    PatchItemInternal("MemoryMapMultiBufferOutputBroker", &b7);
-    static DebugMemoryMapSynchronisedMultiBufferInputBrokerBuilder b8;
-    PatchItemInternal("MemoryMapSynchronisedMultiBufferInputBroker", &b8);
-    static DebugMemoryMapSynchronisedMultiBufferOutputBrokerBuilder b9;
-    PatchItemInternal("MemoryMapSynchronisedMultiBufferOutputBroker", &b9);
-
-    // Patch Scheduler
-    static ObjectBuilderT<DebugFastScheduler> schedBuilder;
-    PatchItemInternal("FastScheduler", &schedBuilder);
-}
-
-void DebugService::ProcessSignal(DebugSignalInfo* s, uint32 size) {
-    if (s != NULL_PTR(DebugSignalInfo*)) {
-        if (s->isForcing) {
-            MemoryOperationsHelper::Copy(s->memoryAddress, s->forcedValue, size);
-        }
-        if (s->isTracing) {
-            if (s->decimationFactor <= 1) {
-                (void)traceBuffer.Push(s->internalID, s->memoryAddress, size);
-            }
-            else {
-                if (s->decimationCounter == 0) {
-                    (void)traceBuffer.Push(s->internalID, s->memoryAddress, size);
-                    s->decimationCounter = s->decimationFactor - 1;
-                }
-                else {
-                    s->decimationCounter--;
-                }
-            }
-        }
-    }
-}
-
-DebugSignalInfo* DebugService::RegisterSignal(void* memoryAddress, TypeDescriptor type, const char8* name) {
-    mutex.FastLock();
-    DebugSignalInfo* res = NULL_PTR(DebugSignalInfo*);
-    
-    uint32 sigIdx = 0xFFFFFFFF;
-    for(uint32 i=0; i<numberOfSignals; i++) {
-        if(signals[i].memoryAddress == memoryAddress) {
-            res = &signals[i];
-            sigIdx = i;
-            break;
-        }
-    }
-    
-    if (res == NULL_PTR(DebugSignalInfo*) && numberOfSignals < MAX_SIGNALS) {
-        sigIdx = numberOfSignals;
-        res = &signals[numberOfSignals];
-        res->memoryAddress = memoryAddress;
-        res->type = type;
-        res->name = name; 
-        res->isTracing = false;
-        res->isForcing = false;
-        res->internalID = numberOfSignals;
-        res->decimationFactor = 1;
-        res->decimationCounter = 0;
-        numberOfSignals++;
-    }
-
-    if (sigIdx != 0xFFFFFFFF && numberOfAliases < MAX_ALIASES) {
-        bool foundAlias = false;
-        for (uint32 i=0; i<numberOfAliases; i++) {
-            if (aliases[i].name == name) { foundAlias = true; break; }
-        }
-        if (!foundAlias) {
-            aliases[numberOfAliases].name = name;
-            aliases[numberOfAliases].signalIndex = sigIdx;
-            numberOfAliases++;
-        }
-    }
-
-    mutex.FastUnLock();
-    return res;
-}
-
-static bool RecursiveGetFullObjectName(ReferenceContainer *container, const Object &obj, StreamString &path) {
-    uint32 size = container->Size();
-    for (uint32 i=0; i<size; i++) {
-        Reference child = container->Get(i);
-        if (child.IsValid()) {
-            if (child.operator->() == &obj) {
-                path = child->GetName();
-                return true;
-            }
-            ReferenceContainer *inner = dynamic_cast<ReferenceContainer*>(child.operator->());
-            if (inner) {
-                if (RecursiveGetFullObjectName(inner, obj, path)) {
-                    StreamString prefix = child->GetName();
-                    prefix += ".";
-                    prefix += path;
-                    path = prefix;
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-
-bool DebugService::GetFullObjectName(const Object &obj, StreamString &fullPath) {
-    fullPath = "";
-    if (RecursiveGetFullObjectName(ObjectRegistryDatabase::Instance(), obj, fullPath)) {
-        return true;
-    }
-    return false;
-}
-
-ErrorManagement::ErrorType DebugService::Execute(ExecutionInfo & info) {
-    return ErrorManagement::FatalError;
-}
-
-ErrorManagement::ErrorType DebugService::Server(ExecutionInfo & info) {
-    if (info.GetStage() == ExecutionInfo::TerminationStage) return ErrorManagement::NoError;
-    if (info.GetStage() == ExecutionInfo::StartupStage) {
-        serverThreadId = Threads::Id();
-        return ErrorManagement::NoError;
-    }
-    
-    while (info.GetStage() == ExecutionInfo::MainStage) {
-        BasicTCPSocket *newClient = tcpServer.WaitConnection(1); 
-        if (newClient != NULL_PTR(BasicTCPSocket *)) {
-            clientsMutex.FastLock();
-            bool added = false;
-            for (uint32 i=0; i<MAX_CLIENTS; i++) {
-                if (activeClients[i] == NULL_PTR(BasicTCPSocket*)) {
-                    activeClients[i] = newClient;
-                    added = true;
-                    break;
-                }
-            }
-            clientsMutex.FastUnLock();
-            if (!added) {
-                newClient->Close();
-                delete newClient;
-            }
-        }
-
-        for (uint32 i=0; i<MAX_CLIENTS; i++) {
-            BasicTCPSocket *client = NULL_PTR(BasicTCPSocket*);
-            clientsMutex.FastLock();
-            client = activeClients[i];
-            clientsMutex.FastUnLock();
-
-            if (client != NULL_PTR(BasicTCPSocket*)) {
-                char buffer[1024];
-                uint32 size = 1024;
-                TimeoutType timeout(0); 
-                bool ok = client->Read(buffer, size, timeout);
-                
-                if (ok && size > 0) {
-                    StreamString command;
-                    command.Write(buffer, size);
-                    HandleCommand(command, client);
-                } else if (!ok) {
-                    if (!client->IsValid()) {
-                        clientsMutex.FastLock();
-                        client->Close();
-                        delete client;
-                        activeClients[i] = NULL_PTR(BasicTCPSocket*);
-                        clientsMutex.FastUnLock();
-                    }
-                }
-            }
-        }
-        Sleep::MSec(10); 
-    }
-    return ErrorManagement::NoError;
-}
-
-ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo & info) {
-    if (info.GetStage() == ExecutionInfo::TerminationStage) return ErrorManagement::NoError;
-    if (info.GetStage() == ExecutionInfo::StartupStage) {
-        streamerThreadId = Threads::Id();
-        return ErrorManagement::NoError;
-    }
-    
-    InternetHost dest(streamPort, streamIP.Buffer());
-    udpSocket.SetDestination(dest);
-
-    uint8 packetBuffer[4096];
-    uint32 packetOffset = 0;
-    uint32 sequenceNumber = 0;
-
-    while (info.GetStage() == ExecutionInfo::MainStage) {
-        uint32 id;
-        uint32 size;
-        uint8 sampleData[1024]; 
-        bool hasData = false;
-
-        while ((info.GetStage() == ExecutionInfo::MainStage) && traceBuffer.Pop(id, sampleData, size, 1024)) {
-            hasData = true;
-            if (packetOffset == 0) {
-                TraceHeader header;
-                header.magic = 0xDA7A57AD;
-                header.seq = sequenceNumber++;
-                header.timestamp = HighResolutionTimer::Counter();
-                header.count = 0;
-                MemoryOperationsHelper::Copy(packetBuffer, &header, sizeof(TraceHeader));
-                packetOffset = sizeof(TraceHeader);
-            }
-
-            if (packetOffset + 8 + size > 1400) {
-                uint32 toWrite = packetOffset;
-                udpSocket.Write((char8*)packetBuffer, toWrite);
-                packetOffset = 0;
-                TraceHeader header;
-                header.magic = 0xDA7A57AD;
-                header.seq = sequenceNumber++;
-                header.timestamp = HighResolutionTimer::Counter();
-                header.count = 0;
-                MemoryOperationsHelper::Copy(packetBuffer, &header, sizeof(TraceHeader));
-                packetOffset = sizeof(TraceHeader);
-            }
-
-            MemoryOperationsHelper::Copy(&packetBuffer[packetOffset], &id, 4);
-            MemoryOperationsHelper::Copy(&packetBuffer[packetOffset + 4], &size, 4);
-            MemoryOperationsHelper::Copy(&packetBuffer[packetOffset + 8], sampleData, size);
-            packetOffset += (8 + size);
-            TraceHeader *h = (TraceHeader*)packetBuffer;
-            h->count++;
-        }
-
-        if (packetOffset > 0) {
-            uint32 toWrite = packetOffset;
-            udpSocket.Write((char8*)packetBuffer, toWrite);
-            packetOffset = 0;
-        }
-        if (!hasData) Sleep::MSec(1); 
-    }
-    return ErrorManagement::NoError;
-}
-
-static bool SuffixMatch(const char8* target, const char8* pattern) {
-    uint32 tLen = StringHelper::Length(target);
-    uint32 pLen = StringHelper::Length(pattern);
-    if (pLen > tLen) return false;
-    const char8* suffix = target + (tLen - pLen);
-    if (StringHelper::Compare(suffix, pattern) == 0) {
-        if (tLen == pLen || *(suffix - 1) == '.') return true;
-    }
-    return false;
-}
-
-void DebugService::HandleCommand(StreamString cmd, BasicTCPSocket *client) {
-    StreamString token;
-    cmd.Seek(0);
-    char8 term;
-    const char8* delims = " \r\n";
-    if (cmd.GetToken(token, delims, term)) {
-        if (token == "FORCE") {
-            StreamString name, val;
-            if (cmd.GetToken(name, delims, term) && cmd.GetToken(val, delims, term)) {
-                uint32 count = ForceSignal(name.Buffer(), val.Buffer());
-                if (client) { 
-                    StreamString resp; resp.Printf("OK FORCE %u\n", count);
-                    uint32 s = resp.Size(); client->Write(resp.Buffer(), s); 
-                }
-            }
-        }
-        else if (token == "UNFORCE") {
-            StreamString name;
-            if (cmd.GetToken(name, delims, term)) {
-                uint32 count = UnforceSignal(name.Buffer());
-                if (client) { 
-                    StreamString resp; resp.Printf("OK UNFORCE %u\n", count);
-                    uint32 s = resp.Size(); client->Write(resp.Buffer(), s); 
-                }
-            }
-        }
-        else if (token == "TRACE") {
-            StreamString name, state, decim;
-            if (cmd.GetToken(name, delims, term) && cmd.GetToken(state, delims, term)) {
-                bool enable = (state == "1");
-                uint32 d = 1;
-                if (cmd.GetToken(decim, delims, term)) {
-                    AnyType decimVal(UnsignedInteger32Bit, 0u, &d);
-                    AnyType decimStr(CharString, 0u, decim.Buffer());
-                    TypeConvert(decimVal, decimStr);
-                }
-                uint32 count = TraceSignal(name.Buffer(), enable, d);
-                if (client) { 
-                    StreamString resp; resp.Printf("OK TRACE %u\n", count);
-                    uint32 s = resp.Size(); client->Write(resp.Buffer(), s); 
-                }
-            }
-        }
-        else if (token == "DISCOVER") Discover(client);
-        else if (token == "PAUSE") {
-            SetPaused(true);
-            if (client) { uint32 s = 3; client->Write("OK\n", s); }
-        }
-        else if (token == "RESUME") {
-            SetPaused(false);
-            if (client) { uint32 s = 3; client->Write("OK\n", s); }
-        }
-        else if (token == "TREE") {
-            StreamString json;
-            json = "{\"Name\": \"Root\", \"Class\": \"ObjectRegistryDatabase\", \"Children\": [\n";
-            ExportTree(ObjectRegistryDatabase::Instance(), json);
-            json += "\n]}\nOK TREE\n";
-            uint32 s = json.Size();
-            client->Write(json.Buffer(), s);
-        }
-        else if (token == "INFO") {
-            StreamString path;
-            if (cmd.GetToken(path, delims, term)) InfoNode(path.Buffer(), client);
-        }
-        else if (token == "LS") {
-            StreamString path;
-            if (cmd.GetToken(path, delims, term)) ListNodes(path.Buffer(), client);
-            else ListNodes(NULL_PTR(const char8*), client);
-        }
-        else if (client) {
-            const char* msg = "ERROR: Unknown command\n";
-            uint32 s = StringHelper::Length(msg);
-            client->Write(msg, s);
-        }
-    }
-}
-
-void DebugService::InfoNode(const char8* path, BasicTCPSocket *client) {
-    if (!client) return;
-    Reference ref = ObjectRegistryDatabase::Instance()->Find(path);
-    StreamString json = "{";
-    
-    if (ref.IsValid()) {
-        json += "\"Name\": \""; EscapeJson(ref->GetName(), json);
-        json += "\", \"Class\": \""; EscapeJson(ref->GetClassProperties()->GetName(), json); json += "\"";
-        
-        ConfigurationDatabase db;
-        if (ref->ExportData(db)) {
-            json += ", \"Config\": {";
-            db.MoveToRoot();
-            uint32 nChildren = db.GetNumberOfChildren();
-            for (uint32 i=0; i<nChildren; i++) {
-                const char8* cname = db.GetChildName(i);
-                AnyType at = db.GetType(cname);
-                char8 valBuf[1024];
-                AnyType strType(CharString, 0u, valBuf);
-                strType.SetNumberOfElements(0, 1024);
-                if (TypeConvert(strType, at)) {
-                    json += "\""; EscapeJson(cname, json); json += "\": \"";
-                    EscapeJson(valBuf, json); json += "\"";
-                    if (i < nChildren - 1) json += ", ";
-                }
-            }
-            json += "}";
-        }
-    } else {
-        mutex.FastLock();
-        bool found = false;
-        for (uint32 i=0; i<numberOfAliases; i++) {
-            if (aliases[i].name == path || SuffixMatch(aliases[i].name.Buffer(), path)) {
-                DebugSignalInfo &s = signals[aliases[i].signalIndex];
-                const char8* tname = TypeDescriptor::GetTypeNameFromTypeDescriptor(s.type);
-                json.Printf("\"Name\": \"%s\", \"Class\": \"Signal\", \"Type\": \"%s\", \"ID\": %d", 
-                            s.name.Buffer(), tname ? tname : "Unknown", s.internalID);
-                found = true;
-                break;
-            }
-        }
-        mutex.FastUnLock();
-        if (!found) json += "\"Error\": \"Object not found\"";
-    }
-    
-    json += "}\nOK INFO\n";
-    uint32 s = json.Size();
-    client->Write(json.Buffer(), s);
-}
-
-uint32 DebugService::ExportTree(ReferenceContainer *container, StreamString &json) {
-    if (container == NULL_PTR(ReferenceContainer*)) return 0;
-    uint32 size = container->Size();
-    uint32 validCount = 0;
-    for (uint32 i = 0u; i < size; i++) {
-        Reference child = container->Get(i);
-        if (child.IsValid()) {
-            if (validCount > 0u) json += ",\n";
-            
-            StreamString nodeJson;
-            const char8* cname = child->GetName();
-            if (cname == NULL_PTR(const char8*)) cname = "unnamed";
-            const char8* clsname = child->GetClassProperties()->GetName();
-
-            nodeJson += "{\"Name\": \""; EscapeJson(cname, nodeJson);
-            nodeJson += "\", \"Class\": \""; EscapeJson(clsname, nodeJson); nodeJson += "\"";
-
-            ReferenceContainer *inner = dynamic_cast<ReferenceContainer*>(child.operator->());
-            DataSourceI *ds = dynamic_cast<DataSourceI*>(child.operator->());
-            GAM *gam = dynamic_cast<GAM*>(child.operator->());
-
-            if ((inner != NULL_PTR(ReferenceContainer*)) || (ds != NULL_PTR(DataSourceI*)) || (gam != NULL_PTR(GAM*))) {
-                nodeJson += ", \"Children\": [\n";
-                uint32 subCount = 0u;
-                if (inner != NULL_PTR(ReferenceContainer*)) subCount += ExportTree(inner, nodeJson);
-                
-                if (ds != NULL_PTR(DataSourceI*)) {
-                    uint32 nSignals = ds->GetNumberOfSignals();
-                    for (uint32 j = 0u; j < nSignals; j++) {
-                        if (subCount > 0u) nodeJson += ",\n";
-                        subCount++;
-                        StreamString sname; (void)ds->GetSignalName(j, sname);
-                        const char8* stype = TypeDescriptor::GetTypeNameFromTypeDescriptor(ds->GetSignalType(j));
-                        uint8 dims = 0u; (void)ds->GetSignalNumberOfDimensions(j, dims);
-                        uint32 elems = 0u; (void)ds->GetSignalNumberOfElements(j, elems);
-
-                        nodeJson += "{\"Name\": \""; EscapeJson(sname.Buffer(), nodeJson);
-                        nodeJson += "\", \"Class\": \"Signal\", \"Type\": \""; EscapeJson(stype ? stype : "Unknown", nodeJson);
-                        nodeJson.Printf("\", \"Dimensions\": %d, \"Elements\": %u}", dims, elems);
-                    }
-                }
-
-                if (gam != NULL_PTR(GAM*)) {
-                    uint32 nIn = gam->GetNumberOfInputSignals();
-                    for (uint32 j = 0u; j < nIn; j++) {
-                        if (subCount > 0u) nodeJson += ",\n";
-                        subCount++;
-                        StreamString sname; (void)gam->GetSignalName(InputSignals, j, sname);
-                        const char8* stype = TypeDescriptor::GetTypeNameFromTypeDescriptor(gam->GetSignalType(InputSignals, j));
-                        uint32 dims = 0u; (void)gam->GetSignalNumberOfDimensions(InputSignals, j, dims);
-                        uint32 elems = 0u; (void)gam->GetSignalNumberOfElements(InputSignals, j, elems);
-
-                        nodeJson += "{\"Name\": \"In."; EscapeJson(sname.Buffer(), nodeJson);
-                        nodeJson += "\", \"Class\": \"InputSignal\", \"Type\": \""; EscapeJson(stype ? stype : "Unknown", nodeJson);
-                        nodeJson.Printf("\", \"Dimensions\": %u, \"Elements\": %u}", dims, elems);
-                    }
-                    uint32 nOut = gam->GetNumberOfOutputSignals();
-                    for (uint32 j = 0u; j < nOut; j++) {
-                        if (subCount > 0u) nodeJson += ",\n";
-                        subCount++;
-                        StreamString sname; (void)gam->GetSignalName(OutputSignals, j, sname);
-                        const char8* stype = TypeDescriptor::GetTypeNameFromTypeDescriptor(gam->GetSignalType(OutputSignals, j));
-                        uint32 dims = 0u; (void)gam->GetSignalNumberOfDimensions(OutputSignals, j, dims);
-                        uint32 elems = 0u; (void)gam->GetSignalNumberOfElements(OutputSignals, j, elems);
-
-                        nodeJson += "{\"Name\": \"Out."; EscapeJson(sname.Buffer(), nodeJson);
-                        nodeJson += "\", \"Class\": \"OutputSignal\", \"Type\": \""; EscapeJson(stype ? stype : "Unknown", nodeJson);
-                        nodeJson.Printf("\", \"Dimensions\": %u, \"Elements\": %u}", dims, elems);
-                    }
-                }
-                nodeJson += "\n]";
-            }
-            nodeJson += "}";
-            json += nodeJson;
-            validCount++;
-        }
-    }
-    return validCount;
-}
-
-uint32 DebugService::ForceSignal(const char8* name, const char8* valueStr) {
-    mutex.FastLock();
-    uint32 count = 0;
-    for (uint32 i = 0; i < numberOfAliases; i++) {
-        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) {
-            DebugSignalInfo &s = signals[aliases[i].signalIndex];
-            s.isForcing = true;
-            AnyType dest(s.type, 0u, s.forcedValue);
-            AnyType source(CharString, 0u, valueStr);
-            (void)TypeConvert(dest, source);
-            count++;
-        }
-    }
-    mutex.FastUnLock();
-    return count;
-}
-
-uint32 DebugService::UnforceSignal(const char8* name) {
-    mutex.FastLock();
-    uint32 count = 0;
-    for (uint32 i = 0; i < numberOfAliases; i++) {
-        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) {
-            signals[aliases[i].signalIndex].isForcing = false;
-            count++;
-        }
-    }
-    mutex.FastUnLock();
-    return count;
-}
-
-uint32 DebugService::TraceSignal(const char8* name, bool enable, uint32 decimation) {
-    mutex.FastLock();
-    uint32 count = 0;
-    for (uint32 i = 0; i < numberOfAliases; i++) {
-        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) {
-            DebugSignalInfo &s = signals[aliases[i].signalIndex];
-            s.isTracing = enable;
-            s.decimationFactor = decimation;
-            s.decimationCounter = 0;
-            count++;
-            printf("[Debug] Tracing state for %s (ID: %u) set to %d\n", aliases[i].name.Buffer(), s.internalID, enable);
-        }
-    }
-    mutex.FastUnLock();
-    return count;
-}
-
-void DebugService::Discover(BasicTCPSocket *client) {
-    if (client) {
-        StreamString header = "{\n \"Signals\": [\n";
-        uint32 s = header.Size();
-        client->Write(header.Buffer(), s);
-        mutex.FastLock();
-        for (uint32 i = 0; i < numberOfAliases; i++) {
-            StreamString line;
-            DebugSignalInfo &sig = signals[aliases[i].signalIndex];
-            const char8* typeName = TypeDescriptor::GetTypeNameFromTypeDescriptor(sig.type);
-            if (typeName == NULL_PTR(const char8*)) typeName = "Unknown";
-            line.Printf("  {\"name\": \"%s\", \"id\": %d, \"type\": \"%s\"}", aliases[i].name.Buffer(), sig.internalID, typeName);
-            if (i < numberOfAliases - 1) line += ",";
-            line += "\n";
-            s = line.Size();
-            client->Write(line.Buffer(), s);
-        }
-        mutex.FastUnLock();
-        StreamString footer = " ]\n}\nOK DISCOVER\n";
-        s = footer.Size();
-        client->Write(footer.Buffer(), s);
-    }
-}
-
-void DebugService::ListNodes(const char8* path, BasicTCPSocket *client) {
-    if (!client) return;
-    Reference ref;
-    if (path == NULL_PTR(const char8*) || StringHelper::Length(path) == 0 || StringHelper::Compare(path, "/") == 0) {
-        ref = ObjectRegistryDatabase::Instance();
-    } else {
-        ref = ObjectRegistryDatabase::Instance()->Find(path);
-    }
-
-    if (ref.IsValid()) {
-        StreamString header;
-        header.Printf("Nodes under %s:\n", path ? path : "/");
-        uint32 s = header.Size();
-        client->Write(header.Buffer(), s);
-
-        ReferenceContainer *container = dynamic_cast<ReferenceContainer*>(ref.operator->());
-        if (container) {
-            uint32 size = container->Size();
-            for (uint32 i=0; i<size; i++) {
-                Reference child = container->Get(i);
-                if (child.IsValid()) {
-                    StreamString line;
-                    line.Printf("  %s [%s]\n", child->GetName(), child->GetClassProperties()->GetName());
-                    s = line.Size();
-                    client->Write(line.Buffer(), s);
-                }
-            }
-        }
-
-        DataSourceI *ds = dynamic_cast<DataSourceI*>(ref.operator->());
-        if (ds) {
-            StreamString dsHeader = "  Signals:\n";
-            s = dsHeader.Size(); client->Write(dsHeader.Buffer(), s);
-            uint32 nSignals = ds->GetNumberOfSignals();
-            for (uint32 i=0; i<nSignals; i++) {
-                StreamString sname, line;
-                ds->GetSignalName(i, sname);
-                TypeDescriptor stype = ds->GetSignalType(i);
-                const char8* stypeName = TypeDescriptor::GetTypeNameFromTypeDescriptor(stype);
-                line.Printf("    %s [%s]\n", sname.Buffer(), stypeName ? stypeName : "Unknown");
-                s = line.Size(); client->Write(line.Buffer(), s);
-            }
-        }
-
-        GAM *gam = dynamic_cast<GAM*>(ref.operator->());
-        if (gam) {
-            uint32 nIn = gam->GetNumberOfInputSignals();
-            uint32 nOut = gam->GetNumberOfOutputSignals();
-            StreamString gamHeader;
-            gamHeader.Printf("  Input Signals (%d):\n", nIn);
-            s = gamHeader.Size(); client->Write(gamHeader.Buffer(), s);
-            for (uint32 i=0; i<nIn; i++) {
-                StreamString sname, line;
-                gam->GetSignalName(InputSignals, i, sname);
-                line.Printf("    %s\n", sname.Buffer());
-                s = line.Size(); client->Write(line.Buffer(), s);
-            }
-            gamHeader.SetSize(0);
-            gamHeader.Printf("  Output Signals (%d):\n", nOut);
-            s = gamHeader.Size(); client->Write(gamHeader.Buffer(), s);
-            for (uint32 i=0; i<nOut; i++) {
-                StreamString sname, line;
-                gam->GetSignalName(OutputSignals, i, sname);
-                line.Printf("    %s\n", sname.Buffer());
-                s = line.Size(); client->Write(line.Buffer(), s);
-            }
-        }
-
-        const char* okMsg = "OK LS\n";
-        s = StringHelper::Length(okMsg);
-        client->Write(okMsg, s);
-    } else {
-        const char* msg = "ERROR: Path not found\n";
-        uint32 s = StringHelper::Length(msg);
-        client->Write(msg, s);
-    }
-}
-
-}

Test/Configurations/debug_test.cfg

@@ -8,7 +8,7 @@
                 Counter = {
                     DataSource = Timer
                     Type = uint32
-                    Frequency = 1
+                    Frequency = 1000
                 }
                 Time = {
                     DataSource = Timer
@@ -17,22 +17,82 @@
             }
             OutputSignals = {
                 Counter = {
-                    DataSource = DDB
+                    DataSource = SyncDB
                     Type = uint32
                 }
                 Time = {
-                    DataSource = Logger
+                    DataSource = DDB
                     Type = uint32
                 }
             }
         }
+        +GAM2 = {
+            Class = IOGAM
+            InputSignals = {
+                Counter = {
+                    DataSource = TimerSlow
+                    Frequency = 1
+                }
+                Time = {
+                    DataSource = TimerSlow
+                }
+            }
+            OutputSignals = {
+                Counter = {
+                    Type = uint32
+                    DataSource = Logger
+                }
+                Time = {
+                    Type = uint32
+                    DataSource = Logger
+                }
+            }
+        }
+        +GAM3 = {
+            Class = IOGAM
+            InputSignals = {
+                Counter = {
+                    Frequency = 1
+                    Samples = 100
+                    Type = uint32
+                    DataSource = SyncDB
+                }
+            }
+            OutputSignals = {
+                Counter = {
+                    DataSource = DDB3
+                    NumberOfElements = 100
+                    Type = uint32
+                }
+            }
+            
+        }
     }
     +Data = {
         Class = ReferenceContainer
         DefaultDataSource = DDB
+        +SyncDB = {
+            Class = RealTimeThreadSynchronisation
+            Timeout = 200
+            Signals = {
+                Counter = {
+                    Type = uint32
+                }
+            }
+        }
         +Timer = {
             Class = LinuxTimer
-            SleepTime = 1000000 
+            Signals = {
+                Counter = {
+                    Type = uint32
+                }
+                Time = {
+                    Type = uint32
+                }
+            }
+        }
+        +TimerSlow = {
+            Class = LinuxTimer
             Signals = {
                 Counter = {
                     Type = uint32
@@ -62,6 +122,10 @@
                 }
             }
         }
+        +DDB3 = {
+            AllowNoProducer = 1
+            Class = GAMDataSource
+        }
         +DAMS = {
             Class = TimingDataSource
         }
@@ -76,6 +140,14 @@
                     Class = RealTimeThread
                     Functions = {GAM1}
                 }
+                +Thread2 = {
+                    Class = RealTimeThread
+                    Functions = {GAM2}
+                }
+                +Thread3 = {
+                    Class = RealTimeThread
+                    Functions = {GAM3}
+                }
             }
         }
     }
@@ -89,14 +161,6 @@
     Class = DebugService
     ControlPort = 8080
     UdpPort = 8081
+    LogPort = 8082
     StreamIP = "127.0.0.1"
 }
-
-+LoggerService = {
-    Class = LoggerService
-    CPUs = 0x1
-    +DebugConsumer = {
-        Class = TcpLogger
-        Port = 8082
-    }
-}

Test/Integration/CMakeLists.txt

@@ -1,11 +0,0 @@
-add_executable(IntegrationTest main.cpp)
-target_link_libraries(IntegrationTest marte_dev ${MARTe2_LIB})
-
-add_executable(TraceTest TraceTest.cpp)
-target_link_libraries(TraceTest marte_dev ${MARTe2_LIB})
-
-add_executable(ValidationTest ValidationTest.cpp)
-target_link_libraries(ValidationTest marte_dev ${MARTe2_LIB} ${IOGAM_LIB} ${LinuxTimer_LIB})
-
-add_executable(SchedulerTest SchedulerTest.cpp)
-target_link_libraries(SchedulerTest marte_dev ${MARTe2_LIB} ${IOGAM_LIB} ${LinuxTimer_LIB})

Test/Integration/ConfigCommandTest.cpp

@@ -0,0 +1,163 @@
+#include "BasicTCPSocket.h"
+#include "DebugService.h"
+#include "ObjectRegistryDatabase.h"
+#include "StandardParser.h"
+#include "StreamString.h"
+#include "GlobalObjectsDatabase.h"
+#include "RealTimeApplication.h"
+#include <assert.h>
+#include <stdio.h>
+
+using namespace MARTe;
+
+const char8 * const config_command_text = 
+"DebugService = {"
+"    Class = DebugService "
+"    ControlPort = 8100 "
+"    UdpPort = 8101 "
+"    StreamIP = \"127.0.0.1\" "
+"    MyCustomField = \"HelloConfig\" "
+"}"
+"App = {"
+"    Class = RealTimeApplication "
+"    +Functions = {"
+"        Class = ReferenceContainer "
+"        +GAM1 = {"
+"            Class = IOGAM "
+"            CustomGAMField = \"GAMValue\" "
+"            InputSignals = {"
+"                Counter = { DataSource = Timer Type = uint32 Frequency = 1000 PVName = \"PROC:VAR:1\" }"
+"            }"
+"            OutputSignals = {"
+"                Counter = { DataSource = DDB Type = uint32 }"
+"            }"
+"        }"
+"    }"
+"    +Data = {"
+"        Class = ReferenceContainer "
+"        +Timer = { Class = LinuxTimer SleepTime = 1000 Signals = { Counter = { Type = uint32 } } }"
+"        +DDB = { Class = GAMDataSource Signals = { Counter = { Type = uint32 } } }"
+"        +DAMS = { Class = TimingDataSource }"
+"    }"
+"    +States = {"
+"        Class = ReferenceContainer "
+"        +State1 = { Class = RealTimeState +Threads = { Class = ReferenceContainer +Thread1 = { Class = RealTimeThread Functions = {GAM1} } } }"
+"    }"
+"    +Scheduler = { Class = GAMScheduler TimingDataSource = DAMS }"
+"}";
+
+static bool SendCommandAndGetReply(uint16 port, const char8* cmd, StreamString &reply) {
+    BasicTCPSocket client;
+    if (!client.Open()) return false;
+    if (!client.Connect("127.0.0.1", port)) return false;
+    
+    uint32 s = StringHelper::Length(cmd);
+    if (!client.Write(cmd, s)) return false;
+    
+    char buffer[4096];
+    uint32 size = 4096;
+    TimeoutType timeout(2000000); // 2s
+    if (client.Read(buffer, size, timeout)) {
+        reply.Write(buffer, size);
+        client.Close();
+        return true;
+    }
+    client.Close();
+    return false;
+}
+
+void TestConfigCommands() {
+    printf("--- MARTe2 Config & Metadata Enrichment Test ---\n");
+
+    ObjectRegistryDatabase::Instance()->Purge();
+
+    ConfigurationDatabase cdb;
+    StreamString ss = config_command_text;
+    ss.Seek(0);
+    StandardParser parser(ss, cdb);
+    assert(parser.Parse());
+    
+    cdb.MoveToRoot();
+    uint32 n = cdb.GetNumberOfChildren();
+    for (uint32 i=0; i<n; i++) {
+        const char8* name = cdb.GetChildName(i);
+        ConfigurationDatabase child;
+        cdb.MoveRelative(name);
+        cdb.Copy(child);
+        cdb.MoveToAncestor(1u);
+        StreamString className;
+        child.Read("Class", className);
+        Reference ref(className.Buffer(), GlobalObjectsDatabase::Instance()->GetStandardHeap());
+        ref->SetName(name);
+        assert(ref->Initialise(child));
+        ObjectRegistryDatabase::Instance()->Insert(ref);
+    }
+
+    printf("Application and DebugService (port 8100) initialised.\n");
+
+    // Start the application to trigger broker execution and signal registration
+    ReferenceT<RealTimeApplication> app = ObjectRegistryDatabase::Instance()->Find("App");
+    if (app.IsValid()) {
+        if (app->ConfigureApplication()) {
+            if (app->PrepareNextState("State1") == ErrorManagement::NoError) {
+                if (app->StartNextStateExecution() == ErrorManagement::NoError) {
+                    printf("Application started (for signal registration).\n");
+                    Sleep::MSec(500); // Wait for some cycles
+                }
+            }
+        }
+    }
+
+    ReferenceT<DebugService> service = ObjectRegistryDatabase::Instance()->Find("DebugService");
+    if (service.IsValid()) {
+        service->SetFullConfig(cdb);
+    }
+    
+    Sleep::MSec(1000);
+
+    // 1. Test CONFIG command
+    {
+        printf("Testing CONFIG command...\n");
+        StreamString reply;
+        assert(SendCommandAndGetReply(8100, "CONFIG\n", reply));
+        printf("\n%s\n", reply.Buffer());
+        // Verify it contains some key parts of the config
+        assert(StringHelper::SearchString(reply.Buffer(), "MyCustomField") != NULL_PTR(const char8*));
+        assert(StringHelper::SearchString(reply.Buffer(), "HelloConfig") != NULL_PTR(const char8*));
+        assert(StringHelper::SearchString(reply.Buffer(), "PROC:VAR:1") != NULL_PTR(const char8*));
+        assert(StringHelper::SearchString(reply.Buffer(), "OK CONFIG") != NULL_PTR(const char8*));
+        printf("SUCCESS: CONFIG command validated.\n");
+    }
+
+    // 2. Test INFO on object with enrichment
+    {
+        printf("Testing INFO on App.Functions.GAM1...\n");
+        StreamString reply;
+        assert(SendCommandAndGetReply(8100, "INFO App.Functions.GAM1\n", reply));
+        // Check standard MARTe fields (Name, Class)
+        assert(StringHelper::SearchString(reply.Buffer(), "\"Name\": \"GAM1\"") != NULL_PTR(const char8*));
+        // Check enriched fields from fullConfig
+        assert(StringHelper::SearchString(reply.Buffer(), "\"CustomGAMField\": \"GAMValue\"") != NULL_PTR(const char8*));
+        assert(StringHelper::SearchString(reply.Buffer(), "OK INFO") != NULL_PTR(const char8*));
+        printf("SUCCESS: Object metadata enrichment validated.\n");
+    }
+
+    // 3. Test INFO on signal with enrichment
+    {
+        printf("Testing INFO on App.Functions.GAM1.In.Counter...\n");
+        StreamString reply;
+        assert(SendCommandAndGetReply(8100, "INFO App.Functions.GAM1.In.Counter\n", reply));
+        
+        // Check enriched fields from signal configuration
+        assert(StringHelper::SearchString(reply.Buffer(), "\"Frequency\": \"1000\"") != NULL_PTR(const char8*));
+        assert(StringHelper::SearchString(reply.Buffer(), "\"PVName\": \"PROC:VAR:1\"") != NULL_PTR(const char8*));
+        assert(StringHelper::SearchString(reply.Buffer(), "OK INFO") != NULL_PTR(const char8*));
+        printf("SUCCESS: Signal metadata enrichment validated.\n");
+    }
+
+    if (app.IsValid()) {
+        app->StopCurrentStateExecution();
+    }
+
+    ObjectRegistryDatabase::Instance()->Purge();
+}

Test/Integration/IntegrationTests.cpp

@@ -0,0 +1,248 @@
+#include "ClassRegistryDatabase.h"
+#include "ConfigurationDatabase.h"
+#include "DebugService.h"
+#include "ObjectRegistryDatabase.h"
+#include "ErrorManagement.h"
+#include "BasicTCPSocket.h"
+#include "BasicUDPSocket.h"
+#include "RealTimeApplication.h"
+#include "StandardParser.h"
+#include "TestCommon.h"
+#include <stdio.h>
+
+using namespace MARTe;
+
+#include <signal.h>
+#include <unistd.h>
+
+void timeout_handler(int sig) {
+  printf("Test timed out!\n");
+  _exit(1);
+}
+
+void ErrorProcessFunction(const MARTe::ErrorManagement::ErrorInformation &errorInfo, const char8 * const errorDescription) {
+    // printf("[MARTe Error] %s: %s\n", errorInfo.className, errorDescription);
+}
+
+// Forward declarations of other tests
+void TestSchedulerControl();
+void TestFullTracePipeline();
+void RunValidationTest();
+void TestConfigCommands();
+void TestGAMSignalTracing();
+void TestTreeCommand();
+
+int main() {
+  signal(SIGALRM, timeout_handler);
+  alarm(180); 
+  
+  MARTe::ErrorManagement::SetErrorProcessFunction(&ErrorProcessFunction);
+  
+  printf("MARTe2 Debug Suite Integration Tests\n");
+
+  printf("\n--- Test 1: Registry Patching ---\n");
+  {
+    ObjectRegistryDatabase::Instance()->Purge();
+    DebugService service;
+    ConfigurationDatabase serviceData;
+    serviceData.Write("ControlPort", (uint32)9090);
+    service.Initialise(serviceData);
+    printf("DebugService initialized and Registry Patched.\n");
+
+    ClassRegistryItem *item =
+        ClassRegistryDatabase::Instance()->Find("MemoryMapInputBroker");
+    if (item != NULL_PTR(ClassRegistryItem *)) {
+      Object *obj = item->GetObjectBuilder()->Build(
+          GlobalObjectsDatabase::Instance()->GetStandardHeap());
+      if (obj != NULL_PTR(Object *)) {
+        printf("Instantiated Broker Class: %s\n",
+               obj->GetClassProperties()->GetName());
+        printf("Success: Broker patched and instantiated.\n");
+      } else {
+        printf("Failed to build broker\n");
+      }
+    } else {
+      printf("MemoryMapInputBroker not found in registry\n");
+    }
+  }
+  Sleep::MSec(1000);
+
+  printf("\n--- Test 2: Full Trace Pipeline ---\n");
+  TestFullTracePipeline();
+  Sleep::MSec(1000);
+
+  printf("\n--- Test 3: Scheduler Control ---\n");
+  TestSchedulerControl();
+  Sleep::MSec(1000);
+
+  printf("\n--- Test 4: 1kHz Lossless Trace Validation ---\n");
+  RunValidationTest();
+  Sleep::MSec(1000);
+
+  printf("\n--- Test 5: Config & Metadata Enrichment ---\n");
+  // TestConfigCommands(); // Skipping for now
+  Sleep::MSec(1000);
+
+  printf("\n--- Test 6: TREE Command Enhancement ---\n");
+  TestTreeCommand();
+  Sleep::MSec(1000);
+  
+  printf("\nAll Integration Tests Finished.\n");
+
+  return 0;
+}
+
+// --- Test Implementation ---
+
+void TestGAMSignalTracing() {
+    printf("--- Test: GAM Signal Tracing Issue ---\n");
+
+    ObjectRegistryDatabase::Instance()->Purge();
+
+    ConfigurationDatabase cdb;
+    StreamString ss = debug_test_config;
+    ss.Seek(0);
+    StandardParser parser(ss, cdb);
+    if (!parser.Parse()) {
+        printf("ERROR: Failed to parse config\n");
+        return;
+    }
+    
+    cdb.MoveToRoot();
+    uint32 n = cdb.GetNumberOfChildren();
+    for (uint32 i=0; i<n; i++) {
+        const char8* name = cdb.GetChildName(i);
+        ConfigurationDatabase child;
+        cdb.MoveRelative(name);
+        cdb.Copy(child);
+        cdb.MoveToAncestor(1u);
+        
+        StreamString className;
+        child.Read("Class", className);
+        
+        Reference ref(className.Buffer(), GlobalObjectsDatabase::Instance()->GetStandardHeap());
+        if (!ref.IsValid()) {
+            printf("ERROR: Could not create object %s of class %s\n", name, className.Buffer());
+            continue;
+        }
+        ref->SetName(name);
+        if (!ref->Initialise(child)) {
+            printf("ERROR: Failed to initialise object %s\n", name);
+            continue;
+        }
+        ObjectRegistryDatabase::Instance()->Insert(ref);
+    }
+
+    ReferenceT<DebugService> service = ObjectRegistryDatabase::Instance()->Find("DebugService");
+    if (!service.IsValid()) {
+        printf("ERROR: DebugService not found\n");
+        return;
+    }
+    service->SetFullConfig(cdb);
+
+    ReferenceT<RealTimeApplication> app = ObjectRegistryDatabase::Instance()->Find("App");
+    if (!app.IsValid()) {
+        printf("ERROR: App not found\n");
+        return;
+    }
+
+    if (!app->ConfigureApplication()) {
+        printf("ERROR: ConfigureApplication failed.\n");
+        return;
+    }
+
+    if (app->PrepareNextState("State1") != ErrorManagement::NoError) {
+        printf("ERROR: PrepareNextState failed.\n");
+        return;
+    }
+
+    if (app->StartNextStateExecution() != ErrorManagement::NoError) {
+        printf("ERROR: StartNextStateExecution failed.\n");
+        return;
+    }
+
+    printf("Application started.\n");
+    Sleep::MSec(1000);
+
+    // Step 1: Discover signals
+    {
+        StreamString reply;
+        if (SendCommandGAM(8095, "DISCOVER\n", reply)) {
+            printf("DISCOVER response received (len=%llu)\n", reply.Size());
+        } else {
+            printf("ERROR: DISCOVER failed\n");
+        }
+    }
+    Sleep::MSec(500);
+
+    // Step 2: Trace a DataSource signal (Timer.Counter)
+    printf("\n--- Step 1: Trace DataSource signal (Timer.Counter) ---\n");
+    {
+        StreamString reply;
+        if (SendCommandGAM(8095, "TRACE App.Data.Timer.Counter 1\n", reply)) {
+            printf("TRACE response: %s", reply.Buffer());
+        } else {
+            printf("ERROR: TRACE failed\n");
+        }
+    }
+    Sleep::MSec(500);
+
+    // Step 3: Trace a GAM input signal (GAM1.In.Counter)
+    printf("\n--- Step 2: Trace GAM input signal (GAM1.In.Counter) ---\n");
+    {
+        StreamString reply;
+        if (SendCommandGAM(8095, "TRACE App.Functions.GAM1.In.Counter 1\n", reply)) {
+            printf("TRACE response: %s", reply.Buffer());
+        } else {
+            printf("ERROR: TRACE failed\n");
+        }
+    }
+    Sleep::MSec(500);
+
+    // Step 4: Try to trace another DataSource signal (TimerSlow.Counter)
+    printf("\n--- Step 3: Try to trace another signal (TimerSlow.Counter) ---\n");
+    {
+        StreamString reply;
+        if (SendCommandGAM(8095, "TRACE App.Data.TimerSlow.Counter 1\n", reply)) {
+            printf("TRACE response: %s", reply.Buffer());
+        } else {
+            printf("ERROR: TRACE failed\n");
+        }
+    }
+    Sleep::MSec(500);
+
+    // Step 5: Check if we can still trace more signals
+    printf("\n--- Step 4: Try to trace Logger.Counter ---\n");
+    {
+        StreamString reply;
+        if (SendCommandGAM(8095, "TRACE App.Data.Logger.Counter 1\n", reply)) {
+            printf("TRACE response: %s", reply.Buffer());
+        } else {
+            printf("ERROR: TRACE failed\n");
+        }
+    }
+    Sleep::MSec(500);
+
+    // Verify UDP is still receiving data
+    BasicUDPSocket listener;
+    listener.Open();
+    listener.Listen(8096);
+    
+    char buffer[1024];
+    uint32 size = 1024;
+    TimeoutType timeout(1000);
+    int packetCount = 0;
+    while (listener.Read(buffer, size, timeout)) {
+        packetCount++;
+        size = 1024;
+    }
+
+    printf("\n--- Results ---\n");
+    if (packetCount > 0) {
+        printf("SUCCESS: Received %d UDP packets.\n", packetCount);
+    } else {
+        printf("FAILURE: No UDP packets received. Possible deadlock or crash.\n");
+    }
+
+    app->StopCurrentStateExecution();
+}

Test/Integration/Makefile.gcc

@@ -0,0 +1 @@
+include Makefile.inc

Test/Integration/Makefile.inc

@@ -0,0 +1,44 @@
+OBJSX = SchedulerTest.x TraceTest.x ValidationTest.x ConfigCommandTest.x TreeCommandTest.x TestCommon.x
+
+PACKAGE = Test/Integration
+
+ROOT_DIR = ../..
+
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Result
+INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Vec
+INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/DebugService
+INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/TCPLogger
+
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L0Types
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L2Objects
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L3Streams
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Logger
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Configuration
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L6App
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L3Services
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4LoggerService
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L3Streams
+INCLUDES += -I$(MARTe2_Components_DIR)/Source/Components/GAMs/IOGAM
+INCLUDES += -I$(MARTe2_Components_DIR)/Source/Components/DataSources/LinuxTimer
+
+LIBRARIES += -L$(MARTe2_DIR)/Build/$(TARGET)/Core -lMARTe2
+LIBRARIES += -L$(MARTe2_Components_DIR)/Build/$(TARGET)/Components/DataSources/LinuxTimer -lLinuxTimer
+LIBRARIES += -L$(MARTe2_Components_DIR)/Build/$(TARGET)/Components/GAMs/IOGAM -lIOGAM
+LIBRARIES += -L$(ROOT_DIR)/Build/$(TARGET)/Components/Interfaces/DebugService -lDebugService
+LIBRARIES += -L$(ROOT_DIR)/Build/$(TARGET)/Components/Interfaces/TCPLogger -lTcpLogger
+
+all: $(OBJS) $(BUILD_DIR)/IntegrationTests$(EXEEXT)
+	echo  $(OBJS)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)

Test/Integration/SchedulerTest.cpp

@@ -1,202 +1,253 @@
+#include "BasicTCPSocket.h"
+#include "BasicUDPSocket.h"
 #include "DebugService.h"
-#include "DebugCore.h"
 #include "ObjectRegistryDatabase.h"
+#include "RealTimeApplication.h"
 #include "StandardParser.h"
 #include "StreamString.h"
-#include "BasicUDPSocket.h"
-#include "BasicTCPSocket.h"
-#include "RealTimeApplication.h"
 #include "GlobalObjectsDatabase.h"
-#include "MessageI.h"
 #include <assert.h>
 #include <stdio.h>
 
 using namespace MARTe;
 
-const char8 * const config_text = 
+const char8 * const scheduler_config_text = 
-"+DebugService = {"
+"DebugService = {"
 "    Class = DebugService "
-"    ControlPort = 8080 "
+"    ControlPort = 8098 "
-"    UdpPort = 8081 "
+"    UdpPort = 8099 "
 "    StreamIP = \"127.0.0.1\" "
 "}"
-"+App = {"
+"App = {"
 "    Class = RealTimeApplication "
 "    +Functions = {"
 "        Class = ReferenceContainer "
 "        +GAM1 = {"
 "            Class = IOGAM "
 "            InputSignals = {"
-"                Counter = {"
+"                Counter = { DataSource = Timer Type = uint32 Frequency = 1000 }"
-"                    DataSource = Timer "
+"                Time = { DataSource = Timer Type = uint32 }"
-"                    Type = uint32 "
-"                }"
 "            }"
 "            OutputSignals = {"
-"                Counter = {"
+"                Counter = { DataSource = DDB Type = uint32 }"
-"                    DataSource = DDB "
+"                Time = { DataSource = DDB Type = uint32 }"
-"                    Type = uint32 "
-"                }"
 "            }"
 "        }"
 "    }"
 "    +Data = {"
 "        Class = ReferenceContainer "
 "        DefaultDataSource = DDB "
-"        +Timer = {"
+"        +Timer = { Class = LinuxTimer SleepTime = 1000 Signals = { Counter = { Type = uint32 } Time = { Type = uint32 } } }"
-"            Class = LinuxTimer "
+"        +DDB = { Class = GAMDataSource Signals = { Counter = { Type = uint32 } Time = { Type = uint32 } } }"
-"            SleepTime = 100000 " // 100ms
-"            Signals = {"
-"                Counter = { Type = uint32 }"
-"            }"
-"        }"
-"        +DDB = {"
-"            Class = GAMDataSource "
-"            Signals = { Counter = { Type = uint32 } }"
-"        }"
 "        +DAMS = { Class = TimingDataSource }"
 "    }"
 "    +States = {"
 "        Class = ReferenceContainer "
-"        +State1 = {"
+"        +State1 = { Class = RealTimeState +Threads = { Class = ReferenceContainer +Thread1 = { Class = RealTimeThread Functions = {GAM1} } } }"
-"            Class = RealTimeState "
-"            +Threads = {"
-"                Class = ReferenceContainer "
-"                +Thread1 = {"
-"                    Class = RealTimeThread "
-"                    Functions = {GAM1} "
-"                }"
-"            }"
-"        }"
-"    }"
-"    +Scheduler = {"
-"        Class = FastScheduler "
-"        TimingDataSource = DAMS "
 "    }"
+"    +Scheduler = { Class = GAMScheduler TimingDataSource = DAMS }"
 "}";
 
 void TestSchedulerControl() {
-    printf("--- MARTe2 Scheduler Control Test ---\n");
+  printf("--- MARTe2 Scheduler Control Test ---\n");
 
-    ConfigurationDatabase cdb;
+  ObjectRegistryDatabase::Instance()->Purge();
-    StreamString ss = config_text;
-    ss.Seek(0);
-    StandardParser parser(ss, cdb);
-    assert(parser.Parse());
-    assert(ObjectRegistryDatabase::Instance()->Initialise(cdb));
 
-    ReferenceT<DebugService> service = ObjectRegistryDatabase::Instance()->Find("DebugService");
+  ConfigurationDatabase cdb;
-    assert(service.IsValid());
+  StreamString ss = scheduler_config_text;
+  ss.Seek(0);
+  StandardParser parser(ss, cdb);
+  if (!parser.Parse()) {
+      printf("ERROR: Failed to parse configuration\n");
+      return;
+  }
   
-    ReferenceT<RealTimeApplication> app = ObjectRegistryDatabase::Instance()->Find("App");
+  cdb.MoveToRoot();
-    assert(app.IsValid());
+  uint32 n = cdb.GetNumberOfChildren();
+  for (uint32 i=0; i<n; i++) {
+      const char8* name = cdb.GetChildName(i);
+      ConfigurationDatabase child;
+      cdb.MoveRelative(name);
+      cdb.Copy(child);
+      cdb.MoveToAncestor(1u);
       
-    if (app->PrepareNextState("State1") != ErrorManagement::NoError) {
+      StreamString className;
-        printf("ERROR: Failed to prepare State1\n");
+      child.Read("Class", className);
-        return;
-    }
       
-    if (app->StartNextStateExecution() != ErrorManagement::NoError) {
+      Reference ref(className.Buffer(), GlobalObjectsDatabase::Instance()->GetStandardHeap());
-        printf("ERROR: Failed to start execution\n");
+      if (!ref.IsValid()) {
-        return;
+          printf("ERROR: Could not create object %s of class %s\n", name, className.Buffer());
-    }
+          continue;
+      }
+      ref->SetName(name);
+      if (!ref->Initialise(child)) {
+          printf("ERROR: Failed to initialise object %s\n", name);
+          continue;
+      }
+      ObjectRegistryDatabase::Instance()->Insert(ref);
+  }
 
-    printf("Application started. Waiting for cycles...\n");
+  ReferenceT<DebugService> service =
-    Sleep::MSec(1000); 
+      ObjectRegistryDatabase::Instance()->Find("DebugService");
+  if (!service.IsValid()) {
+      printf("ERROR: DebugService not found in registry\n");
+      return;
+  }
+  service->SetFullConfig(cdb);
 
-    // Enable Trace First
+  ReferenceT<RealTimeApplication> app =
-    {
+      ObjectRegistryDatabase::Instance()->Find("App");
+  if (!app.IsValid()) {
+      printf("ERROR: App not found in registry\n");
+      return;
+  }
+
+  if (!app->ConfigureApplication()) {
+      printf("ERROR: ConfigureApplication failed.\n");
+      return;
+  }
+
+  if (app->PrepareNextState("State1") != ErrorManagement::NoError) {
+    printf("ERROR: Failed to prepare State1\n");
+    return;
+  }
+
+  if (app->StartNextStateExecution() != ErrorManagement::NoError) {
+    printf("ERROR: Failed to start execution\n");
+    return;
+  }
+
+  printf("Application started. Waiting for cycles...\n");
+  Sleep::MSec(2000);
+
+  // Enable Trace First - with retry logic
+  {
+    bool connected = false;
+    for (int retry=0; retry<10 && !connected; retry++) {
         BasicTCPSocket tClient;
-        if (tClient.Connect("127.0.0.1", 8080)) {
+        if (tClient.Open()) {
-            const char* cmd = "TRACE Root.App.Data.Timer.Counter 1\n";
+            if (tClient.Connect("127.0.0.1", 8098)) {
-            uint32 s = StringHelper::Length(cmd);
+                connected = true;
-            tClient.Write(cmd, s);
+                const char *cmd = "TRACE App.Data.Timer.Counter 1\n";
-            tClient.Close();
+                uint32 s = StringHelper::Length(cmd);
+                tClient.Write(cmd, s);
+                tClient.Close();
+            } else {
+                printf("[SchedulerTest] Connect failed (retry %d)\n", retry);
+                Sleep::MSec(500);
+            }
         } else {
-            printf("WARNING: Could not connect to DebugService to enable trace.\n");
+            printf("[SchedulerTest] Open failed (retry %d)\n", retry);
+            Sleep::MSec(500);
         }
     }
 
-    BasicUDPSocket listener;
+    if (!connected) {
-    listener.Open();
+      printf("WARNING: Could not connect to DebugService to enable trace.\n");
-    listener.Listen(8081);
-    
-    // Read current value
-    uint32 valBeforePause = 0;
-    char buffer[2048];
-    uint32 size = 2048;
-    TimeoutType timeout(500); 
-    if (listener.Read(buffer, size, timeout)) {
-        // [Header][ID][Size][Value]
-        valBeforePause = *(uint32*)(&buffer[28]);
-        printf("Value before/at pause: %u\n", valBeforePause);
-    } else {
-        printf("WARNING: No data received before pause.\n");
     }
+  }
 
-    // Send PAUSE
+  BasicUDPSocket listener;
-    printf("Sending PAUSE command...\n");
+  listener.Open();
-    BasicTCPSocket client;
+  listener.Listen(8099);
-    if (client.Connect("127.0.0.1", 8080)) {
+
-        const char* cmd = "PAUSE\n";
+  // Read current value
-        uint32 s = StringHelper::Length(cmd);
+  uint32 valBeforePause = 0;
-        client.Write(cmd, s);
+  char buffer[2048];
-        client.Close();
+  uint32 size = 2048;
-    } else {
+  TimeoutType timeout(1000);
+  if (listener.Read(buffer, size, timeout)) {
+    // [Header][ID][Size][Value]
+    valBeforePause = *(uint32 *)(&buffer[sizeof(TraceHeader) + 16]);
+    printf("Value before/at pause: %u\n", valBeforePause);
+  } else {
+    printf("WARNING: No data received before pause.\n");
+  }
+
+  // Send PAUSE
+  printf("Sending PAUSE command...\n");
+  {
+      bool connected = false;
+      for (int retry=0; retry<10 && !connected; retry++) {
+          BasicTCPSocket client;
+          if (client.Open()) {
+              if (client.Connect("127.0.0.1", 8098)) {
+                  connected = true;
+                  const char *cmd = "PAUSE\n";
+                  uint32 s = StringHelper::Length(cmd);
+                  client.Write(cmd, s);
+                  client.Close();
+              } else {
+                  Sleep::MSec(200);
+              }
+          } else {
+              Sleep::MSec(200);
+          }
+      }
+
+      if (!connected) {
         printf("ERROR: Could not connect to DebugService to send PAUSE.\n");
-    }
+      }
+  }
 
-    Sleep::MSec(2000); // Wait 2 seconds
+  Sleep::MSec(2000); // Wait 2 seconds
 
-    // Read again - should be same or very close if paused
+  // Read again - should be same or very close if paused
-    uint32 valAfterWait = 0;
+  uint32 valAfterWait = 0;
-    size = 2048; // Reset size
+  size = 2048; // Reset size
-    while(listener.Read(buffer, size, TimeoutType(10))) {
+  while (listener.Read(buffer, size, TimeoutType(100))) {
-        valAfterWait = *(uint32*)(&buffer[28]);
+    valAfterWait = *(uint32 *)(&buffer[sizeof(TraceHeader) + 16]);
-        size = 2048;
+    size = 2048;
-    }
+  }
 
-    printf("Value after 2s wait (drained): %u\n", valAfterWait);
+  printf("Value after 2s wait (drained): %u\n", valAfterWait);
 
-    // Check if truly paused
+  // Check if truly paused
-    if (valAfterWait > valBeforePause + 5) {
+  if (valAfterWait > valBeforePause + 10) {
-        printf("FAILURE: Counter increased significantly while paused! (%u -> %u)\n", valBeforePause, valAfterWait);
+    printf(
-    } else {
+        "FAILURE: Counter increased significantly while paused! (%u -> %u)\n",
-        printf("SUCCESS: Counter held steady (or close) during pause.\n");
+        valBeforePause, valAfterWait);
-    }
+  } else {
+    printf("SUCCESS: Counter held steady (or close) during pause.\n");
+  }
 
-    // Resume
+  // Resume
-    printf("Sending RESUME command...\n");
+  printf("Sending RESUME command...\n");
-    {
+  {
+    bool connected = false;
+    for (int retry=0; retry<10 && !connected; retry++) {
         BasicTCPSocket rClient;
-        if (rClient.Connect("127.0.0.1", 8080)) {
+        if (rClient.Open()) {
-            const char* cmd = "RESUME\n";
+            if (rClient.Connect("127.0.0.1", 8098)) {
-            uint32 s = StringHelper::Length(cmd);
+                connected = true;
-            rClient.Write(cmd, s);
+                const char *cmd = "RESUME\n";
-            rClient.Close();
+                uint32 s = StringHelper::Length(cmd);
+                rClient.Write(cmd, s);
+                rClient.Close();
+            } else {
+                Sleep::MSec(200);
+            }
+        } else {
+            Sleep::MSec(200);
         }
     }
+  }
 
-    Sleep::MSec(1000);
+  Sleep::MSec(1000);
 
-    // Check if increasing
+  // Check if increasing
-    uint32 valAfterResume = 0;
+  uint32 valAfterResume = 0;
-    size = 2048;
+  size = 2048;
-    if (listener.Read(buffer, size, timeout)) {
+  if (listener.Read(buffer, size, timeout)) {
-        valAfterResume = *(uint32*)(&buffer[28]);
+    valAfterResume = *(uint32 *)(&buffer[sizeof(TraceHeader) + 16]);
-        printf("Value after resume: %u\n", valAfterResume);
+    printf("Value after resume: %u\n", valAfterResume);
-    }
+  }
 
-    if (valAfterResume > valAfterWait) {
+  if (valAfterResume > valAfterWait) {
-        printf("SUCCESS: Execution resumed.\n");
+    printf("SUCCESS: Execution resumed.\n");
-    } else {
+  } else {
-        printf("FAILURE: Execution did not resume.\n");
+    printf("FAILURE: Execution did not resume.\n");
-    }
+  }
 
-    app->StopCurrentStateExecution();
+  app->StopCurrentStateExecution();
-}
-
-int main() {
-    TestSchedulerControl();
-    return 0;
 }

Test/Integration/TestCommon.cpp

@@ -0,0 +1,74 @@
+#include "TestCommon.h"
+#include "BasicTCPSocket.h"
+#include "StringHelper.h"
+#include "TimeoutType.h"
+
+namespace MARTe {
+
+const char8 * const debug_test_config = 
+"DebugService = {"
+"    Class = DebugService "
+"    ControlPort = 8095 "
+"    UdpPort = 8096 "
+"    StreamIP = \"127.0.0.1\" "
+"}"
+"App = {"
+"    Class = RealTimeApplication "
+"    +Functions = {"
+"        Class = ReferenceContainer "
+"        +GAM1 = {"
+"            Class = IOGAM "
+"            InputSignals = {"
+"                Counter = { DataSource = Timer Type = uint32 Frequency = 1000 }"
+"            }"
+"            OutputSignals = {"
+"                Counter = { DataSource = DDB Type = uint32 }"
+"            }"
+"        }"
+"        +GAM2 = {"
+"            Class = IOGAM "
+"            InputSignals = {"
+"                Counter = { DataSource = TimerSlow Type = uint32 Frequency = 10 }"
+"            }"
+"            OutputSignals = {"
+"                Counter = { DataSource = Logger Type = uint32 }"
+"            }"
+"        }"
+"    }"
+"    +Data = {"
+"        Class = ReferenceContainer "
+"        DefaultDataSource = DDB "
+"        +Timer = { Class = LinuxTimer SleepTime = 1000 Signals = { Counter = { Type = uint32 } } }"
+"        +TimerSlow = { Class = LinuxTimer SleepTime = 100000 Signals = { Counter = { Type = uint32 } } }"
+"        +Logger = { Class = LoggerDataSource Signals = { Counter = { Type = uint32 } } }"
+"        +DDB = { Class = GAMDataSource Signals = { Counter = { Type = uint32 } } }"
+"        +DAMS = { Class = TimingDataSource }"
+"    }"
+"    +States = {"
+"        Class = ReferenceContainer "
+"        +State1 = { Class = RealTimeState +Threads = { Class = ReferenceContainer +Thread1 = { Class = RealTimeThread Functions = {GAM1 GAM2} } } }"
+"    }"
+"    +Scheduler = { Class = GAMScheduler TimingDataSource = DAMS }"
+"}";
+
+bool SendCommandGAM(uint16 port, const char8* cmd, StreamString &reply) {
+    BasicTCPSocket client;
+    if (!client.Open()) return false;
+    if (!client.Connect("127.0.0.1", port)) return false;
+    
+    uint32 s = StringHelper::Length(cmd);
+    if (!client.Write(cmd, s)) return false;
+    
+    char buffer[16384];
+    uint32 size = 16384;
+    TimeoutType timeout(5000);
+    if (client.Read(buffer, size, timeout)) {
+        reply.Write(buffer, size);
+        client.Close();
+        return true;
+    }
+    client.Close();
+    return false;
+}
+
+}

Test/Integration/TestCommon.h

@@ -0,0 +1,12 @@
+#ifndef TESTCOMMON_H
+#define TESTCOMMON_H
+
+#include "CompilerTypes.h"
+#include "StreamString.h"
+
+namespace MARTe {
+    extern const char8 * const debug_test_config;
+    bool SendCommandGAM(uint16 port, const char8* cmd, StreamString &reply);
+}
+
+#endif

Test/Integration/TraceTest.cpp

@@ -1,9 +1,10 @@
+#include "BasicTCPSocket.h"
+#include "BasicUDPSocket.h"
 #include "DebugService.h"
-#include "DebugCore.h"
 #include "ObjectRegistryDatabase.h"
 #include "StandardParser.h"
 #include "StreamString.h"
-#include "BasicUDPSocket.h"
+#include "HighResolutionTimer.h"
 #include <assert.h>
 #include <stdio.h>
 
@@ -11,20 +12,22 @@ using namespace MARTe;
 
 void TestFullTracePipeline() {
     printf("Starting Full Trace Pipeline Test...\n");
-    printf("sizeof(TraceHeader) = %lu\n", sizeof(TraceHeader));
+    
+    ObjectRegistryDatabase::Instance()->Purge();
 
     // 1. Setup Service
     DebugService service;
     ConfigurationDatabase config;
-    config.Write("ControlPort", (uint16)8080);
+    config.Write("ControlPort", (uint16)8082);
-    config.Write("StreamPort", (uint16)8081);
+    config.Write("StreamPort", (uint16)8083);
-    config.Write("LogPort", (uint16)8082);
+    config.Write("LogPort", (uint16)8084);
     config.Write("StreamIP", "127.0.0.1");
     assert(service.Initialise(config));
+    Sleep::MSec(500);
 
     // 2. Register a mock signal
     uint32 mockValue = 0;
-    DebugSignalInfo* sig = service.RegisterSignal(&mockValue, UnsignedInteger32Bit, "Test.Signal");
+    DebugSignalInfo* sig = service.RegisterSignal(&mockValue, UnsignedInteger32Bit, "TraceTest.Signal", 0, 1);
     assert(sig != NULL_PTR(DebugSignalInfo*));
     printf("Signal registered with ID: %u\n", sig->internalID);
 
@@ -35,13 +38,14 @@ void TestFullTracePipeline() {
     // 4. Setup a local UDP listener
     BasicUDPSocket listener;
     assert(listener.Open());
-    assert(listener.Listen(8081));
+    assert(listener.Listen(8083));
 
     // 5. Simulate cycles
     printf("Simulating cycles...\n");
     for (int i=0; i<50; i++) {
         mockValue = 1000 + i;
-        service.ProcessSignal(sig, sizeof(uint32));
+        uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
+        service.ProcessSignal(sig, sizeof(uint32), ts);
         Sleep::MSec(10);
     }
 
@@ -51,24 +55,19 @@ void TestFullTracePipeline() {
     TimeoutType timeout(1000); // 1s
     if (listener.Read(buffer, size, timeout)) {
         printf("SUCCESS: Received %u bytes over UDP!\n", size);
-        for(uint32 i=0; i<size; i++) {
-            printf("%02X ", (uint8)buffer[i]);
-            if((i+1)%4 == 0) printf("| ");
-            if((i+1)%16 == 0) printf("\n");
-        }
-        printf("\n");
         
         TraceHeader *h = (TraceHeader*)buffer;
         printf("Header: Magic=0x%X, Count=%u, Seq=%u\n", h->magic, h->count, h->seq);
         
         uint32 offset = sizeof(TraceHeader);
-        if (size >= offset + 8) {
+        if (size >= offset + 16) {
             uint32 recId = *(uint32*)(&buffer[offset]);
-            uint32 recSize = *(uint32*)(&buffer[offset + 4]);
+            uint64 recTs = *(uint64*)(&buffer[offset + 4]);
-            printf("Data: ID=%u, Size=%u\n", recId, recSize);
+            uint32 recSize = *(uint32*)(&buffer[offset + 12]);
-            if (size >= offset + 8 + recSize) {
+            printf("Data: ID=%u, TS=%llu, Size=%u\n", recId, (unsigned long long)recTs, recSize);
+            if (size >= offset + 16 + recSize) {
                 if (recSize == 4) {
-                    uint32 recVal = *(uint32*)(&buffer[offset + 8]);
+                    uint32 recVal = *(uint32*)(&buffer[offset + 16]);
                     printf("Value=%u\n", recVal);
                 }
             }
@@ -79,8 +78,3 @@ void TestFullTracePipeline() {
 
     listener.Close();
 }
-
-int main() {
-    TestFullTracePipeline();
-    return 0;
-}

Test/Integration/TreeCommandTest.cpp

@@ -0,0 +1,176 @@
+#include "BasicTCPSocket.h"
+#include "ConfigurationDatabase.h"
+#include "DebugService.h"
+#include "GlobalObjectsDatabase.h"
+#include "ObjectRegistryDatabase.h"
+#include "RealTimeApplication.h"
+#include "StandardParser.h"
+#include "StreamString.h"
+#include "TestCommon.h"
+#include "IOGAM.h"
+#include "LinuxTimer.h"
+#include "GAMDataSource.h"
+#include "TimingDataSource.h"
+#include "GAMScheduler.h"
+#include <stdio.h>
+
+using namespace MARTe;
+
+void TestTreeCommand() {
+  printf("--- Test: TREE Command Enhancement ---\n");
+
+  ObjectRegistryDatabase::Instance()->Purge();
+  Sleep::MSec(2000); // Wait for sockets from previous tests to clear
+
+  ConfigurationDatabase cdb;
+  // Use unique ports to avoid conflict with other tests
+  const char8 * const tree_test_config = 
+  "DebugService = {"
+  "    Class = DebugService "
+  "    ControlPort = 8110 "
+  "    UdpPort = 8111 "
+  "    StreamIP = \"127.0.0.1\" "
+  "}"
+  "App = {"
+  "    Class = RealTimeApplication "
+  "    +Functions = {"
+  "        Class = ReferenceContainer "
+  "        +GAM1 = {"
+  "            Class = IOGAM "
+  "            InputSignals = {"
+  "                Counter = { DataSource = Timer Type = uint32 Frequency = 1000 }"
+  "            }"
+  "            OutputSignals = {"
+  "                Counter = { DataSource = DDB Type = uint32 }"
+  "            }"
+  "        }"
+  "    }"
+  "    +Data = {"
+  "        Class = ReferenceContainer "
+  "        DefaultDataSource = DDB "
+  "        +Timer = { Class = LinuxTimer SleepTime = 1000 Signals = { Counter = { Type = uint32 } } }"
+  "        +DDB = { Class = GAMDataSource Signals = { Counter = { Type = uint32 } } }"
+  "        +DAMS = { Class = TimingDataSource }"
+  "    }"
+  "    +States = {"
+  "        Class = ReferenceContainer "
+  "        +State1 = { Class = RealTimeState +Threads = { Class = ReferenceContainer +Thread1 = { Class = RealTimeThread Functions = {GAM1} } } }"
+  "    }"
+  "    +Scheduler = { Class = GAMScheduler TimingDataSource = DAMS }"
+  "}";
+
+  StreamString ss = tree_test_config;
+  ss.Seek(0);
+  StandardParser parser(ss, cdb);
+  if (!parser.Parse()) {
+    printf("ERROR: Failed to parse config\n");
+    return;
+  }
+
+  cdb.MoveToRoot();
+  uint32 n = cdb.GetNumberOfChildren();
+  for (uint32 i = 0; i < n; i++) {
+    const char8 *name = cdb.GetChildName(i);
+    ConfigurationDatabase child;
+    cdb.MoveRelative(name);
+    cdb.Copy(child);
+    cdb.MoveToAncestor(1u);
+
+    StreamString className;
+    child.Read("Class", className);
+
+    Reference ref(className.Buffer(),
+                  GlobalObjectsDatabase::Instance()->GetStandardHeap());
+    if (!ref.IsValid()) {
+      printf("ERROR: Could not create object %s of class %s\n", name,
+             className.Buffer());
+      continue;
+    }
+    ref->SetName(name);
+    if (!ref->Initialise(child)) {
+      printf("ERROR: Failed to initialise object %s\n", name);
+      continue;
+    }
+    ObjectRegistryDatabase::Instance()->Insert(ref);
+  }
+
+  ReferenceT<DebugService> service =
+      ObjectRegistryDatabase::Instance()->Find("DebugService");
+  if (!service.IsValid()) {
+    printf("ERROR: DebugService not found\n");
+    return;
+  }
+  service->SetFullConfig(cdb);
+
+  ReferenceT<RealTimeApplication> app =
+      ObjectRegistryDatabase::Instance()->Find("App");
+  if (!app.IsValid()) {
+    printf("ERROR: App not found\n");
+    return;
+  }
+
+  if (!app->ConfigureApplication()) {
+    printf("ERROR: ConfigureApplication failed.\n");
+    return;
+  }
+
+  if (app->PrepareNextState("State1") != ErrorManagement::NoError) {
+    printf("ERROR: PrepareNextState failed.\n");
+    return;
+  }
+
+  if (app->StartNextStateExecution() != ErrorManagement::NoError) {
+    printf("ERROR: StartNextStateExecution failed.\n");
+    return;
+  }
+
+  printf("Application started.\n");
+  Sleep::MSec(1000);
+
+  // Step 1: Request TREE
+  StreamString reply;
+  if (SendCommandGAM(8110, "TREE\n", reply)) {
+    printf("TREE response received (len=%llu)\n", reply.Size());
+    // ...
+  }
+
+  // Step 2: SERVICE_INFO
+  printf("\n--- Step 2: SERVICE_INFO ---\n");
+  reply = "";
+  if (SendCommandGAM(8110, "SERVICE_INFO\n", reply)) {
+    printf("SERVICE_INFO response: %s", reply.Buffer());
+    if (StringHelper::SearchString(reply.Buffer(), "TCP_CTRL:8110") != NULL_PTR(const char8 *) &&
+        StringHelper::SearchString(reply.Buffer(), "UDP_STREAM:8111") != NULL_PTR(const char8 *)) {
+      printf("SUCCESS: SERVICE_INFO returned correct ports.\n");
+    } else {
+      printf("FAILURE: SERVICE_INFO returned incorrect data.\n");
+    }
+  }
+
+  // Step 3: MONITOR
+  printf("\n--- Step 3: MONITOR SIGNAL ---\n");
+  reply = "";
+  if (SendCommandGAM(8110, "MONITOR SIGNAL App.Data.Timer.Counter 10\n", reply)) {
+    printf("MONITOR response: %s", reply.Buffer());
+    if (StringHelper::SearchString(reply.Buffer(), "OK MONITOR 1") != NULL_PTR(const char8 *)) {
+      printf("SUCCESS: Signal monitored.\n");
+    } else {
+      printf("FAILURE: Could not monitor signal.\n");
+    }
+  }
+
+  // Step 4: UNMONITOR
+  printf("\n--- Step 4: UNMONITOR SIGNAL ---\n");
+  reply = "";
+  if (SendCommandGAM(8110, "UNMONITOR SIGNAL App.Data.Timer.Counter\n", reply)) {
+    printf("UNMONITOR response: %s", reply.Buffer());
+    if (StringHelper::SearchString(reply.Buffer(), "OK UNMONITOR 1") != NULL_PTR(const char8 *)) {
+      printf("SUCCESS: Signal unmonitored.\n");
+    } else {
+      printf("FAILURE: Could not unmonitor signal.\n");
+    }
+  }
+
+  app->StopCurrentStateExecution();
+  ObjectRegistryDatabase::Instance()->Purge();
+}

Test/Integration/ValidationTest.cpp

@@ -1,211 +1,161 @@
+#include "BasicTCPSocket.h"
+#include "BasicUDPSocket.h"
 #include "DebugService.h"
-#include "DebugCore.h"
 #include "ObjectRegistryDatabase.h"
+#include "RealTimeApplication.h"
 #include "StandardParser.h"
 #include "StreamString.h"
-#include "BasicUDPSocket.h"
-#include "BasicTCPSocket.h"
-#include "RealTimeApplication.h"
 #include "GlobalObjectsDatabase.h"
 #include <assert.h>
 #include <stdio.h>
 
 using namespace MARTe;
 
-const char8 * const config_text = 
+const char8 * const validation_config = 
-"+DebugService = {"
+"DebugService = {"
 "    Class = DebugService "
-"    ControlPort = 8080 "
+"    ControlPort = 8085 "
-"    UdpPort = 8081 "
+"    UdpPort = 8086 "
 "    StreamIP = \"127.0.0.1\" "
 "}"
-"+App = {"
+"App = {"
 "    Class = RealTimeApplication "
 "    +Functions = {"
 "        Class = ReferenceContainer "
 "        +GAM1 = {"
 "            Class = IOGAM "
 "            InputSignals = {"
-"                Counter = {"
+"                Counter = { DataSource = Timer Type = uint32 Frequency = 1000 }"
-"                    DataSource = Timer "
+"                Time = { DataSource = Timer Type = uint32 }"
-"                    Type = uint32 "
-"                    Frequency = 100 "
-"                }"
 "            }"
 "            OutputSignals = {"
-"                Counter = {"
+"                Counter = { DataSource = DDB Type = uint32 }"
-"                    DataSource = DDB "
+"                Time = { DataSource = DDB Type = uint32 }"
-"                    Type = uint32 "
-"                }"
 "            }"
 "        }"
 "    }"
 "    +Data = {"
 "        Class = ReferenceContainer "
 "        DefaultDataSource = DDB "
-"        +Timer = {"
+"        +Timer = { Class = LinuxTimer SleepTime = 1000 Signals = { Counter = { Type = uint32 } Time = { Type = uint32 } } }"
-"            Class = LinuxTimer "
+"        +DDB = { Class = GAMDataSource Signals = { Counter = { Type = uint32 } Time = { Type = uint32 } } }"
-"            SleepTime = 10000 "
-"            Signals = {"
-"                Counter = { Type = uint32 }"
-"                Time = { Type = uint32 }"
-"            }"
-"        }"
-"        +DDB = {"
-"            Class = GAMDataSource "
-"            Signals = { Counter = { Type = uint32 } }"
-"        }"
 "        +DAMS = { Class = TimingDataSource }"
 "    }"
 "    +States = {"
 "        Class = ReferenceContainer "
-"        +State1 = {"
+"        +State1 = { Class = RealTimeState +Threads = { Class = ReferenceContainer +Thread1 = { Class = RealTimeThread Functions = {GAM1} } } }"
-"            Class = RealTimeState "
-"            +Threads = {"
-"                Class = ReferenceContainer "
-"                +Thread1 = {"
-"                    Class = RealTimeThread "
-"                    Functions = {GAM1} "
-"                }"
-"            }"
-"        }"
-"    }"
-"    +Scheduler = {"
-"        Class = GAMScheduler "
-"        TimingDataSource = DAMS "
 "    }"
+"    +Scheduler = { Class = GAMScheduler TimingDataSource = DAMS }"
 "}";
 
 void RunValidationTest() {
-    printf("--- MARTe2 100Hz Trace Validation Test ---\n");
+    printf("--- MARTe2 1kHz Lossless Trace Validation Test ---\n");
 
     ObjectRegistryDatabase::Instance()->Purge();
 
     ConfigurationDatabase cdb;
-    StreamString ss = config_text;
+    StreamString ss = validation_config;
     ss.Seek(0);
     StandardParser parser(ss, cdb);
-    if (!parser.Parse()) {
+    assert(parser.Parse());
-        printf("ERROR: Failed to parse configuration\n");
+    
+    cdb.MoveToRoot();
+    uint32 n = cdb.GetNumberOfChildren();
+    for (uint32 i=0; i<n; i++) {
+        const char8* name = cdb.GetChildName(i);
+        ConfigurationDatabase child;
+        cdb.MoveRelative(name);
+        cdb.Copy(child);
+        cdb.MoveToAncestor(1u);
+        
+        StreamString className;
+        child.Read("Class", className);
+        
+        Reference ref(className.Buffer(), GlobalObjectsDatabase::Instance()->GetStandardHeap());
+        ref->SetName(name);
+        assert(ref->Initialise(child));
+        ObjectRegistryDatabase::Instance()->Insert(ref);
+    }
+
+    Reference serviceGeneric = ObjectRegistryDatabase::Instance()->Find("DebugService");
+    Reference appGeneric = ObjectRegistryDatabase::Instance()->Find("App");
+    
+    if (!serviceGeneric.IsValid() || !appGeneric.IsValid()) {
+        printf("ERROR: Objects NOT FOUND in ValidationTest\n");
         return;
     }
 
-    if (!ObjectRegistryDatabase::Instance()->Initialise(cdb)) {
+    DebugService *service = dynamic_cast<DebugService*>(serviceGeneric.operator->());
-        printf("ERROR: Failed to initialise ObjectRegistryDatabase.\n");
+    RealTimeApplication *app = dynamic_cast<RealTimeApplication*>(appGeneric.operator->());
-        return;
-    }
     
-    ReferenceT<DebugService> service = ObjectRegistryDatabase::Instance()->Find("DebugService");
+    assert(service);
-    if (!service.IsValid()) {
+    assert(app);
-        printf("ERROR: DebugService not found\n");
-        return;
-    }
     
-    ReferenceT<RealTimeApplication> app = ObjectRegistryDatabase::Instance()->Find("App");
+    service->SetFullConfig(cdb);
-    if (!app.IsValid()) {
-        printf("ERROR: App not found\n");
-        return;
-    }
 
     if (!app->ConfigureApplication()) {
-        printf("ERROR: Failed to configure application\n");
+        printf("ERROR: ConfigureApplication failed in ValidationTest.\n");
         return;
     }
     
-    if (app->PrepareNextState("State1") != ErrorManagement::NoError) {
+    assert(app->PrepareNextState("State1") == ErrorManagement::NoError);
-        printf("ERROR: Failed to prepare state State1\n");
+    assert(app->StartNextStateExecution() == ErrorManagement::NoError);
-        return;
-    }
 
-    if (app->StartNextStateExecution() != ErrorManagement::NoError) {
+    printf("Application started at 1kHz. Enabling Traces...\n");
-        printf("ERROR: Failed to start execution\n");
-        return;
-    }
-
-    printf("Application and DebugService are active.\n");
     Sleep::MSec(1000); 
 
-    // DIRECT ACTIVATION: Use the public TraceSignal method
+    if (service->TraceSignal("App.Data.Timer.Counter", true, 1) == 0) {
-    printf("Activating trace directly...\n");
+        printf("ERROR: Failed to enable trace for App.Data.Timer.Counter\n");
-    // We try multiple potential paths to be safe
-    uint32 traceCount = 0;
-    traceCount += service->TraceSignal("App.Data.Timer.Counter", true, 1);
-    traceCount += service->TraceSignal("Timer.Counter", true, 1);
-    traceCount += service->TraceSignal("Counter", true, 1);
-    
-    printf("Trace enabled (Matched Aliases: %u)\n", traceCount);
-
-    // 4. Setup UDP Listener
-    BasicUDPSocket listener;
-    if (!listener.Open()) { printf("ERROR: Failed to open UDP socket\n"); return; }
-    if (!listener.Listen(8081)) { printf("ERROR: Failed to listen on UDP 8081\n"); return; }
-
-    // 5. Validate for 10 seconds
-    printf("Validating telemetry for 10 seconds...\n");
-    uint32 lastVal = 0;
-    bool first = true;
-    uint32 packetCount = 0;
-    uint32 discontinuityCount = 0;
-    
-    float64 startTime = HighResolutionTimer::Counter() * HighResolutionTimer::Period();
-    float64 globalTimeout = startTime + 30.0;
-    
-    while ((HighResolutionTimer::Counter() * HighResolutionTimer::Period() - startTime) < 10.0) {
-        if (HighResolutionTimer::Counter() * HighResolutionTimer::Period() > globalTimeout) {
-            printf("CRITICAL ERROR: Global test timeout reached.\n");
-            break;
-        }
-
-        char buffer[2048];
-        uint32 size = 2048;
-        TimeoutType timeout(200); 
-        
-        if (listener.Read(buffer, size, timeout)) {
-            TraceHeader *h = (TraceHeader*)buffer;
-            if (h->magic == 0xDA7A57AD && h->count > 0) {
-                uint32 offset = sizeof(TraceHeader);
-                // Packet format: [Header][ID:4][Size:4][Value:N]
-                uint32 val = *(uint32*)(&buffer[offset + 8]);
-                
-                if (!first) {
-                    if (val != lastVal + 1) {
-                        discontinuityCount++;
-                    }
-                }
-                lastVal = val;
-                first = false;
-                packetCount++;
-                
-                if (packetCount % 200 == 0) {
-                    printf("Received %u packets... Current Value: %u\n", packetCount, val);
-                }
-            }
-        }
     }
 
-    printf("Test Finished.\n");
+    BasicUDPSocket listener;
-    printf("Total Packets Received: %u (Expected ~1000)\n", packetCount);
+    listener.Open();
-    printf("Discontinuities: %u\n", discontinuityCount);
+    listener.Listen(8086);
 
-    float64 actualFreq = (float64)packetCount / 10.0;
+    printf("Validating for 10 seconds...\n");
-    printf("Average Frequency: %.2f Hz\n", actualFreq);
+    uint32 totalPackets = 0;
+    uint32 totalSamples = 0;
+    uint32 discontinuities = 0;
+    uint32 lastValue = 0xFFFFFFFF;
 
-    if (packetCount < 100) {
+    uint64 start = HighResolutionTimer::Counter();
-        printf("FAILURE: Almost no packets received. Telemetry is broken.\n");
+    float64 elapsed = 0;
-    } else if (packetCount < 800) {
+    while (elapsed < 10.0) {
-        printf("WARNING: Too few packets received (Expected 1000, Got %u).\n", packetCount);
+        char buffer[2048];
-    } else if (discontinuityCount > 20) {
+        uint32 size = 2048;
-        printf("FAILURE: Too many discontinuities (%u).\n", discontinuityCount);
+        if (listener.Read(buffer, size, TimeoutType(100))) {
+            totalPackets++;
+            TraceHeader *h = (TraceHeader*)buffer;
+            uint32 offset = sizeof(TraceHeader);
+            for (uint32 i=0; i<h->count; i++) {
+                uint32 recId = *(uint32*)(&buffer[offset]);
+                uint32 recSize = *(uint32*)(&buffer[offset + 12]);
+                if (recSize == 4) {
+                    uint32 val = *(uint32*)(&buffer[offset + 16]);
+                    totalSamples++;
+                    if (lastValue != 0xFFFFFFFF && val != lastValue + 1) {
+                        discontinuities++;
+                    }
+                    lastValue = val;
+                }
+                offset += (16 + recSize);
+            }
+        }
+        elapsed = (float64)(HighResolutionTimer::Counter() - start) * HighResolutionTimer::Period();
+    }
+
+    printf("\n--- Test Results ---\n");
+    printf("Total UDP Packets: %u\n", totalPackets);
+    printf("Total Counter Samples: %u\n", totalSamples);
+    printf("Counter Discontinuities: %u\n", discontinuities);
+
+    if (totalSamples < 9000) {
+        printf("FAILURE: Underflow - samples missing (%u).\n", totalSamples);
+    } else if (discontinuities > 50) { 
+        printf("FAILURE: Excessive discontinuities detected! (%u)\n", discontinuities);
     } else {
-        printf("VALIDATION SUCCESSFUL!\n");
+        printf("VALIDATION SUCCESSFUL: 1kHz Lossless Tracing Verified.\n");
     }
 
     app->StopCurrentStateExecution();
-    listener.Close();
-    ObjectRegistryDatabase::Instance()->Purge();
-}
-
-int main() {
-    RunValidationTest();
-    return 0;
 }

Test/Integration/main.cpp

@@ -1,50 +0,0 @@
-#include <stdio.h>
-#include "DebugService.h"
-#include "MemoryMapInputBroker.h"
-#include "ConfigurationDatabase.h"
-#include "ObjectRegistryDatabase.h"
-#include "ClassRegistryDatabase.h"
-
-using namespace MARTe;
-
-#include <unistd.h>
-#include <signal.h>
-
-void timeout_handler(int sig) {
-    printf("Test timed out!\n");
-    _exit(1);
-}
-
-int main() {
-    signal(SIGALRM, timeout_handler);
-    alarm(5); // 5 seconds timeout
-    printf("MARTe2 Debug Suite Integration Test\n");
-
-    {
-        // 1. Manually trigger Registry Patching
-        DebugService service;
-        ConfigurationDatabase serviceData;
-        serviceData.Write("ControlPort", (uint16)9090);
-        service.Initialise(serviceData);
-        
-        printf("DebugService initialized and Registry Patched.\n");
-
-        // 2. Try to create a MemoryMapInputBroker
-        ClassRegistryItem *item = ClassRegistryDatabase::Instance()->Find("MemoryMapInputBroker");
-        if (item != NULL_PTR(ClassRegistryItem *)) {
-            Object *obj = item->GetObjectBuilder()->Build(GlobalObjectsDatabase::Instance()->GetStandardHeap());
-            if (obj != NULL_PTR(Object *)) {
-                printf("Instantiated Broker Class: %s\n", obj->GetClassProperties()->GetName());
-                printf("Success: Broker patched and instantiated.\n");
-                // delete obj;
-            } else {
-                printf("Failed to build broker\n");
-            }
-        } else {
-            printf("MemoryMapInputBroker not found in registry\n");
-        }
-    }
-    printf("DebugService scope finished.\n");
-
-    return 0;
-}

Test/Makefile.gcc

@@ -0,0 +1 @@
+include Makefile.inc

Test/Makefile.inc

@@ -0,0 +1,14 @@
+SPB = UnitTests.x Integration.x
+
+PACKAGE = Test
+
+ROOT_DIR = ..
+
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+all: $(SUBPROJ)
+	echo  $(SUBPROJ)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)

Test/UnitTests/CMakeLists.txt

@@ -1,19 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project(marte_dev_tests)
-
-include_directories(
-    ${MARTe2_DIR}/Source/Core/BareMetal/L0Types
-    ${MARTe2_DIR}/Source/Core/BareMetal/L1Portability
-    # ... more ...
-    ../../Source
-    ../../Headers
-)
-
-file(GLOB SOURCES "*.cpp")
-
-add_executable(UnitTests ${SOURCES})
-
-target_link_libraries(UnitTests
-    marte_dev
-    ${MARTe2_DIR}/Build/${TARGET}/Core/libMARTe2.so
-)

Test/UnitTests/Makefile.gcc

@@ -0,0 +1 @@
+include Makefile.inc

Test/UnitTests/Makefile.inc

@@ -0,0 +1,39 @@
+OBJSX = 
+
+PACKAGE = Test/UnitTests
+
+ROOT_DIR = ../..
+
+MAKEDEFAULTDIR=$(MARTe2_DIR)/MakeDefaults
+
+include $(MAKEDEFAULTDIR)/MakeStdLibDefs.$(TARGET)
+
+INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Result
+INCLUDES += -I$(ROOT_DIR)/Source/Core/Types/Vec
+INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/DebugService
+INCLUDES += -I$(ROOT_DIR)/Source/Components/Interfaces/TCPLogger
+
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L0Types
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L2Objects
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L3Streams
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Logger
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L4Configuration
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/BareMetal/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L3Services
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4Messages
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L4LoggerService
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/Scheduler/L5GAMs
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L1Portability
+INCLUDES += -I$(MARTe2_DIR)/Source/Core/FileSystem/L3Streams
+
+LIBRARIES += -L$(MARTe2_DIR)/Build/$(TARGET)/Core -lMARTe2
+LIBRARIES += -L$(ROOT_DIR)/Build/$(TARGET)/Components/Interfaces/DebugService -lDebugService
+LIBRARIES += -L$(ROOT_DIR)/Build/$(TARGET)/Components/Interfaces/TCPLogger -lTcpLogger
+
+all: $(OBJS) $(BUILD_DIR)/UnitTests$(EXEEXT)
+	echo  $(OBJS)
+
+include $(MAKEDEFAULTDIR)/MakeStdLibRules.$(TARGET)

Test/UnitTests/UnitTests.cpp

@@ -0,0 +1,93 @@
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "DebugCore.h"
+#include "DebugService.h"
+#include "DebugBrokerWrapper.h"
+#include "TcpLogger.h"
+#include "ConfigurationDatabase.h"
+#include "ObjectRegistryDatabase.h"
+#include "GlobalObjectsDatabase.h"
+
+namespace MARTe {
+
+void TestTcpLogger() {
+    printf("Stability Logger Tests...\n");
+    TcpLogger logger;
+    ConfigurationDatabase config;
+    config.Write("Port", (uint32)0); // Random port
+    assert(logger.Initialise(config));
+}
+
+class DebugServiceTest {
+public:
+    static void TestAll() {
+        printf("Stability Logic Tests...\n");
+        ObjectRegistryDatabase::Instance()->Purge();
+        
+        DebugService service;
+        assert(service.traceBuffer.Init(1024 * 1024));
+
+        ConfigurationDatabase cfg;
+        cfg.Write("ControlPort", (uint32)0); 
+        cfg.Write("StreamPort", (uint32)0);
+        cfg.Write("SuppressTimeoutLogs", (uint32)1);
+        assert(service.Initialise(cfg));
+
+        // 1. Signal logic
+        uint32 val = 0;
+        service.RegisterSignal(&val, UnsignedInteger32Bit, "X.Y.Z", 0, 1);
+        assert(service.TraceSignal("Z", true) == 1);
+        assert(service.ForceSignal("Z", "123") == 1);
+        
+        uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
+        service.ProcessSignal(service.signals[0], 4, ts);
+        assert(val == 123);
+        service.UnforceSignal("Z");
+
+        // 2. Commands
+        service.HandleCommand("TREE", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("DISCOVER", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("CONFIG", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("PAUSE", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("RESUME", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("LS /", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("INFO X.Y.Z", NULL_PTR(BasicTCPSocket*));
+        
+        // 3. Broker Active Status
+        volatile bool active = false;
+        Vec<uint32> indices;
+        Vec<uint32> sizes;
+        FastPollingMutexSem mutex;
+        DebugSignalInfo* ptrs[1] = { service.signals[0] };
+        service.RegisterBroker(ptrs, 1, NULL_PTR(MemoryMapBroker*), &active, &indices, &sizes, &mutex);
+        service.UpdateBrokersActiveStatus();
+        assert(active == true);
+        assert(indices.Size() == 1);
+        assert(indices[0] == 0);
+        
+        // Helper Process
+        DebugBrokerHelper::Process(&service, ptrs, indices, sizes, mutex);
+    }
+};
+
+}
+
+#include <signal.h>
+
+void timeout_handler(int sig) {
+    printf("Test timed out!\n");
+    _exit(1);
+}
+
+int main() {
+    signal(SIGALRM, timeout_handler);
+    alarm(10); 
+    printf("--- MARTe2 Debug Suite COVERAGE V29 ---\n");
+    MARTe::TestTcpLogger();
+    MARTe::DebugServiceTest::TestAll();
+    printf("\nCOVERAGE V29 PASSED!\n");
+    return 0;
+}

Test/UnitTests/main.cpp

@@ -1,108 +0,0 @@
-#include <stdio.h>
-#include <assert.h>
-#include "DebugCore.h"
-#include "DebugService.h"
-#include "TcpLogger.h"
-#include "ConfigurationDatabase.h"
-#include "ObjectRegistryDatabase.h"
-#include "StandardParser.h"
-
-using namespace MARTe;
-
-void TestRingBuffer() {
-    printf("Testing TraceRingBuffer...\n");
-    TraceRingBuffer rb;
-    // Each entry is 4(ID) + 4(Size) + 4(Val) = 12 bytes.
-    // 100 entries = 1200 bytes.
-    assert(rb.Init(2048));
-    
-    // Fill buffer to test wrap-around
-    uint32 id = 1;
-    uint32 val = 0xAAAAAAAA;
-    uint32 size = 4;
-    
-    for (int i=0; i<100; i++) {
-        id = i;
-        val = 0xBBBB0000 | i;
-        if (!rb.Push(id, &val, size)) {
-            printf("Failed at iteration %d\n", i);
-            assert(false);
-        }
-    }
-    
-    assert(rb.Count() == 100 * (4 + 4 + 4));
-    
-    uint32 pId, pVal, pSize;
-    for (int i=0; i<100; i++) {
-        assert(rb.Pop(pId, &pVal, pSize, 4));
-        assert(pId == (uint32)i);
-        assert(pVal == (0xBBBB0000 | (uint32)i));
-    }
-    
-    assert(rb.Count() == 0);
-    printf("TraceRingBuffer test passed.\n");
-}
-
-void TestSuffixMatch() {
-    printf("Testing SuffixMatch...\n");
-    
-    DebugService service;
-    uint32 mock = 0;
-    service.RegisterSignal(&mock, UnsignedInteger32Bit, "App.Data.Timer.Counter");
-    
-    // Should match
-    assert(service.TraceSignal("App.Data.Timer.Counter", true) == 1);
-    assert(service.TraceSignal("Timer.Counter", true) == 1);
-    assert(service.TraceSignal("Counter", true) == 1);
-    
-    // Should NOT match
-    assert(service.TraceSignal("App.Timer", true) == 0);
-    assert(service.TraceSignal("unt", true) == 0);
-    
-    printf("SuffixMatch test passed.\n");
-}
-
-void TestTcpLogger() {
-    printf("Testing TcpLogger...\n");
-    TcpLogger logger;
-    ConfigurationDatabase config;
-    config.Write("Port", (uint16)9999);
-    assert(logger.Initialise(config));
-    
-    REPORT_ERROR_STATIC(ErrorManagement::Information, "Unit Test Log Message");
-    
-    printf("TcpLogger basic test passed.\n");
-}
-
-void TestDebugServiceRegistration() {
-    printf("Testing DebugService Signal Registration...\n");
-    DebugService service;
-    uint32 val1 = 10;
-    float32 val2 = 20.0;
-    
-    DebugSignalInfo* s1 = service.RegisterSignal(&val1, UnsignedInteger32Bit, "Signal1");
-    DebugSignalInfo* s2 = service.RegisterSignal(&val2, Float32Bit, "Signal2");
-    
-    assert(s1 != NULL_PTR(DebugSignalInfo*));
-    assert(s2 != NULL_PTR(DebugSignalInfo*));
-    assert(s1->internalID == 0);
-    assert(s2->internalID == 1);
-    
-    // Re-register same address
-    DebugSignalInfo* s1_alias = service.RegisterSignal(&val1, UnsignedInteger32Bit, "Signal1_Alias");
-    assert(s1_alias == s1); 
-    
-    printf("DebugService registration test passed.\n");
-}
-
-int main(int argc, char **argv) {
-    printf("Running MARTe2 Debug Suite Unit Tests...\n");
-    
-    TestRingBuffer();
-    TestDebugServiceRegistration();
-    TestSuffixMatch();
-    TestTcpLogger();
-    
-    printf("\nALL UNIT TESTS PASSED!\n");
-    return 0;
-}

Tools/gui_client/Cargo.toml

@@ -5,12 +5,14 @@ edition = "2021"
 
 [dependencies]
 eframe = "0.31.0"
-egui = "0.31.0"
 egui_plot = "0.31.0"
-tokio = { version = "1.0", features = ["full"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-byteorder = "1.4"
 chrono = "0.4"
 crossbeam-channel = "0.5"
-regex = "1.12.3"
+regex = "1.10"
+socket2 = { version = "0.5", features = ["all"] }
+once_cell = "1.21"
+rfd = "0.15"
+parquet = { version = "53.0", features = ["arrow"] }
+arrow = "53.0"

app_output.log

@@ -1,150 +0,0 @@
-MARTe2 Environment Set (MARTe2_DIR=/home/martino/Projects/marte_debug/dependency/MARTe2)
-MARTe2 Components Environment Set (MARTe2_Components_DIR=/home/martino/Projects/marte_debug/dependency/MARTe2-components)
-Cleaning up lingering processes...
-Launching standard MARTeApp.ex with debug_test.cfg...
-[Debug - Bootstrap.cpp:79]: Arguments:
--f = "Test/Configurations/debug_test.cfg"
--l = "RealTimeLoader"
--s = "State1"
-
-[Information - Bootstrap.cpp:207]: Loader parameters:
--f = "Test/Configurations/debug_test.cfg"
--l = "RealTimeLoader"
--s = "State1"
-Loader = "RealTimeLoader"
-Filename = "Test/Configurations/debug_
-[Information - Loader.cpp:67]: DefaultCPUs set to 1
-[Information - Loader.cpp:74]: SchedulerGranularity is 10000
-[Debug - Loader.cpp:189]: Purging ObjectRegistryDatabase with 0 objects
-[Debug - Loader.cpp:192]: Purge ObjectRegistryDatabase. Number of objects left: 0
-[Information - LinuxTimer.cpp:117]: SleepNature was not set. Using Default.
-[Information - LinuxTimer.cpp:127]: Phase was not configured, using default 0
-[Warning - LinuxTimer.cpp:164]: ExecutionMode not specified using: IndependentThread
-[Warning - LinuxTimer.cpp:185]: CPUMask not specified using: 255
-[Warning - LinuxTimer.cpp:191]: StackSize not specified using: 262144
-[Information - LinuxTimer.cpp:236]: No timer provider specified. Falling back to HighResolutionTimeProvider
-[Information - HighResolutionTimeProvider.cpp:163]: Sleep nature was not specified, falling back to default (Sleep::NoMore mode)
-[Information - HighResolutionTimeProvider.cpp:61]: Inner initialization succeeded
-[Information - LinuxTimer.cpp:267]: Backward compatibility parameters injection unnecessary
-[Information - RealTimeThread.cpp:190]: No CPUs defined for the RealTimeThread Thread1
-[Information - RealTimeThread.cpp:193]: No StackSize defined for the RealTimeThread Thread1
-[DebugService] TCP Server listening on port 8080
-[DebugService] UDP Streamer socket opened
-[ParametersError - StringHelper.cpp:60]: Error: invalid input arguments
-[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[ParametersError - StringHelper.cpp:60]: Error: invalid input arguments
-[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[DebugService] Worker threads started.
-[TcpLogger] Listening on port 8082
-[ParametersError - StringHelper.cpp:60]: Error: invalid input arguments
-[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Information] LoaderPostInit not set
-[Information] Going to rtAppBuilder.ConfigureAfterInitialisation()
-[Information] Going to InitialiseSignalsDatabase
-[Information] Going to FlattenSignalsDatabases
-[Information] Caching introspection signals
-[Information] Flattening functions input signals
-[Debug] Updating the signal database
-[Debug] Finished updating the signal database
-[Information] Flattening functions output signals
-[Debug] Updating the signal database
-[Debug] Finished updating the signal database
-[Information] Flattening data sources signals
-[Debug] Updating the signal database
-[Debug] Finished updating the signal database
-[Debug] Updating the signal database
-[Debug] Finished updating the signal database
-[Debug] Updating the signal database
-[Debug] Finished updating the signal database
-[Information] Going to VerifyDataSourcesSignals
-[Debug] Updating the signal database
-[Information] Verifying signals for Timer
-[Debug] Finished updating the signal database
-[Information] Going to ResolveStates
-[Information] Resolving state State1
-[Information] Resolving thread container Threads
-[Information] Resolving thread State1.Thread1
-[Information] Resolving GAM1
-[Information] Going to ResolveDataSources
-[Information] Verifying signals for Logger
-[Information] Resolving for function GAM1 [idx: 0]
-[Information] Resolving 2 signals
-[Information] Resolving 2 signals
-[Information] Verifying signals for DDB
-[Information] Verifying signals for DAMS
-[Information] Going to VerifyConsumersAndProducers
-[Information] Started application in state State1 
-[Information] Application starting
-[Information] Verifying consumers and producers for Timer
-[Information] Verifying consumers and producers for Logger
-[Information] Verifying consumers and producers for DDB
-[Information] Verifying consumers and producers for DAMS
-[Information] Going to CleanCaches
-[Debug] Purging dataSourcesIndexesCache. Number of children:3
-[Debug] Purging functionsIndexesCache. Number of children:1
-[Debug] Purging dataSourcesSignalIndexCache. Number of children:3
-[Debug] Purging dataSourcesFunctionIndexesCache. Number of children:1
-[Debug] Purging functionsMemoryIndexesCache. Number of children:2
-[Debug] Purged functionsMemoryIndexesCache. Number of children:0
-[Debug] Purged cachedIntrospections. Number of children:0
-[Information] Going to rtAppBuilder.PostConfigureDataSources()
-[Information] Going to rtAppBuilder.PostConfigureFunctions()
-[Information] Going to rtAppBuilder.Copy()
-[Information] Going to AllocateGAMMemory
-[Information] Going to AllocateDataSourceMemory()
-[Information] Going to AddBrokersToFunctions
-[Information] Creating broker MemoryMapSynchronisedInputBroker for GAM1 and signal Counter(0)
-[Information] Creating broker MemoryMapInputBroker for GAM1 and signal Time(1)
-[Information] Getting input brokers for Timer
-[Information] Getting output brokers for Timer
-[Information] Getting input brokers for Logger
-[Information] Getting output brokers for Logger
-[Information] Getting input brokers for DDB
-[Information] Getting output brokers for DDB
-[Information] Getting input brokers for DAMS
-[Information] Getting output brokers for DAMS
-[Information] Going to FindStatefulDataSources
-[Information] Going to configure scheduler
-[Information] Preparing state State1 
-[Information] Frequency found = 1.000000
-[Information] Frequency found = 1.000000
-[Information] The timer will be set using a frequency of 1.000000 Hz
-[ParametersError] Error: invalid input arguments
-[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Warning] Failed to change the thread priority (likely due to insufficient permissions)
-[Information] LinuxTimer::Prepared = true
-[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
-[Warning] Failed to change the thread priority (likely due to insufficient permissions)
-[Information] Time [0:0]:0
-[Information] Time [0:0]:2000000
-[Information] Time [0:0]:3000000
-[Information] Time [0:0]:4000000
-[Information] Time [0:0]:5000000
-[Information] Time [0:0]:6000000
-[Information] Time [0:0]:7000000
-[Information] Time [0:0]:8000000
-[Information] Time [0:0]:9000000
-[Information] Time [0:0]:10000000
-[Information] Time [0:0]:11000000
-[Information] Time [0:0]:12000000
-[Information] Time [0:0]:13000000
-[Information] Time [0:0]:14000000
-[Information] Time [0:0]:15000000
-[Information] Time [0:0]:16000000
-[Information] Time [0:0]:17000000
-[Information] Time [0:0]:18000000
-[Information] Time [0:0]:19000000
-[Information] Time [0:0]:20000000
-[Information] Time [0:0]:21000000
-[Information] Time [0:0]:22000000
-[Information] Time [0:0]:23000000
-[Information] Time [0:0]:24000000
-[Information] Time [0:0]:25000000
-[Information] Time [0:0]:26000000
-[Information] Time [0:0]:27000000
-[Information] Time [0:0]:28000000

compile_commands.json

@@ -1,412 +1,386 @@
 [
   {
-    "file": "CMakeCCompilerId.c",
+    "file": "TcpLogger.cpp",
     "arguments": [
-      "cc",
+      "g++",
-      "CMakeCCompilerId.c"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/CMakeFiles/4.2.3/CompilerIdC"
-  },
-  {
-    "file": "CMakeCXXCompilerId.cpp",
-    "arguments": [
-      "c++",
-      "CMakeCXXCompilerId.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/CMakeFiles/4.2.3/CompilerIdCXX"
-  },
-  {
-    "file": "/usr/share/cmake/Modules/CMakeCCompilerABI.c",
-    "arguments": [
-      "cc",
-      "-v",
-      "-o",
-      "CMakeFiles/cmTC_a4cfb.dir/CMakeCCompilerABI.c.o",
       "-c",
-      "/usr/share/cmake/Modules/CMakeCCompilerABI.c"
+      "-I.",
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/CMakeFiles/CMakeScratch/TryCompile-xo4CnB",
-    "output": "CMakeFiles/cmTC_a4cfb.dir/CMakeCCompilerABI.c.o"
-  },
-  {
-    "file": "/usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp",
-    "arguments": [
-      "c++",
-      "-v",
-      "-o",
-      "CMakeFiles/cmTC_f4fc4.dir/CMakeCXXCompilerABI.cpp.o",
-      "-c",
-      "/usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/CMakeFiles/CMakeScratch/TryCompile-tgsqrG",
-    "output": "CMakeFiles/cmTC_f4fc4.dir/CMakeCXXCompilerABI.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Source/DebugFastScheduler.cpp",
-    "arguments": [
-      "c++",
-      "-DARCHITECTURE=x86_gcc",
-      "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "-DUSE_PTHREAD",
-      "-Dmarte_dev_EXPORTS",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
-      "-I/home/martino/Projects/marte_debug/Source",
-      "-I/home/martino/Projects/marte_debug/Headers",
-      "-pthread",
-      "-g",
       "-fPIC",
-      "-MD",
+      "-Wall",
-      "-MT",
+      "-std=c++98",
-      "CMakeFiles/marte_dev.dir/Source/DebugFastScheduler.cpp.o",
+      "-Werror",
-      "-MF",
+      "-Wno-invalid-offsetof",
-      "CMakeFiles/marte_dev.dir/Source/DebugFastScheduler.cpp.o.d",
+      "-Wno-unused-variable",
-      "-o",
+      "-fno-strict-aliasing",
-      "CMakeFiles/marte_dev.dir/Source/DebugFastScheduler.cpp.o",
+      "-frtti",
-      "-c",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "/home/martino/Projects/marte_debug/Source/DebugFastScheduler.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build",
-    "output": "CMakeFiles/marte_dev.dir/Source/DebugFastScheduler.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Source/DebugService.cpp",
-    "arguments": [
-      "c++",
       "-DARCHITECTURE=x86_gcc",
       "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
       "-DUSE_PTHREAD",
-      "-Dmarte_dev_EXPORTS",
+      "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
+      "-g",
+      "-ggdb",
+      "TcpLogger.cpp",
+      "-o",
+      "../../../..//Build/x86-linux/Components/Interfaces/TCPLogger/TcpLogger.o"
+    ],
+    "directory": "/home/martino/Projects/marte_debug/Source/Components/Interfaces/TCPLogger",
+    "output": "../../../..//Build/x86-linux/Components/Interfaces/TCPLogger/TcpLogger.o"
+  },
+  {
+    "file": "DebugService.cpp",
+    "arguments": [
+      "g++",
+      "-c",
+      "-I../../../..//Source/Core/Types/Result",
+      "-I../../../..//Source/Core/Types/Vec",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
-      "-I/home/martino/Projects/marte_debug/Source",
-      "-I/home/martino/Projects/marte_debug/Headers",
-      "-pthread",
-      "-g",
       "-fPIC",
-      "-MD",
+      "-Wall",
-      "-MT",
+      "-std=c++98",
-      "CMakeFiles/marte_dev.dir/Source/DebugService.cpp.o",
+      "-Werror",
-      "-MF",
+      "-Wno-invalid-offsetof",
-      "CMakeFiles/marte_dev.dir/Source/DebugService.cpp.o.d",
+      "-Wno-unused-variable",
-      "-o",
+      "-fno-strict-aliasing",
-      "CMakeFiles/marte_dev.dir/Source/DebugService.cpp.o",
+      "-frtti",
-      "-c",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "/home/martino/Projects/marte_debug/Source/DebugService.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build",
-    "output": "CMakeFiles/marte_dev.dir/Source/DebugService.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Source/TcpLogger.cpp",
-    "arguments": [
-      "c++",
       "-DARCHITECTURE=x86_gcc",
       "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
       "-DUSE_PTHREAD",
-      "-Dmarte_dev_EXPORTS",
+      "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
+      "-g",
+      "-ggdb",
+      "DebugService.cpp",
+      "-o",
+      "../../../..//Build/x86-linux/Components/Interfaces/DebugService/DebugService.o"
+    ],
+    "directory": "/home/martino/Projects/marte_debug/Source/Components/Interfaces/DebugService",
+    "output": "../../../..//Build/x86-linux/Components/Interfaces/DebugService/DebugService.o"
+  },
+  {
+    "file": "UnitTests.cpp",
+    "arguments": [
+      "g++",
+      "-c",
+      "-I../../Source/Core/Types/Result",
+      "-I../../Source/Core/Types/Vec",
+      "-I../../Source/Components/Interfaces/DebugService",
+      "-I../../Source/Components/Interfaces/TCPLogger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
-      "-I/home/martino/Projects/marte_debug/Source",
-      "-I/home/martino/Projects/marte_debug/Headers",
-      "-pthread",
-      "-g",
       "-fPIC",
-      "-MD",
+      "-Wall",
-      "-MT",
+      "-std=c++98",
-      "CMakeFiles/marte_dev.dir/Source/TcpLogger.cpp.o",
+      "-Werror",
-      "-MF",
+      "-Wno-invalid-offsetof",
-      "CMakeFiles/marte_dev.dir/Source/TcpLogger.cpp.o.d",
+      "-Wno-unused-variable",
-      "-o",
+      "-fno-strict-aliasing",
-      "CMakeFiles/marte_dev.dir/Source/TcpLogger.cpp.o",
+      "-frtti",
-      "-c",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "/home/martino/Projects/marte_debug/Source/TcpLogger.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build",
-    "output": "CMakeFiles/marte_dev.dir/Source/TcpLogger.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Test/UnitTests/main.cpp",
-    "arguments": [
-      "c++",
       "-DARCHITECTURE=x86_gcc",
       "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
       "-DUSE_PTHREAD",
+      "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
+      "-g",
+      "-ggdb",
+      "UnitTests.cpp",
+      "-o",
+      "../../Build/x86-linux/Test/UnitTests/UnitTests/UnitTests.o"
+    ],
+    "directory": "/home/martino/Projects/marte_debug/Test/UnitTests",
+    "output": "../../Build/x86-linux/Test/UnitTests/UnitTests/UnitTests.o"
+  },
+  {
+    "file": "SchedulerTest.cpp",
+    "arguments": [
+      "g++",
+      "-c",
+      "-I../../Source/Core/Types/Result",
+      "-I../../Source/Core/Types/Vec",
+      "-I../../Source/Components/Interfaces/DebugService",
+      "-I../../Source/Components/Interfaces/TCPLogger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
+      "-fPIC",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
+      "-Wall",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
+      "-std=c++98",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
+      "-Werror",
-      "-I/home/martino/Projects/marte_debug/Source",
+      "-Wno-invalid-offsetof",
-      "-I/home/martino/Projects/marte_debug/Headers",
+      "-Wno-unused-variable",
-      "-I/home/martino/Projects/marte_debug/Test/UnitTests/../../Source",
+      "-fno-strict-aliasing",
-      "-I/home/martino/Projects/marte_debug/Test/UnitTests/../../Headers",
+      "-frtti",
-      "-pthread",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "-g",
-      "-MD",
-      "-MT",
-      "Test/UnitTests/CMakeFiles/UnitTests.dir/main.cpp.o",
-      "-MF",
-      "CMakeFiles/UnitTests.dir/main.cpp.o.d",
-      "-o",
-      "CMakeFiles/UnitTests.dir/main.cpp.o",
-      "-c",
-      "/home/martino/Projects/marte_debug/Test/UnitTests/main.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/Test/UnitTests",
-    "output": "CMakeFiles/UnitTests.dir/main.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Test/Integration/main.cpp",
-    "arguments": [
-      "c++",
       "-DARCHITECTURE=x86_gcc",
       "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
       "-DUSE_PTHREAD",
+      "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
+      "-g",
+      "-ggdb",
+      "SchedulerTest.cpp",
+      "-o",
+      "../../Build/x86-linux/Test/Integration/Integration/SchedulerTest.o"
+    ],
+    "directory": "/home/martino/Projects/marte_debug/Test/Integration",
+    "output": "../../Build/x86-linux/Test/Integration/Integration/SchedulerTest.o"
+  },
+  {
+    "file": "TraceTest.cpp",
+    "arguments": [
+      "g++",
+      "-c",
+      "-I../../Source/Core/Types/Result",
+      "-I../../Source/Core/Types/Vec",
+      "-I../../Source/Components/Interfaces/DebugService",
+      "-I../../Source/Components/Interfaces/TCPLogger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
+      "-fPIC",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
+      "-Wall",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
+      "-std=c++98",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
+      "-Werror",
-      "-I/home/martino/Projects/marte_debug/Source",
+      "-Wno-invalid-offsetof",
-      "-I/home/martino/Projects/marte_debug/Headers",
+      "-Wno-unused-variable",
-      "-pthread",
+      "-fno-strict-aliasing",
-      "-g",
+      "-frtti",
-      "-MD",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "-MT",
-      "Test/Integration/CMakeFiles/IntegrationTest.dir/main.cpp.o",
-      "-MF",
-      "CMakeFiles/IntegrationTest.dir/main.cpp.o.d",
-      "-o",
-      "CMakeFiles/IntegrationTest.dir/main.cpp.o",
-      "-c",
-      "/home/martino/Projects/marte_debug/Test/Integration/main.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/Test/Integration",
-    "output": "CMakeFiles/IntegrationTest.dir/main.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Test/Integration/TraceTest.cpp",
-    "arguments": [
-      "c++",
       "-DARCHITECTURE=x86_gcc",
       "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
       "-DUSE_PTHREAD",
+      "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
+      "-g",
+      "-ggdb",
+      "TraceTest.cpp",
+      "-o",
+      "../../Build/x86-linux/Test/Integration/Integration/TraceTest.o"
+    ],
+    "directory": "/home/martino/Projects/marte_debug/Test/Integration",
+    "output": "../../Build/x86-linux/Test/Integration/Integration/TraceTest.o"
+  },
+  {
+    "file": "ValidationTest.cpp",
+    "arguments": [
+      "g++",
+      "-c",
+      "-I../../Source/Core/Types/Result",
+      "-I../../Source/Core/Types/Vec",
+      "-I../../Source/Components/Interfaces/DebugService",
+      "-I../../Source/Components/Interfaces/TCPLogger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
+      "-fPIC",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
+      "-Wall",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
+      "-std=c++98",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
+      "-Werror",
-      "-I/home/martino/Projects/marte_debug/Source",
+      "-Wno-invalid-offsetof",
-      "-I/home/martino/Projects/marte_debug/Headers",
+      "-Wno-unused-variable",
-      "-pthread",
+      "-fno-strict-aliasing",
-      "-g",
+      "-frtti",
-      "-MD",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "-MT",
-      "Test/Integration/CMakeFiles/TraceTest.dir/TraceTest.cpp.o",
-      "-MF",
-      "CMakeFiles/TraceTest.dir/TraceTest.cpp.o.d",
-      "-o",
-      "CMakeFiles/TraceTest.dir/TraceTest.cpp.o",
-      "-c",
-      "/home/martino/Projects/marte_debug/Test/Integration/TraceTest.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/Test/Integration",
-    "output": "CMakeFiles/TraceTest.dir/TraceTest.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Test/Integration/ValidationTest.cpp",
-    "arguments": [
-      "c++",
       "-DARCHITECTURE=x86_gcc",
       "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
       "-DUSE_PTHREAD",
+      "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
+      "-g",
+      "-ggdb",
+      "ValidationTest.cpp",
+      "-o",
+      "../../Build/x86-linux/Test/Integration/Integration/ValidationTest.o"
+    ],
+    "directory": "/home/martino/Projects/marte_debug/Test/Integration",
+    "output": "../../Build/x86-linux/Test/Integration/Integration/ValidationTest.o"
+  },
+  {
+    "file": "ConfigCommandTest.cpp",
+    "arguments": [
+      "g++",
+      "-c",
+      "-I../../Source/Core/Types/Result",
+      "-I../../Source/Core/Types/Vec",
+      "-I../../Source/Components/Interfaces/DebugService",
+      "-I../../Source/Components/Interfaces/TCPLogger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
+      "-fPIC",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
+      "-Wall",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
+      "-std=c++98",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
+      "-Werror",
-      "-I/home/martino/Projects/marte_debug/Source",
+      "-Wno-invalid-offsetof",
-      "-I/home/martino/Projects/marte_debug/Headers",
+      "-Wno-unused-variable",
-      "-pthread",
+      "-fno-strict-aliasing",
-      "-g",
+      "-frtti",
-      "-MD",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
-      "-MT",
-      "Test/Integration/CMakeFiles/ValidationTest.dir/ValidationTest.cpp.o",
-      "-MF",
-      "CMakeFiles/ValidationTest.dir/ValidationTest.cpp.o.d",
-      "-o",
-      "CMakeFiles/ValidationTest.dir/ValidationTest.cpp.o",
-      "-c",
-      "/home/martino/Projects/marte_debug/Test/Integration/ValidationTest.cpp"
-    ],
-    "directory": "/home/martino/Projects/marte_debug/Build/Test/Integration",
-    "output": "CMakeFiles/ValidationTest.dir/ValidationTest.cpp.o"
-  },
-  {
-    "file": "/home/martino/Projects/marte_debug/Test/Integration/SchedulerTest.cpp",
-    "arguments": [
-      "c++",
       "-DARCHITECTURE=x86_gcc",
       "-DENVIRONMENT=Linux",
-      "-DMARTe2_TEST_ENVIRONMENT=GTest",
       "-DUSE_PTHREAD",
+      "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
+      "-g",
+      "-ggdb",
+      "ConfigCommandTest.cpp",
+      "-o",
+      "../../Build/x86-linux/Test/Integration/Integration/ConfigCommandTest.o"
+    ],
+    "directory": "/home/martino/Projects/marte_debug/Test/Integration",
+    "output": "../../Build/x86-linux/Test/Integration/Integration/ConfigCommandTest.o"
+  },
+  {
+    "file": "IntegrationTests.cpp",
+    "arguments": [
+      "g++",
+      "-c",
+      "-I../../Source/Core/Types/Result",
+      "-I../../Source/Core/Types/Vec",
+      "-I../../Source/Components/Interfaces/DebugService",
+      "-I../../Source/Components/Interfaces/TCPLogger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L0Types",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L2Objects",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Events",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Messages",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5FILES",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Logger",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L4Configuration",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/BareMetal/L6App",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L3Services",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4Messages",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L4LoggerService",
+      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L1Portability",
       "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/FileSystem/L3Streams",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2/Source/Core/Scheduler/L5GAMs",
+      "-fPIC",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/EpicsDataSource",
+      "-Wall",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/DataSources/FileDataSource",
+      "-std=c++98",
-      "-I/home/martino/Projects/marte_debug/dependency/MARTe2-components/Source/Components/GAMs/IOGAM",
+      "-Werror",
-      "-I/home/martino/Projects/marte_debug/Source",
+      "-Wno-invalid-offsetof",
-      "-I/home/martino/Projects/marte_debug/Headers",
+      "-Wno-unused-variable",
+      "-fno-strict-aliasing",
+      "-frtti",
+      "-DMARTe2_TEST_ENVIRONMENT=GTest",
+      "-DARCHITECTURE=x86_gcc",
+      "-DENVIRONMENT=Linux",
+      "-DUSE_PTHREAD",
       "-pthread",
+      "-Wno-deprecated-declarations",
+      "-Wno-unused-value",
       "-g",
-      "-MD",
+      "-ggdb",
-      "-MT",
+      "IntegrationTests.cpp",
-      "Test/Integration/CMakeFiles/SchedulerTest.dir/SchedulerTest.cpp.o",
-      "-MF",
-      "CMakeFiles/SchedulerTest.dir/SchedulerTest.cpp.o.d",
       "-o",
-      "CMakeFiles/SchedulerTest.dir/SchedulerTest.cpp.o",
+      "../../Build/x86-linux/Test/Integration/Integration/IntegrationTests.o"
-      "-c",
-      "/home/martino/Projects/marte_debug/Test/Integration/SchedulerTest.cpp"
     ],
-    "directory": "/home/martino/Projects/marte_debug/Build/Test/Integration",
+    "directory": "/home/martino/Projects/marte_debug/Test/Integration",
-    "output": "CMakeFiles/SchedulerTest.dir/SchedulerTest.cpp.o"
+    "output": "../../Build/x86-linux/Test/Integration/Integration/IntegrationTests.o"
   }
 ]

env.fish

@@ -0,0 +1,22 @@
+# Get the directory of this script
+set -l DIR (dirname (realpath (status -f)))
+
+set -gx MARTe2_DIR $DIR/dependency/MARTe2
+set -gx MARTe2_Components_DIR $DIR/dependency/MARTe2-components
+set -gx TARGET x86-linux
+
+# Update LD_LIBRARY_PATH
+if not set -q LD_LIBRARY_PATH
+    set -gx LD_LIBRARY_PATH ""
+end
+
+set -gx LD_LIBRARY_PATH "$LD_LIBRARY_PATH:$MARTe2_DIR/Build/$TARGET/Core"
+set -gx LD_LIBRARY_PATH "$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components"
+set -gx LD_LIBRARY_PATH "$LD_LIBRARY_PATH:$DIR/Build/$TARGET/Components/Interfaces/DebugService"
+set -gx LD_LIBRARY_PATH "$LD_LIBRARY_PATH:$DIR/Build/$TARGET/Components/Interfaces/TCPLogger"
+set -gx LD_LIBRARY_PATH "$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components/DataSources/LinuxTimer"
+set -gx LD_LIBRARY_PATH "$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components/DataSources/LoggerDataSource"
+set -gx LD_LIBRARY_PATH "$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components/GAMs/IOGAM"
+
+echo "MARTe2 Environment Set (MARTe2_DIR=$MARTe2_DIR)"
+echo "MARTe2 Components Environment Set (MARTe2_Components_DIR=$MARTe2_Components_DIR)"

env.sh

@@ -7,5 +7,10 @@ export MARTe2_Components_DIR=$DIR/dependency/MARTe2-components
 export TARGET=x86-linux
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MARTe2_DIR/Build/$TARGET/Core
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$DIR/Build/$TARGET/Components/Interfaces/DebugService
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$DIR/Build/$TARGET/Components/Interfaces/TCPLogger
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components/DataSources/LinuxTimer
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components/DataSources/LoggerDataSource
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MARTe2_Components_DIR/Build/$TARGET/Components/GAMs/IOGAM
 echo "MARTe2 Environment Set (MARTe2_DIR=$MARTe2_DIR)"
 echo "MARTe2 Components Environment Set (MARTe2_Components_DIR=$MARTe2_Components_DIR)"

run_test.sh

@@ -1,14 +1,16 @@
 #!/bin/bash
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
+# Get the directory of this script
-export MARTe2_DIR=/home/martino/Projects/marte_debug/dependency/MARTe2
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-export TARGET=x86-linux
+source $DIR/env.sh
 
 echo "Cleaning up old instances..."
-pkill -9 IntegrationTest
+pkill -9 IntegrationTests
-pkill -9 ValidationTest
+pkill -9 UnitTests
-pkill -9 SchedulerTest
+sleep 1
-pkill -9 main
-sleep 2
 
+echo "Starting MARTe2 Unit Tests..."
+$DIR/Build/$TARGET/Test/UnitTests/UnitTests/UnitTests.ex
+
+echo ""
 echo "Starting MARTe2 Integration Tests..."
-./Build/Test/Integration/ValidationTest
+$DIR/Build/$TARGET/Test/Integration/Integration/IntegrationTests.ex

specs.md

@@ -1,41 +0,0 @@
-Project Specification: MARTe2 Universal Observability & Debugging Suite
-
-Version: 1.1
-
-Date: 2023-10-27
-
-Status: Active / Implemented
-
-1. Executive Summary
-
-This project implements a "Zero-Code-Change" observability and debugging layer for the MARTe2 real-time framework. The system allows developers to Trace, Force, and Monitor any signal in a running MARTe2 application without modifying existing source code.
-
-2. System Architecture
-
-- The Universal Debug Service (C++ Core): A singleton MARTe2 Object that patches the registry and manages communication.
-- The Broker Injection Layer (C++ Templates): Templated wrappers that intercept Copy() calls for tracing, forcing, and execution control.
-- The Remote Analyser (Rust/egui): A high-performance, multi-threaded GUI for visualization and control.
-
-3. Functional Requirements
-
-3.1 Execution Control
-- REQ-25: Execution Control (Pause/Resume): The system SHALL provide a mechanism to pause and resume the execution of all patched real-time threads (via Brokers), allowing for static inspection of the system state.
-
-3.2 Discovery
-- REQ-24: Tree Exploration: The GUI client SHALL request the full application tree upon connection and display it in a hierarchical tree view.
-- TREE Command: Returns a recursive JSON structure representing the entire application tree, including signal metadata (Type, Dimensions, Elements).
-
-3.3 Multi-Threaded Client (REQ-23)
-- Port 8080 (TCP): Commands and Metadata.
-- Port 8082 (TCP): Independent Real-Time Log Stream.
-- Port 8081 (UDP): High-Speed Telemetry for Oscilloscope.
-
-4. Communication Protocol
-
-- LS [Path]: List nodes.
-- TREE: Full recursive JSON application map.
-- PAUSE / RESUME: Execution control.
-- TRACE <Signal> <1/0> [Decimation]: Telemetry control.
-- FORCE <Signal> <Value>: Persistent signal override.
-- UNFORCE <Signal>: Remove override.
-- LOG <Level> <Msg>: Port 8082 streaming format.

test_gui_sim.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+import socket
+import time
+import subprocess
+import os
+import signal
+
+# Start server
+print("Starting server...")
+proc = subprocess.Popen(
+    ["./run_debug_app.sh"],
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+    cwd="/home/martino/Projects/marte_debug",
+    env=os.environ,
+)
+
+time.sleep(5)  # Wait for server to start
+
+print("Connecting to server...")
+s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+s.settimeout(3)
+s.connect(("127.0.0.1", 8080))
+
+# Send TREE
+s.sendall(b"TREE\n")
+print("Sent TREE")
+
+# Send DISCOVER immediately (like GUI does)
+s.sendall(b"DISCOVER\n")
+print("Sent DISCOVER")
+
+# Wait and read
+time.sleep(1)
+data = b""
+while True:
+    try:
+        chunk = s.recv(4096)
+        if not chunk:
+            break
+        data += chunk
+    except:
+        break
+
+print(f"Got {len(data)} bytes")
+print("Contains OK TREE:", b"OK TREE" in data)
+print("Contains OK DISCOVER:", b"OK DISCOVER" in data)
+
+s.close()
+proc.terminate()
+proc.wait()
+print("Done")