Generate doc

.gitignore

@@ -41,3 +41,5 @@
 *.dwo
 
 build
+html
+xml

.gitmodules

@@ -4,12 +4,12 @@
 [submodule "robotlib"]
 	path = robotlib
 	url = git@github.com:iit-DLSLab/robotlib.git
-[submodule "gluecode"]
-	path = gluecode
-	url = git@github.com:iit-DLSLab/gluecode.git
 [submodule "dls2_ros2_interface"]
 	path = dls2_ros2_interface
 	url = git@github.com:iit-DLSLab/dls2_ros2_interface.git
 [submodule "dls2_msgs"]
 	path = dls2_msgs
 	url = git@github.com:iit-DLSLab/dls2_msgs.git
+[submodule "pinocchio-gluecode"]
+	path = pinocchio-gluecode
+	url = git@github.com:iit-DLSLab/pinocchio-gluecode.git

CMakeLists.txt

@@ -15,7 +15,7 @@ if(BUILD_DLS2_MSGS)
 	add_subdirectory(dls2_msgs)
 endif()
 add_subdirectory(robotlib)
-add_subdirectory(gluecode)
+add_subdirectory(pinocchio-gluecode)
 add_subdirectory(visualizers/rviz_interface)
 
 # generate ROS2 messages from IDL files each time CMake is run, to ensure they are always up to date with the IDL definitions

README.md

@@ -1,29 +1,65 @@
 # dls2-barebone
+This repository contains the official implementation of _D. Wildgrube Bertol, G. Fink, M. Marchitto, Y. Nisticò, M. Pestarino, and C. Semini, “DLS2: A distributed microcomponent-based robotic software architecture”_, which is currently under review.
 
-This repository provides a reusable, buildable base for DLS2 robot control applications. It brings together the DLS2 framework, the Robotlib robot interface, robot-specific glue code, RViz visualization support, and a ROS 2 interface for shared message definitions and network settings.
+It provides a reusable, buildable base for DLS2 robot control applications. It brings together the DLS2 framework, the Robotlib robot interface, the pinocchio-gluecode, RViz visualization support, and a ROS 2 interface for shared message definitions and network settings.
 
