docs/armem/how_to_create_a_new_core_segment_or_memory_server/README.md → etc/doxygen/pages/armem/how_to_create_a_new_core_segment_or_memory_server.md

+# How to Create a New Core segment or Memory Server {#memory_system-how_to_create_a_new_core_segment_or_memory_server}
+
+@see
+\ref tutorials_120_memory_server_and_client_cpp
+
+\todo 
+Merge the information from here into \ref tutorials_120_memory_server_and_client_cpp
+
 In order to make a new type of data available in the memory system, you first need to create an ARON XML file. Please refer to [Aron/CodeGeneration](Aron/CodeGeneration) if you want to know how to do so.
 
-[[_TOC_]]
 
 <!--
 # Define your data type in ARON
@@ -390,4 +397,4 @@ When you now start your new memory server and the MemoryNameSystem (MNS) (e.g. u
 
 That's it! You now have a memory server providing a place where your nice and interesting data can feel welcome, and where interested listeners would look to find it.
 
-[Next, we learn how to commit data to the memory, and query data from the memory.](ArMem/How-to-read-from-and-write-to-a-Memory-Server)
\ No newline at end of file
+[Next, we learn how to commit data to the memory, and query data from the memory.](ArMem/How-to-read-from-and-write-to-a-Memory-Server)

etc/doxygen/pages/armem/memory_system.md

+# ArmarX Memory System  {#memory_system}
+
+\tableofcontents
+
+@see
+- \ref tutorials_120_memory_server_and_client_cpp
+- \subpage memory_system-how_to_create_a_new_core_segment_or_memory_server
+
+## Introduction to the Memory System {#memory_system-introduction}
+
+### Distributed Memory 
+
+The ArMem memory system is distributed: It consists of several **memory servers** storing data in a hierarchical
+structure. 
+A memory server can be defined in any ArmarX package and defines which kind of data it stores
+(e.g. robot state, object classes and instances, visual data, speech, ...). 
+As a memory server knows which data it stores, it can provide special behaviour, such as custom visualization, 
+aggregation, interpolation or prediction.
+As each server is a separate component describing its own structure, it is simple to add new memory servers containing
+special data types, which are defined in ArmarX packages further down in the dependency chain.
+
+All memory servers follow the same hierarchical data structure and self-describing data format. 
+The data structure consists of several levels, storing histories/timelines of different entities stored in different 
+segments (see "Memory Levels" below). 
+The common data format is \ref aron, which is a self-describing, hierarchical data format, 
+allowing extensive introspection as well as general storage. 
+Each item in the memory (i.e. entries in all levels) can be identified with a **Memory ID**, which contains the keys
+of each (specified) level. For example, a core segment ID specifies the memory name and core segment name, while an
+entity instance ID specifies the whole path to the leaf of the data structure.
+
+Technically, each memory server is one ArmarX component implementing the `armarx::armem::server::MemoryInterface`
+(comprising a `armarx::armem::server::ReadingMemoryInterface` and a `armarx::armem::server::WritingMemoryInterface`). 
+Memory servers register themselves in the **Memory Name System (MNS)**, where they can be found by their (semantic)
+memory name (which is usually a short, human-readable name such as "Robot", "Object" or "Vision"). 
+Memory servers receive data via **commits** (via the `armarx::armem::server::WritingMemoryInterface`), 
+and return data according to **queries** (via the `armarx::armem::server::ReadingMemoryInterface`). 
+
+
+### Memory Levels
+
+A memory server stores data in a hierarchical structure consisting of several levels:
+```
+- Grasping (Memory)
+  - Grasps (Core Segment)
+    - KnownObjectGraspPlanner (Provider Segment)
+      - my_object (Entity)
+        - t = 2021-03-09 14:24:20.064524 (Entity Snapshot)
+          - 00 (Entity Instance)
+          - 01 (Entity Instance)
+          - 02 (Entity Instance)
+```
+
+| Level                    | Key                                                      | Description                                                                                                                                                                                    | Examples                                                                                          | Implementation                              |
+|--------------------------|----------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------|---------------------------------------------|
+| Memory                   | Name (String)                                            | Semantic grouping of one or more core segments. Corresponds to one memory server.                                                                                                              | Robot, Object, Vision                                                                             | `armarx::armem::wm::Memory`                 |
+| Core Segment             | Name (String)                                            | Building block of a memory containing homogeneous data of a specific (ARON) type. Specifies a _Core Segment Type_ which all provided data must comply to.                                      | (Robot) Proprioception, (Object) Classes, Known (Object) Instances, ImageRGB                      | `armarx::armem::wm::CoreSegment`            |
+| Provider Segment         | Name (String)                                            | Sub-segment of a core segment which contains the data from a single source (e.g. a camera, a method, a component). Can define a _Provider Segment Type_ which extends the _Core Segment Type_. | Primesense, MyObjectLocalizer, MyGraspPlanner                                                     | `armarx::armem::wm::ProviderSegment`        |
+| Entity                   | Name (String)                                            | A single thing or concept whose properties change over time. An entity has a history / timeline, i.e. a sequence of snapshots storing the entity's properties at a specific point in time.     | `image`, `some_object`, `some_object_grasps`                                                      | `armarx::armem::wm::Entity`                 |
+| Entity Snapshot          | Timestamp (`armarx::armem::Time` aka `armarx::DateTime`) | An entry of an entity's history, i.e. the state of an entity at a specific point in time. Can contain multiple (entitiy) instances.                                                            | Image, object instance, grasp hypotheses at a time *t*                                            | `armarx::armem::wm::EntitySnapshot`         |
+| Entity Instance          | Index (int)                                              | One instance of the segment's ARON type.                                                                                                                                                       | left/right stereo image (at time t), object (at time t), grasp hypothesis (one of many at time t) | `armarx::armem::wm::EntityInstance`         | 
+| Entity Instance Metadata | --                                                       | Metadata stored alongside the instance's data.                                                                                                                                                 | Further timesteps, confidence                                                                     | `armarx::armem::wm::EntityInstanceMetadata` |
+
+
+## Existing Memory Servers and Segments  {#memory_system-existing_servers_segments}
+
+This is a list of existing memory servers, their core segments and their \ref ARON "ARON" data types.
+
+
+### RobotState  {#memory_system-robot_state}
+
+* Memory Server: [`RobotStateMemory` (RobotAPI)](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/tree/master/source/RobotAPI/components/armem/server/RobotStateMemory)
+* Core Segments:
+
+| Core Segment Name                                  | Type                                                                                                                                                | Description                                                                     | Example Entities                             |
+|----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------|----------------------------------------------|
+| Description                                        | [RobotDescription](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/libraries/armem_robot/aron/RobotDescription.xml)   | Robot description (e.g. link to XML or URDF file)                               | Description of ARMAR-6                       |
+| Proprioception                                     | [Proprioception](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/libraries/armem_robot_state/aron/Proprioception.xml) | Robot configuration and internal sensor values.                                 | Proprioception of ARMAR-6                    |
+| \subpage memory_system-localization "Localization" | [Transform](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/libraries/armem_robot_localization/aron/Transform.xml)    | Transformations between frames {world,map,robot} to retrieve global robot pose. | Transfrom from robot root frame to map frame |
+
+Missing:
+- Robot calibration: should be part of `Description` core segment
+
+
+### Object
+
+* Memory Server: [`ObjectMemory` (RobotAPI)](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/components/armem/server/ObjectMemory)
+* Core Segments:
+
+| Core Segment Name        | Type                                                                                                                                                                          | Description                                                                              | Example Entities                                    |
+|--------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|-----------------------------------------------------|
+| Class                    | [ObjectClass](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/libraries/armem_objects/aron/ObjectClass.xml)                                     | Static description of a known object class. Entity names are (ArmarXObjects) object IDs. | `KIT/CoffeeFilters`, `YCB/001_chips_can`            |
+| Instance                 | [ObjectInstance](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/libraries/armem_objects/aron/ObjectInstance.xml)                               | Localized object instance. Entity names are (ArmarXObjects) object IDs.                  | `KIT/CoffeeFilters`, `YCB/001_chips_can/instance_1` |
+| Attachments             | [ObjectAttachment and ArticulatedObjectAttachment](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/libraries/armem_objects/aron/Attachment.xml) |                                                                                          |                                                     |
+
+
+### Vision
+
+* Memory Server: [`ArMemVisionMemory` (VisionX)](https://git.h2t.iar.kit.edu/sw/armarx/visionx/-/tree/master/source/VisionX/components/armem/ArMemVisionMemory)
+* Core Segments:
+
+| Core Segment Name | Type                                                                                                                           | Description                               | Example Entities |
+|-------------------|--------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------|------------------|
+| ImageRGB          | [`ImageRGB`](https://git.h2t.iar.kit.edu/sw/armarx/visionx/-/blob/master/source/VisionX/libraries/ArMem/aron/ImageRGB.xml)     | RGB images (mono and stereo) of a camera  | image            |
+| ImageDepth        | [`ImageDepth`](https://git.h2t.iar.kit.edu/sw/armarx/visionx/-/blob/master/source/VisionX/libraries/ArMem/aron/ImageDepth.xml) | Depth images of an RGB-D or stereo camera | image            |
+
+
+### Speech
+
+* Memory Server: [`SpeechMemory` (SpeechX)](https://git.h2t.iar.kit.edu/sw/armarx/speechx/-/tree/master/source/SpeechX/components/SpeechMemory)
+* Core Segments:
+
+| Core Segment Name     | Type            | Description                                                               | Example Entities |
+|-----------------------|-----------------|---------------------------------------------------------------------------|------------------|
+| Command               | `SpeechCommand` | Language commands from speech (topic `Speech_Commands`).                  | `command`        | 
+| TextListenerInterface | `Text`          | Data from `TextListenerInterface` topics. (`TextToSpeech`, `RobotAction`) | `text`           | 
+
+... 
+
+
+### Skills
+
+* Memory Server: [`SkillsMemory` (RobotAPI)](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/tree/master/source/RobotAPI/components/armem/server/SkillsMemory)
+* Core Segments:
+
+| Core Segment Name | Type         | Description                         | Example Entities |
+|-------------------|--------------|-------------------------------------|------------------|
+| Statechart        | `Transition` | Transitions in ArmarX state charts. | tbd              | 
+
+
+### Example
+
+An example memory server (alongside a matching client) showing how to implement a standard memory server and test the framework during development.
+
+* Memory Server: [`ExampleMemory` (RobotAPI)](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/tree/master/source/RobotAPI/components/armem/server/ExampleMemory)
+* Core Segments:
+
+| Core Segment Name | Type                                                                                                                                                    | Description        | Example Entities |
+|-------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|------------------|
+| ExampleData       | [ExampleData](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/blob/master/source/RobotAPI/components/armem/server/ExampleMemory/aron/ExampleData.xml) | Some example data. | example          |
+
+
+### GeneralPurpose
+
+This memory is meant to allow for a quick-and-dirty integration of your data type in the memory framework. When your development finishes a stable state, consider creating moving the core segment(s) to an existing memory server or creating a new dedicated memory server.
+
+* Memory Server: [`GeneralPurposeMemory` (RobotAPI)](https://git.h2t.iar.kit.edu/sw/armarx/robot-api/-/tree/master/source/RobotAPI/components/armem/server/GeneralPurposeMemory)
+* Core Segments:
+
+| Core Segment Name                      | Type | Description | Example Entities |
+|----------------------------------------|------|-------------|------------------|
+| None. You can add segments on the fly. |      |             |                  |

etc/doxygen/pages/aron/aron.md

+# ArmarX Object Notation (ARON) / Interpretable Data Format (IDF)  {#aron}
+
+\tableofcontents
+
+\see
+- \subpage aron-code_generation
+- \subpage aron-visitors
+- \subpage aron-conversion
+
+
+ARON (ArmarX Object Notation) is the ArmarX implementation of variants which can be transferred over the network via 
+ZeroC Ice. 
+Further, ARON is the data representation used in the \ref memory_system.
+We distinguish between:
+
+- type specification vs. data information
+- data transfer object (in the following called "ARON DTO") vs. its corresponding C++ wrapper 
+  (in the following called "ARON object"). 
+  The DTO specification is done in ice so that every ARON object can be transferred via ice.
+
+
+## ARON Type specification
+
+An ARON type specification defines the static type for an ARON data DTO or an ARON data object. It does not contain any
+data (e.g. an ARON type list only knows the accepted type, not the list members). 
+Since ARON supports maybe types (raw ptr, smart ptr, optional), every ARON type DTO contains a special member. 
+It can only consist of the following types and information (ARONVariant means any Type):
+
+```cpp
+Object { // dto called armarx::aron::type::dto::AronObject
+    string name;
+    AronVariant extends;
+    map<string, AronVariant> memberTypes;
+}
+Dict { // dto called armarx::aron::type::dto::Dict
+    AronVariant acceptedType;
+}
+List { // dto called armarx::aron::type::dto::List
+     AronVariant acceptedType;
+}
+Pair { // ...
+     AronVariant acceptedType1;
+     AronVariant acceptedType2;
+}
+Tuple {
+     vector<AronVariant> acceptedTypes;
+}
+IntEnum {
+     string name;
+     map<string, int> acceptedValues;
+}
+NDArray {
+     int ndim;
+     type type; // in [uint8, int8, uint16, int16, uint32, int32, float32, float64]
+}
+Matrix {
+     int rows, cols;
+     type type; // in [int16, int32, int64, float32, float64]
+}
+Quaternion {
+     type type; // in [float32, float64]
+} 
+Position {
+}
+Orientation {
+} 
+Pose {
+} 
+Image {
+    pixelType type; // in [rgb24, depth32]
+}     
+PointCloud {
+    voxelType type; // in [PointXYZ, PointXYZI, PointXYZL, PointXYZRGB, PointXYZRGBA, PointXYZRGBL, PointXYZHSV]
+}
+Int { // dto called armarx::aron::type::dto::AronInt
+}
+Long { // dto called armarx::aron::type::dto::AronLong
+}
+Float { // dto called armarx::aron::type::dto::AronFloat
+}
+Double { // dto called armarx::aron::type::dto::AronDouble
+}
+String { // dto called armarx::aron::type::dto::AronString
+}
+Bool { // dto called armarx::aron::type::dto::AronBool
+}
+Time { // dto called armarx::aron::type::dto::AronTime
+}
+```
+
+## ARON Data specification
+
+ARON data objects and ARON data DTOs are similar structured to type objects and type DTOs. 
+However, there are fewer classes for data objects and data DTOs. 
+ARON data is completely decoupled from the static types and contains the data members 
+(e.g. an aron data list only contains the list members (as ARONVariants) and not the accepted type):
+
+```cpp
+Dict { // dto called armarx::aron::data::dto::Dict
+    map<string, AronVariant> members;
+}
+List { // dto called armarx::aron::data::dto::List
+     vector<AronVariant> elements;
+}
+NDArray { // ...
+     vector<int> shape;
+     string type;
+     vector<byte> data;
+}
+Int { // dto called armarx::aron::data::dto::AronInt
+     int value;
+}
+Long { // dto called armarx::aron::data::dto::AronLong
+     long value;
+}
+Float { // dto called armarx::aron::data::dto::AronFloat
+     float value;
+}
+Double { // dto called armarx::aron::data::dto::AronDouble
+     double value;
+}
+String { // dto called armarx::aron::data::dto::AronString
+     string value;
+}
+Bool { // dto called armarx::aron::data::dto::AronBool
+     bool value;
+}
+```
+
+\note
+Note that every ARON data object or DTO can be `nullptr`!
+The reason is that if the type supports maybe types and a member is, for example, optional, 
+the data must support maybetype as well. 
+If a generated ARON class (We come to the code generation later) has an optional member, 
+this member will be translated into a NULL ARON object and DTO. 
+
+
+## Connection of ARON data and ARON type
+
+ARON data contains fewer classes than ARON type.
+Because ARON data objects and DTOs do not check the type of the members (they can be any aron data (ARONVariant)),
+we can only validate an aron data object or DTO if we have the type information. The following mapping describes, 
+how data and types correspond.
+
+| ARON Type   | ARON Data |
+|-------------|-----------|
+| Object      | Dict      |
+| Dict        | Dict      |
+| List        | List      |
+| Pair        | List      |
+| Tuple       | List      |
+| NDArray     | NDArray   |
+| Matrix      | NDArray   |
+| Quaternion  | NDArray   |
+| Position    | NDArray   |
+| Orientation | NDArray   |
+| Pose        | NDArray   |
+| Image       | NDArray   |
+| PointCloud  | NDArray   |
+| IntEnum     | Int       |
+| Int         | Int       |
+| Long        | Long      |
+| Float       | Float     |
+| Double      | Double    |
+| String      | String    |
+| Bool        | Bool      |
+| Time        | Long      |
+
+
+If no type object or DTO is available, we can at least derive some information from the data object 
+(e.g. "it is a data dict, so the type cant be list").
+
+To differ between data and type makes it easier to work with these Variants. 
+In most cases, the type information is not relevant.
+Then you only have to check for the data type.
+
+
+## ARON Data and Type Objects
+
+As already mentioned, we implemented wrapper classes around the DTO. 
+These classes offer convenience methods and conversions and make lots things easier when working directly with ARON.
+These classes can be found at `aron/core/{data,type}/variant/Variant.h`.
+
+The ARON objects have more or less the same structure as the DTOs (see above).
+Everything is stored as a `std::shared_ptr` (e.g. members, elements, acceptedTypes, ...). 
+If you want to implement a method which takes any ARON data object as input, 
+you can use the base class of every ARON data object: 
+```cpp
+void myFancyMethod(const armarx::aron::data::VariantPtr& variant);
+```
+
+If you want to check, what a variant really is, you can use the descriptor of the object:
+```cpp
+armarx::aron::data::VariantPtr variant;  // <-- the variant
+auto desc = variant->getDescriptor();
+switch(desc)
+{
+    case armarx::aron::data::Descriptor::eDict: ...
+    case armarx::aron::data::Descriptor::eList: ...
+    ...
+}
+```
+
+If you have a DTO, you do not know the exact type,
+but you want to have a ARON object you can make use of the static construction methods:
+```cpp
+armarx::aron::data::dto::GenericData dto; // <-- the DTO variant
+auto aron = armarx::aron::data::Variant::FromAronDTO(dto);
+```
+
+If you know the type, you can use the constructor the specific ARON object.
+
+### Example to Create an ARON Data Dict from Scratch
+
+Goal: Have an ARON dict with a list as member "the_list" and some values in it. 
+Then echo the members and their descriptor as a string.
+
+```cpp
+using namespace armarx;
+
+// setup aron object
+auto dict = std::make_shared<aron::data::Dict>();
+{
+    auto list = std::make_shared<aron::data::List>();
+    for (unsigned int i = 0; i < 10; ++i)
+    {
+        list->addElement(std::make_shared<aron::data::Int>(i));
+    }
+    dict->addElement("the_list", list);
+}
+
+// echo
+auto listVariant = dict->getElement("the_list"); // will return a aron::data::VariantPtr
+auto list = aron::data::List::DynamicCastAndCheck(listVariant); // cast and check whether the cast was successful
+for (const auto& intVar : list->getElements())
+{
+    auto i = aron::data::Int::DynamicCastAndCheck(intVar);
+    std::cout << "The value is: " << i->getValue() << std::endl;
+    std::cout << "The descriptor is: " << aron::data::defaultconversion::string::Descriptor2String.at(i->getDescriptor()) << std::endl;
+}
+```
+
+Please note that we might add more methods or make the current ones more flexible (e.g. such as nlohmann::json).
+
+## Lessons Learned
+
+- There is a difference between ARON data and ARON type
+- There is a difference between ARON objects and ARON DTOs
+- How are ARON DTOs structured
+- How do ARON data and ARON types correspond
+- How to use the ARON objects

docs/aron/code_generation/README.md → etc/doxygen/pages/aron/code_generation.md

-[[_TOC_]]
+# ARON Code Generation  {#aron-code_generation}
 
-# Aron Type Reading
+\tableofcontents
 
-As already mention in the introduction, aron supports code generation in order to create a c++ (other languages also possible) class with plain c++ members which you can use for convenience. Further, the generated class offers methods to convert itself to a Aron object and to set the members from a Aron object. Code generation only makes sense for Aron data, however we need an Aron type specification in order to generate the class.
+## Aron Type Reading
+
+As already mention in the introduction, aron supports code generation in order to create a C++ 
+(other languages also possible) class with plain C++ members which you can use for convenience. 
+Further, the generated class offers methods to convert itself to an Aron object and to set the members from an Aron
+object.
+Code generation only makes sense for Aron data,
+however we need an Aron type specification in order to generate the class.
  
 In the following we will describe how to specify Aron types in XML and how the generated code looks like.
 
 
-## XML type description and creation
+### XML type description and creation
 
-In order to make Aron generate a c++ class for you, you first have to tell the program how the object should look like. Second you need to add the file to cmake in order to create the code generation target. 
+In order to make Aron generate a C++ class for you, you first have to tell the program how the object should look like.
+Second you need to add the file to cmake in order to create the code generation target. 
 
-### XML type description
+#### XML type description
 
 Consider you want to use a data type called `MyData` (in the namespace `armarx::mydata`).
-* Choose a library in an ArmarX package where your data type will be defined (or create a new one). Here, we will call it `MyDataLib`.
-* In the directory `MyDataLib/`, create a directory `aron/` (if necessary). Inside, add a file `MyData.xml`. The directory structure should now look like this:
+* Choose a library in an ArmarX package where your data type will be defined (or create a new one).
+  Here, we will call it `MyDataLib`.
+* In the directory `MyDataLib/`, create a directory `aron/` (if necessary). Inside, add a file `MyData.xml`. 
+  The directory structure should now look like this:
 
 ```
 .../libraries/
@@ -45,7 +55,13 @@ Then start defining your data in ARON. A hello world example could look like thi
 </AronTypeDefinition>
 ```
 
-Every type specification must have the top-level-tag `AronTypeDefinition` and must at least define one type in `GenerateTypes`. In the `GenerateTypes`-tag you can add as many `Object` or `IntEnum` definitions as you want. `<Object>` defines a new ARON object type (generating a C++ class) containing a number of children. Inside the `Object`-tag you can add as many members as you want through the `ObjectChild`-tag (generating a public member variable of the generated C++ class, with `key` specifying the member's name). If a member should be e.g. optional you have to add the attribute `optional="true"` to the member:
+Every type specification must have the top-level tag `AronTypeDefinition` 
+and must at least define one type in `GenerateTypes`.
+In the `GenerateTypes` tag you can add as many `Object` or `IntEnum` definitions as you want. 
+`<Object>` defines a new ARON object type (generating a C++ class) containing a number of children. 
+Inside the `Object`-tag you can add as many members as you want through the `ObjectChild`-tag 
+(generating a public member variable of the generated C++ class, with `key` specifying the member's name). 
+If a member should be e.g. optional you have to add the attribute `optional="true"` to the member:
 ```xml
     <ObjectChild key="helloWorld">
         <String optional="true" />
@@ -54,34 +70,29 @@ Every type specification must have the top-level-tag `AronTypeDefinition` and mu
 The same way you can define `raw_ptr`, `shared_ptr` or `unique_ptr` members.
 
 Conventions:
-- Put your ARON object type into a `arondto::` namespace inside your usual namespace (e.g., `armarx::mydata::arondto::MyData`), where "DTO" stands for "Data Transfer Object". This way, you can define or use a custom or existing C++ type with more methods/intelligence in the usual namespace in your business logic code (e.g. `armarx::mydata::MyData`).
+- Put your ARON object type into a `arondto::` namespace inside your usual namespace 
+  (e.g., `armarx::mydata::arondto::MyData`), where "DTO" stands for "Data Transfer Object".
+  This way, you can define or use a custom or existing C++ type with more methods/intelligence in the usual namespace  
+  in your business logic code (e.g. `armarx::mydata::MyData`).
 
-If you want to use a definition of another Aron file, you can include the file using the `AronIncludes`-section. Simply add the files you want to include using a `include`-tag:
+If you want to use a definition of another Aron file, you can include the file using the `AronIncludes` section.
+Simply add the files you want to include using a `include` tag:
 ```xml
-    <AronIncludes>
-        <Include include="<RobotAPI/libraries/aron/common/aron/PackagePath.xml>" autoinclude="true" />
-        ... 
-    </AronIncludes>
+<AronIncludes>
+    <Include include="RobotAPI/libraries/aron/common/aron/PackagePath.xml" />
+    ... 
+</AronIncludes>
 ```
-The option `autoinclude` automatically adds the generated class of the Aron xml file to the c++ class.
 
 After that, you can use the type definitions in your current xml file (you must specify the full namespace):
 ```xml
-    <ObjectChild key="referenceToMemoryID">
-        <armarx::arondto::PackagePath />
-    </ObjectChild>
+<ObjectChild key="referenceToMemoryID">
+    <armarx::arondto::PackagePath />
+</ObjectChild>
 ```
 
-(At the moment), you need to specify `<CodeIncludes>` to Eigen to use `Pose`, `Position` and `Orientation` (which are translated to `Eigen::Matrix4f`, `Eigen::Vector3f`, and `Eigen::Quaternionf` in C++). In that section, you can add includes in your target language (right now only C++), e.g.:
-```xml
-    <CodeIncludes>
-        <Include include="<Eigen/Core>" />
-    </CodeIncludes>
-```
-
-If you do not need the `CodeIncludes` and `AronIncludes` you can remove these tags.
 
-### Examples
+#### Examples
 
 In the following we define a class that uses all more complex types once:
 ```xml
@@ -158,9 +169,10 @@ In the following we define a class that uses all more complex types once:
 </AronTypeDefinition>
 ```
 
-### CMake specification
+#### CMake Specification
 
-In the `CMakeLists.txt`, add or extend after the definition of the target (e.g. through add_library or add_component):
+In the `CMakeLists.txt`, add or extend after the definition of the target 
+(e.g. through `add_library` or `add_component`):
 
 ```cmake
 armarx_enable_aron_file_generation_for_target(
@@ -171,9 +183,10 @@ armarx_enable_aron_file_generation_for_target(
 )
 ```
 
-### Important changes
+#### Important changes
 
-- I changed the xml type reader so that embedded classes are not allowed anymore! Before that you were able to define a new class inside an existing one, e.g.:
+- I changed the xml type reader so that embedded classes are not allowed anymore! 
+  Before that you were able to define a new class inside an existing one, e.g.:
 ```xml
 <!-- MyData containing a helloWorld member -->
 <?xml version="1.0" encoding="UTF-8" ?>
@@ -191,7 +204,8 @@ armarx_enable_aron_file_generation_for_target(
 ```
 This is not supported anymore!
 
-## Full example
+
+### Full example
 
 Say you have the following Aron XML type description:
 ```xml
@@ -223,7 +237,7 @@ Say you have the following Aron XML type description:
 </AronTypeDefinition>
 ```
 
-The generated c++ file looks like:
+The generated C++ file looks like:
 ```cpp
 #pragma once
 
@@ -651,29 +665,45 @@ namespace armarx
 
 ```
 
-As you see, the code generation creates a class for the `NaturalIKControlMode` enum. This special class provides convenience methods compared to normal c++ enums.
+As you see, the code generation creates a class for the `NaturalIKControlMode` enum. 
+This special class provides convenience methods compared to normal C++ enums.
 Further, it creates a class for the `NaturalIKResult` object. 
 
-Both, the enum and the object provide methods for reading and writing. The `read` method is used to parse a Aron object in an arbitrary representation (e.g. Aron variant or nlohmann::json) and to set the c++ members to the same values as the Aron object. To do so it uses a ReaderInterface implementation (See [Converter](Aron/Converter)). The `write` method is used to create an Aron object in an arbitrary representation with the same values as the c++ object. This method uses a WriterInterface implementation.
-
-For convenience, the `toAron()` and `fromAron()` methods, which internally use the `read` and `write` methods, are created. To get the structure of the c++ class as an Aron type object you can use the static `toAronType()` method which internally uses the `writeType` method.
+Both, the enum and the object provide methods for reading and writing.
+The `read` method is used to parse a Aron object in an arbitrary representation
+(e.g. Aron variant or nlohmann::json) and to set the C++ members to the same values as the Aron object.
+To do so it uses a ReaderInterface implementation (see \ref aron-conversion). 
+The `write` method is used to create an Aron object in an arbitrary representation with the same values as the C++ 
+object.
+This method uses a WriterInterface implementation.
 
-Futher, the code generation creates methods to compare two classes with each other (right now only operator==).
+For convenience, the `toAron()` and `fromAron()` methods, which internally use the `read` and `write` methods, 
+are created. 
+To get the structure of the C++ class as an Aron type object you can use the static `toAronType()` method which
+internally uses the `writeType` method.
 
-This means, when using Aron, you don't need to mess around with the Aron DTOs and Aron objects, you only have to set and use plain c++ members of a generated class!
+Further, the code generation creates methods to compare two classes with each other (right now only operator==).
 
+This means, when using Aron, you don't need to mess around with the Aron DTOs and Aron objects, you only have to set
+and use plain C++ members of a generated class!
 
 
+## (Optional) Add conversions to existing (potentially more intelligent) C++ types
 
-# (Optional) Add conversions to existing (potentially more intelligent) C++ types
+Consider the case of `simox::OrientedBoxf` and `simox::arondto::OrientedBox`. The former is the business object (BO), 
+used in daily business logic code (as it offers useful methods to construct and manipulate it). 
+The latter is a mere data storage used to transfer the data, which is called a data transfer object (DTO).
 
-Consider the case of `simox::OrientedBoxf` and `simox::arondto::OrientedBox`. The former is the business object (BO), used in daily business logic code (as it offers useful methods to construct and manipulate it). The latter is a mere data storage used to transfer the data, which is called a data transfer object (DTO).
-
-Therefore, you usually want to convert a `simox::arondto::OrientedBox` to a `simox::OrientedBoxf` as soon as you want to do things other than passing it around over network (e.g., at the beginning of a component method or after reading it from the working memory). Likewise, you want to convert a `simox::OrientedBoxf` to a `simox::arondto::OrientedBox` when you send the information over network or store it in the memory.
+Therefore, you usually want to convert a `simox::arondto::OrientedBox` to a `simox::OrientedBoxf` as soon as you want
+to do things other than passing it around over network (e.g., at the beginning of a component method or after reading 
+it from the working memory).
+Likewise, you want to convert a `simox::OrientedBoxf` to a `simox::arondto::OrientedBox` when you send the information 
+over network or store it in the memory.
 
 To allow this conversion, follow these steps:
 
-- In your library, add a file pair `aron_conversions.{h, cpp}` next to your `aron/` directory and add them to the `CMakeLists.txt`
+- In your library, add a file pair `aron_conversions.{h, cpp}` next to your `aron/` directory and add them to 
+  the `CMakeLists.txt`
 - In the header, declare functions following this form:
 
 ```cpp
@@ -723,11 +753,14 @@ void simox::toAron(arondto::OrientedBox& dto, const OrientedBoxf& bo)
 }
 ```
 
-Note:
+\note
+The implementation depends on your data. 
+It might be as simple as copying all members, or require more complex conversions. 
+Especially, you might use `fromAron()` for `toAron()` for other ARON object types.
+
 
-- The implementation depends on your data. It might be as simple as copying all members, or require more complex conversions. Especially, you might use `fromAron()` for `toAron()` for other ARON object types.
+## Lessons learned
 
-# Lessons learned
 - How to create a XML file with a valid Aron specification
 - How to add this file to CMake
-- How to use the generated class and how to convert it to an Aron object (e.g. for sending it to the memory)
\ No newline at end of file
+- How to use the generated class and how to convert it to an Aron object (e.g. for sending it to the memory)

etc/doxygen/pages/aron/conversion.md

+# ARON Readers, Writers and Conversion  {#aron-conversion}
+
+\ref aron "ARON" offers ways to simply convert any aron object into another representation 
+(e.g. from variant to `nlohmann::json` or vice versa).
+To do so, it makes use of specific readers and writers. 
+In the following we will only describe the readers, writers and converters for ARON data,
+not for types (but the principle is the same).
+
+
+## Readers
+
+An ARON reader is used to get information of an ARON object in a specific representation. 
+Assume you have an `nlohmann::json` aron object which contains some information 
+(for example, it is a dict, containing some members, ...). 
+We need this information to create another object in another representation with the same content.
+
+To do so, you only have to implement the `armarx::aron::data::ReaderInterface` class.
+It needs one template parameter for your InputType (e.g. here const `nlohmann::json`).
+
+The interface provides the following pure virtual methods:
+```cpp
+virtual void readList(InputType& input, std::vector<InputTypeNonConst>& elements) = 0;
+virtual void readDict(InputType& input, std::map<std::string, InputTypeNonConst>& elements) = 0;
+virtual void readNDArray(InputType& input, std::vector<int>& shape, std::string& typeAsString, std::vector<unsigned char>& data) = 0;
+virtual void readInt(InputType& input, int& i) = 0;
+virtual void readLong(InputType& input, long& i) = 0;
+virtual void readFloat(InputType& input, float& i) = 0;
+virtual void readDouble(InputType& input, double& i) = 0;
+virtual void readString(InputType& input, std::string& s) = 0;
+virtual void readBool(InputType& input, bool& i) = 0;
+```
+
+You have to implement the function so that the non-const arguments of the method will be filled with the values of the
+input. 
+For example, the implementation of the readString method for the `nlohmann::json` reader would be:
+```cpp
+void NlohmannJSONReader::readString(const nlohmann::json& input, std::string& i)
+{
+    if (input[rw::json::constantes::TYPE_SLUG] != expectedType)
+    {
+        throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Wrong type in json encountered.", input[rw::json::constantes::TYPE_SLUG], expectedType);
+    }
+    i = input[rw::json::constantes::VALUE_SLUG];
+}
+```
+
+Of course, the way to get the member depend on the way how to construct (writer) the `nlohmann::json`.

etc/doxygen/pages/aron/visitors.md

+# ARON Visitors  {#aron-visitors}
+
+\tableofcontents
+
+Visitors are a useful tool to define specific methods for specific types 
+without specifying the `switch(): case: ...` again and again.
+Further, recursive visitors offer a convenient way to iterate through the tree-like structure of any Aron object. 
+(Please note that right now the implementation does not check for cycles!). 
+Again, we will only look at data visitors since the implementation of type visitors is more or less similar.
+
+
+## Non-recursive Visitors
+
+First, there are "normal" visitors. 
+They are used to get rid of the big switch-case statement when getting an Aron object with unknown type.
+Further, these visitors can be used to convert an Aron object from one representation into another (see \ref aron-conversion). 
+The `armarx::aron::data::Visitor` base class offers the following pure virtual methods which you have to implement:
+
+```cpp
+virtual data::Descriptor getDescriptor(Input&) = 0;
+virtual void visitDict(Input&) {};
+virtual void visitList(Input&) {};
+virtual void visitNDArray(Input&) {};
+virtual void visitInt(Input&) {};
+virtual void visitLong(Input&) {};
+virtual void visitFloat(Input&) {};
+virtual void visitDouble(Input&) {};
+virtual void visitBool(Input&) {};
+virtual void visitString(Input&) {};
+virtual void visitUnknown(Input&) { throw error::AronException(__PRETTY_FUNCTION__, "Unknown type in visitor."); }
+```
+
+`Input` is a template parameter, defining the Input-type 
+(e.g. `const armarx::aron::data::VariantPtr` for a `VariantVisitor` Implementation).
+
+The method `getDescriptor(Input&)` is used for the switch case internally.
+
+As you can see the `VariantVisitor` always gets a generic variant as input in each function.
+This means that, although the Visitor guarantees that the input is correct, you have to cast the class to the correct
+type.
+For widely used Visitors, the Aron library offers convenience implementations 
+(e.g. for Variants and for nlohmann::json inputs). 
+The convenience class for Variants additionally adds overloads where the input is already cast correctly 
+(you can decide which method you want to override).
+
+To use a Visitor, you have to use the function 
+```cpp
+void visit(VisitorImplementation& v, typename VisitorImplementation::Input& o);
+```
+which takes the visitor and the input as arguments and does the switch-case.
+
+
+## Recursive Visitors
+
+Recursive visitors are similar to normal visitors, but they continue "visiting" until the object is fully visited.
+For containers (e.g. dicts, lists) they offer two methods each:
+```cpp
+virtual void visitDictOnEnter(Input& element) {};
+virtual void visitDictOnExit(Input& element) {};
+virtual void visitListOnEnter(Input& element) {};
+virtual void visitListOnExit(Input& element) {};
+```
+The `*OnEnter` method is called before iterating over all children of the container. 
+The `*OnExit` is called after the iteration.
+
+Further, in order to get the elements of a container, you must implement the methods:
+```cpp
+virtual MapElements getDictElements(Input&) = 0;
+virtual ListElements getListElements(Input&) = 0;
+```
+Again, Input can be any aron object (e.g. Variant or nlohmann::json).
+
+As for normal visitors, the Aron library offers convenience implementations for Variants and nlohmann::json inputs.
+
+To use the RecursiveVisitor, you have to use the function 
+```cpp
+void visitRecursive(RecursiveVisitorImplementation& v, typename RecursiveVisitorImplementation::Input& o);
+```
+
+### Example 
+
+Assume you want to count how many objects of each kind you have in a Variant.
+```cpp
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
+class CountingRecursiveVisitor : public RecursiveConstVariantVisitor
+{
+public:
+    int dicts = 0;
+    int lists = 0;
+    int ndarrays = 0;
+    int ints = 0;
+    int floats = 0;
+    int longs = 0;
+    int doubles = 0;
+    int strings = 0;
+    int bools = 0;
+public:
+    void visitAronVariantOnEnter(const data::DictPtr&) override { dicts++; }
+    void visitAronVariantOnEnter(const data::ListPtr&) override { lists++; }
+    void visitAronVariant(const data::NDArrayPtr&) override     { ndarrays++; }
+    void visitAronVariant(const data::IntPtr&) override         { ints++; }
+    void visitAronVariant(const data::LongPtr&) override        { longs++; }
+    void visitAronVariant(const data::FloatPtr&) override       { floats++; }
+    void visitAronVariant(const data::DoublePtr&) override      { doubles++; }
+    void visitAronVariant(const data::BoolPtr&) override        { strings++; }
+    void visitAronVariant(const data::StringPtr&) override      { bools++; }
+};
+
+void countHowMany(const aron::data::VariantPtr& aron)
+{
+    CountingRecursiveVisitor visitor;
+    aron::data::visitRecursive(visitor, aron);
+
+    std::cout << "The aron has " << visitor.dicts << " dicts." << std::endl;
+}
+```
+
+## Typed Visitors
+
+# Lessons Learned

scenarios/RobotHealthTest/config/RobotHealthApp.cfg

@@ -18,6 +18,15 @@
 # ArmarX.ApplicationName = ""
 
 
+# ArmarX.AutodiscoverPackages:  If enabled, will discover all ArmarX packages based on the environment variables. Otherwise, the `DefaultPackages` and `AdditionalPackages` properties are used.
+#  Attributes:
+#  - Default:            true
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.AutodiscoverPackages = true
+
+
 # ArmarX.CachePath:  Path for cache files. If relative path AND env. variable ARMARX_CONFIG_DIR is set, the cache path will be made relative to ARMARX_CONFIG_DIR. Otherwise if relative it will be relative to the default ArmarX config dir (${ARMARX_WORKSPACE}/armarx_config)
 #  Attributes:
 #  - Default:            mongo/.cache

scenarios/RobotHealthTest/config/RobotHealthDummyApp.HealthDummy1.cfg

@@ -18,6 +18,15 @@
 # ArmarX.ApplicationName = ""
 
 
+# ArmarX.AutodiscoverPackages:  If enabled, will discover all ArmarX packages based on the environment variables. Otherwise, the `DefaultPackages` and `AdditionalPackages` properties are used.
+#  Attributes:
+#  - Default:            true
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.AutodiscoverPackages = true
+
+
 # ArmarX.CachePath:  Path for cache files. If relative path AND env. variable ARMARX_CONFIG_DIR is set, the cache path will be made relative to ARMARX_CONFIG_DIR. Otherwise if relative it will be relative to the default ArmarX config dir (${ARMARX_WORKSPACE}/armarx_config)
 #  Attributes:
 #  - Default:            mongo/.cache

scenarios/RobotHealthTest/config/RobotHealthDummyApp.HealthDummy2.cfg

@@ -18,6 +18,15 @@
 # ArmarX.ApplicationName = ""
 
 
+# ArmarX.AutodiscoverPackages:  If enabled, will discover all ArmarX packages based on the environment variables. Otherwise, the `DefaultPackages` and `AdditionalPackages` properties are used.
+#  Attributes:
+#  - Default:            true
+#  - Case sensitivity:   yes
+#  - Required:           no
+#  - Possible values: {0, 1, false, no, true, yes}
+# ArmarX.AutodiscoverPackages = true
+
+
 # ArmarX.CachePath:  Path for cache files. If relative path AND env. variable ARMARX_CONFIG_DIR is set, the cache path will be made relative to ARMARX_CONFIG_DIR. Otherwise if relative it will be relative to the default ArmarX config dir (${ARMARX_WORKSPACE}/armarx_config)
 #  Attributes:
 #  - Default:            mongo/.cache

scenarios/memory_to_debug_observer/config/global.cfg

+# ==================================================================
+# Global Config from Scenario memory_to_debug_observer
+# ==================================================================
+

scenarios/memory_to_debug_observer/memory_to_debug_observer.scx

+<?xml version="1.0" encoding="utf-8"?>
+<scenario name="memory_to_debug_observer" creation="1970-01-01.01:00:00" globalConfigName="./config/global.cfg" package="RobotAPI" deploymentType="local" nodeName="NodeMain">
+	<application name="MemoryToDebugObserver" instance="" package="RobotAPI" nodeName="" enabled="true" iceAutoRestart="false"/>
+</scenario>
+

source/RobotAPI/components/RobotNameService/RobotNameService.cpp

@@ -54,8 +54,8 @@ namespace armarx
     }
 
     bool
-    RobotNameService::registerRobot(const robot_name_service::dto::Robot& robot,
-                                    const Ice::Current& current)
+    RobotNameService::registerRobotInfo(const robot_name_service::dto::RobotInfo& robot,
+                                        const Ice::Current& current)
     {
         std::scoped_lock l(robotsMutex);
         ARMARX_INFO << "Register a new robot with name '" << robot.name << "' in RNS";
@@ -72,7 +72,7 @@ namespace armarx
     }
 
     void
-    RobotNameService::unregisterRobot(const std::string& name, const Ice::Current& current)
+    RobotNameService::unregisterRobotInfo(const std::string& name, const Ice::Current& current)
     {
         std::scoped_lock l(robotsMutex);
 
@@ -82,8 +82,8 @@ namespace armarx
         }
     }
 
-    IceUtil::Optional<robot_name_service::dto::Robot>
-    RobotNameService::getRobot(const std::string& name, const Ice::Current& current)
+    IceUtil::Optional<robot_name_service::dto::RobotInfo>
+    RobotNameService::getRobotInfo(const std::string& name, const Ice::Current& current)
     {
         std::scoped_lock l(robotsMutex);
 

source/RobotAPI/components/RobotNameService/RobotNameService.h

@@ -87,14 +87,14 @@ namespace armarx
 
         // RobotNameServiceInterface interface
     public:
-        bool registerRobot(const robot_name_service::dto::Robot& robot,
-                           const Ice::Current& current) override;
-        void unregisterRobot(const std::string& name, const Ice::Current& current) override;
-        IceUtil::Optional<robot_name_service::dto::Robot>
-        getRobot(const std::string& name, const Ice::Current& current) override;
+        bool registerRobotInfo(const robot_name_service::dto::RobotInfo& robot,
+                               const Ice::Current& current) override;
+        void unregisterRobotInfo(const std::string& name, const Ice::Current& current) override;
+        IceUtil::Optional<robot_name_service::dto::RobotInfo>
+        getRobotInfo(const std::string& name, const Ice::Current& current) override;
 
     private:
         mutable std::mutex robotsMutex;
-        std::map<std::string, robot_name_service::core::Robot> robots;
+        std::map<std::string, robot_name_service::core::RobotInfo> robots;
     };
 } // namespace armarx

source/RobotAPI/components/RobotState/RobotStateComponent.cpp

@@ -37,6 +37,8 @@
 #include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
 #include <ArmarXCore/core/system/ArmarXDataPath.h>
 #include <ArmarXCore/core/time/TimeUtil.h>
+#include <RobotAPI/components/units/RobotUnit/util/RtTiming.h>
+#include <RobotAPI/components/units/RobotUnit/util/NonRtTiming.h>
 
 
 using namespace Eigen;
@@ -296,10 +298,10 @@ namespace armarx
     {
         if (timestamp <= 0)
         {
-            timestamp = IceUtil::Time::now().toMicroSeconds();
+            timestamp = armarx::rtNow().toMicroSeconds();
         }
 
-        IceUtil::Time time = IceUtil::Time::microSeconds(timestamp);
+        IceUtil::Time time = mapRtTimestampToNonRtTimestamp(IceUtil::Time::microSeconds(timestamp));
 
         ARMARX_DEBUG << deactivateSpam(1) << "Got new jointangles: " << jointAngles
                      << " from timestamp " << time.toDateTime()

source/RobotAPI/components/armem/client/CMakeLists.txt

 add_subdirectory(ExampleMemoryClient)
 add_subdirectory(GraspProviderExample)
+add_subdirectory(MemoryToDebugObserver)
 add_subdirectory(ObjectInstanceToIndex)
 add_subdirectory(RobotStatePredictionClientExample)
 add_subdirectory(SimpleVirtualRobot)

source/RobotAPI/components/armem/client/MemoryToDebugObserver/CMakeLists.txt

+armarx_component_set_name(MemoryToDebugObserver)
+
+set(COMPONENT_LIBS
+    ArmarXCore
+    ArmarXCoreComponentPlugins
+    ArmarXGuiComponentPlugins
+    RobotAPICore RobotAPIInterfaces
+    armem
+)
+
+set(SOURCES
+    Component.cpp
+)
+
+set(HEADERS
+    Component.h
+)
+
+armarx_add_component("${SOURCES}" "${HEADERS}")
+
+armarx_generate_and_add_component_executable(
+    COMPONENT_INCLUDE
+        "${CMAKE_CURRENT_LIST_DIR}/Component.h"
+    COMPONENT_NAMESPACE
+        armarx::memory_to_debug_observer
+    COMPONENT_CLASS_NAME
+        Component
+)

source/RobotAPI/components/armem/client/MemoryToDebugObserver/Component.cpp

+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package    RobotAPI::ArmarXObjects::MemoryToDebugObserver
+ * @author     Rainer Kartmann ( rainer dot kartmann at kit dot edu )
+ * @date       2023
+ * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
+ *             GNU General Public License
+ */
+
+#include "Component.h"
+
+#include <SimoxUtility/json.h>
+
+#include <ArmarXCore/core/time/Frequency.h>
+#include <ArmarXCore/core/time/Metronome.h>
+
+namespace armarx::memory_to_debug_observer
+{
+
+    armarx::PropertyDefinitionsPtr
+    Component::createPropertyDefinitions()
+    {
+        armarx::PropertyDefinitionsPtr defs =
+            new ComponentPropertyDefinitions(getConfigIdentifier());
+
+        {
+            armem::MemoryID robotEntityId{"RobotState", "Proprioception", "Armar7", "Armar7"};
+
+            std::vector<std::string> jointNames{
+                "Neck_1_Yaw",
+                "Neck_2_Hemisphere_A",
+                "Neck_3_Hemisphere_B",
+            };
+
+            for (const std::string& jointName : jointNames)
+            {
+                std::vector<std::string> attributes{
+                    "position",
+                    "positionTarget",
+                    "relativePosition",
+                    "velocity",
+                    "velocityTarget",
+                    "torque",
+                    "motorCurrent",
+                    "currentTarget",
+                };
+                for (const std::string& attribute : attributes)
+                {
+                    properties.memoryToDebugObserver.plottedValues.push_back({
+                        .entityID = robotEntityId,
+                        .aronPath = {{"joints", attribute, jointName}},
+                    });
+                    properties.memoryToDebugObserver.plottedValues.push_back({
+                        .entityID = robotEntityId,
+                        .aronPath = {{"extraLongs", jointName + ".absoluteEncoderTicks"}},
+                    });
+                }
+            }
+
+            simox::json::json j = properties.memoryToDebugObserver;
+            properties.memoryToDebugObserverJson = j.dump();
+        }
+        defs->optional(properties.memoryToDebugObserverJson,
+                       "p.memoryToDebugObserverJson",
+                       "Configuration of MemoryToDebugObserver in JSON format.");
+
+        defs->optional(properties.pollFrequencyHz, "p.pollFrequencyHz");
+
+        return defs;
+    }
+
+    Component::Component()
+    {
+    }
+
+    std::string
+    Component::getDefaultName() const
+    {
+        return "MemoryToDebugObserver";
+    }
+
+    void
+    Component::onInitComponent()
+    {
+        DebugObserverComponentPluginUser::setDebugObserverBatchModeEnabled(true);
+
+        {
+            simox::json::json j = simox::json::json::parse(properties.memoryToDebugObserverJson);
+            j.get_to(properties.memoryToDebugObserver);
+        }
+    }
+
+    void
+    Component::onConnectComponent()
+    {
+        createRemoteGuiTab();
+        RemoteGui_startRunningTask();
+
+        task = new RunningTask<Component>(this, &Component::runLoop);
+        task->start();
+    }
+
+    void
+    Component::onDisconnectComponent()
+    {
+        task->stop();
+        task = nullptr;
+    }
+
+    void
+    Component::onExitComponent()
+    {
+    }
+
+    void
+    Component::runLoop()
+    {
+        armem::client::util::MemoryToDebugObserver::Services services{
+            .memoryNameSystem = memoryNameSystem(),
+            .debugObserver = getDebugObserverComponentPlugin(),
+        };
+        armem::client::util::MemoryToDebugObserver memoryToDebugObserver{
+            properties.memoryToDebugObserver, services};
+
+        Frequency frequency = Frequency::Hertz(properties.pollFrequencyHz);
+        Metronome metronome(frequency);
+        while (task and not task->isStopped())
+        {
+            memoryToDebugObserver.pollOnce();
+            metronome.waitForNextTick();
+        }
+    }
+
+    void
+    Component::createRemoteGuiTab()
+    {
+        using namespace armarx::RemoteGui::Client;
+
+        tab.group = GroupBox();
+        tab.group.setLabel("Todo ...");
+
+        VBoxLayout root = {tab.group, VSpacer()};
+        RemoteGui_createTab(getName(), root, &tab);
+    }
+
+    void
+    Component::RemoteGui_update()
+    {
+        if (tab.rebuild.exchange(false))
+        {
+            createRemoteGuiTab();
+        }
+    }
+
+} // namespace armarx::memory_to_debug_observer

source/RobotAPI/components/armem/client/MemoryToDebugObserver/Component.h

+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package    RobotAPI::ArmarXObjects::MemoryToDebugObserver
+ * @author     Rainer Kartmann ( rainer dot kartmann at kit dot edu )
+ * @date       2023
+ * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
+ *             GNU General Public License
+ */
+
+#pragma once
+
+#include <ArmarXCore/core/Component.h>
+#include <ArmarXCore/libraries/ArmarXCoreComponentPlugins/DebugObserverComponentPlugin.h>
+#include <ArmarXCore/util/tasks.h>
+
+#include <ArmarXGui/libraries/ArmarXGuiComponentPlugins/LightweightRemoteGuiComponentPlugin.h>
+
+#include <RobotAPI/libraries/armem/client/plugins/PluginUser.h>
+#include <RobotAPI/libraries/armem/client/util/MemoryToDebugObserver.h>
+
+namespace armarx::memory_to_debug_observer
+{
+
+    /**
+     * @defgroup Component-MemoryToDebugObserver MemoryToDebugObserver
+     * @ingroup RobotAPI-Components
+     *
+     * Transfers data from the memory system to the \ref Component-DebugObserver "Debug Observer",
+     * allowing to visualize them in the \ref ArmarXGui-GuiPlugins-PlotterPlugin "Live Plotter".
+     *
+     * @see armarx::armem::client::util::MemoryToDebugObserver for the business logic
+     * implementation.
+     *
+     * @class Component
+     * @ingroup Component-MemoryToDebugObserver
+     * @brief Implementation of \ref Component-MemoryToDebugObserver.
+     *
+     * @see armarx::armem::client::util::MemoryToDebugObserver for the business logic
+     * implementation.
+     */
+    class Component :
+        virtual public armarx::Component,
+        virtual public armarx::armem::ClientPluginUser,
+        virtual public armarx::DebugObserverComponentPluginUser,
+        virtual public armarx::LightweightRemoteGuiComponentPluginUser
+    {
+    public:
+        Component();
+
+        /// @see armarx::ManagedIceObject::getDefaultName()
+        std::string getDefaultName() const override;
+
+        // LightweightRemoteGuiComponentPluginUser interface
+    public:
+        void createRemoteGuiTab();
+        void RemoteGui_update() override;
+
+
+    protected:
+        armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
+
+        void onInitComponent() override;
+        void onConnectComponent() override;
+        void onDisconnectComponent() override;
+        void onExitComponent() override;
+
+        void runLoop();
+
+
+    private:
+        struct Properties
+        {
+            armem::client::util::MemoryToDebugObserver::Properties memoryToDebugObserver;
+            std::string memoryToDebugObserverJson;
+
+            float pollFrequencyHz = 30;
+        };
+
+        Properties properties;
+
+        armarx::RunningTask<Component>::pointer_type task;
+
+        struct RemoteGuiTab : RemoteGui::Client::Tab
+        {
+            std::atomic_bool rebuild = false;
+
+            RemoteGui::Client::GroupBox group;
+        };
+
+        RemoteGuiTab tab;
+    };
+} // namespace armarx::memory_to_debug_observer

source/RobotAPI/components/skills/SkillProviderExample/HelloWorld.cpp

@@ -29,7 +29,8 @@ namespace armarx::skills::provider
                                 .rootProfileDefaults = root_profile_params.toAron(),
                                 .timeout = armarx::core::time::Duration::MilliSeconds(1000),
                                 .parametersType =
-                                    armarx::skills::Example::HelloWorldAcceptedType::ToAronType()};
+                                    armarx::skills::Example::HelloWorldAcceptedType::ToAronType(),
+                                .resultType = armarx::skills::Example::HelloWorldAcceptedType::ToAronType()};
     }
 
     Skill::MainResult
@@ -42,6 +43,6 @@ namespace armarx::skills::provider
                                 .dump(2)
                          << "\n"
                          << "(executed at: " << IceUtil::Time::now() << ")";
-        return {TerminatedSkillStatus::Succeeded, nullptr};
+        return {TerminatedSkillStatus::Succeeded, in.parameters.toAron()};
     }
 } // namespace armarx::skills::provider