-## Repository Structure
+# Project Status
+This project is currently in **pre-release** and under active development.
+
+[![Build Test](https://github.com/iit-DLSLab/dls2-barebone/actions/workflows/build_test.yml/badge.svg)](https://github.com/iit-DLSLab/dls2-barebone/actions/workflows/build_test.yml)
+
+# Repository Structure
 
 | Component | Path | Description |
 |-----------|------|-------------|
-| **DLS2 Framework** | `dls2/` | Core control middleware. Contains modules for control, state estimation, messaging (DDS/IDL), plugins, tasks, state machines, signal handling, logging, and utilities. |
+| **DLS2 Framework** | `dls2/` | Core control middleware. Contains modules for control, state estimation, messaging (DDS/IDL), plugins, state machines, signal handling, logging, and utilities. |
 | **Robotlib** | `robotlib/` | Generic C++ robot abstraction layer. Provides a common API (kinematics, dynamics, Jacobians, data structures) that controllers target, independent of any specific robot morphology. Uses a factory pattern with `dlopen` for runtime-loadable robot libraries. |
-| **GlueCode** | `gluecode/` | Robot-specific implementation of the Robotlib interface based on Pinocchio. Loaded at runtime as a shared library. |
+| **GlueCode** | `pinocchio-gluecode/` | Robot-specific implementation of the Robotlib interface based on Pinocchio. Loaded at runtime as a shared library. |
 | **RViz Interface** | `visualizers/rviz_interface/` | Visualization support for RViz. |
 | **ROS 2 Interface** | `dls2_ros2_interface/` | Bidirectional message bridge between DLS2 IDL definitions and ROS 2 `.msg` types. Provides tooling to convert `.idl` ↔ `.msg` and scripts to configure FastDDS discovery so ROS 2 and DLS2 communicate over the same DDS domain. |
 
+# Documentation
+To generate the documentation:
+
+```bash
+cd dls2-barebone
+doxygen docs/Doxifile
+```
+To open the documentation double click on the file build/html/index.html.
+
+# Installation
+## Pull or build docker image
+You can either pull the docker image `ghcr.io/iit-dlslab/dls2-dev:latest` or you can build it from scratch.
+### Pulling
 
-## Building
+```docker pull ghcr.io/iit-dlslab/dls2-dev:latest```
 
+### Building - TODO
+
+## Clone repository
+```bash
+git clone --recursive https://github.com/iit-DLSLab/dls2-barebone.git
+cd dls2-barebone
+```
+## Open docker image - TODO
+```bash
+docker run
+cd dls2-barebone
+```
+## Build
 ```bash
 mkdir build && cd build
 cmake ..
 make
+sudo make install
 ```
+The first compilation takes a bit of time because it needs to compile all the messages (the ROS2 default ones and the DLS2 ones).
 
-## Documentation: TODO
-
+# Run example - TODO
+To run an example, you can have a look at this repo, where a ready-to-use framework is provided for quadruped locomotion.
 
-## Docker image
+# Contributing
+Feel free to open issues and/or PRs!
 
-- Docker image `ghcr.io/iit-dlslab/dls2-dev:latest` 
+# Mantainers
+This repository is mantained by [Marco Marchitto](https://github.com/MMarcus95) and [Michele Pestarino](https://github.com/mich-pest).

docs/CurrentStageOfDevelopment.md

@@ -0,0 +1,20 @@
+# Current stage of development
+
+The implementation of DLS2 is progressing incrementally, translating its architectural principles as distribution, real-time awareness, modularity, and platform independence, into operational software components. Development milestones are organized per architectural layer and subsystem, enabling iterative validation and controlled evolution. Each architectural element has been addressed through targeted development efforts, resulting in a system that is both operational and extensible.
+
+The current implementation includes the following capabilities:
+
+- **Distributed Node Architecture**: A node management subsystem abstracts each hardware unit as a node and supports dynamic application placement, coordinated lifecycle management, and comprehensive health monitoring at both the device and process levels, including execution status, real-time compliance, resource utilization, and data integrity and synchronization checks.
+- **Omnipresent Layers**: Functional domains (Hardware, Control, Estimation, Console, Log) are instantiated on any capable node, with explicit classification into real-time (RT) or best-effort (BE) execution contexts.
+- **Controller Layer**: Orchestrates multiple controllers, and aggregates control signals under deterministic scheduling constraints.
+- **Distributed Supervisor**: Local automata embedded within processes (\eg drivers, estimators, controllers) compose global behavior, enabling safe initialization and controlled switching.
+- **Containerization Runtime**: Packages applications with dependencies to ensure reproducible deployment across heterogeneous nodes and enable migration under policy constraints.
+- **QoS-Aware Communication**: A DDS-class messaging substrate provides publish--subscribe and request--response semantics with configurable QoS, semantic domain segregation, and automatic discovery.
+- **Real-Time Conformance Tooling**: Preliminary tooling validates configuration against RT policies (\eg latency budgets, jitter bounds, deadline miss ratios) and reports metrics to guide placement and scheduling.
+- **Console and Logging**: Operator-facing tools provide diagnostics, structured logs, and runtime introspection of processes and topics.
+- **Dynamic Discovery and Interoperability**: Nodes can join or leave with minimal reconfiguration; compatibility with ROS2 is fully supported, provided that the used middleware is FastDDS.
+- **Plugin Architecture**: External libraries can be attached as plugins, promoting reuse and framework independence.
+
+
+The current implementation of the DDS standard is based on **FastDDS**. From
+an implementation standpoint, the vast majority of the framework’s features and tools are developed in C++. However, Python-based processes are also integrated through a dedicated binding that exploits the proposed plugin architecture. %This solution preserves real-time guarantees and ensures consistent node lifecycle management across programming languages, while enabling rapid prototyping and development by leveraging the extensive Python library ecosystem.