From 7153cef13229105c94c224d5ceaad15d24e9d79e Mon Sep 17 00:00:00 2001 From: Ralph Lange Date: Mon, 17 Dec 2018 09:53:15 +0100 Subject: [PATCH 1/5] Added first draft of embedded TF subpage. Signed-off-by: Ralph Lange --- embedded_tf/index.md | 42 ++++++++++++++++++++++++++++++++++++++++++ index.md | 3 ++- 2 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 embedded_tf/index.md diff --git a/embedded_tf/index.md b/embedded_tf/index.md new file mode 100644 index 00000000..ae865c11 --- /dev/null +++ b/embedded_tf/index.md @@ -0,0 +1,42 @@ +# Embedded TF + +Table of contents + +* [Introduction and Goal](#introduction-and-goal) +* [Requirements](#requirements) +* [Design](#design) +* [Implementation of tf2_filter](#Implementation-of-tf2_filter) +* [Roadmap](#roadmap) +* [Acknowledgments](#acknowledgments) + + +## Introduction and Goal + +The TF transform graph, with its support for both a temporal history, and distributed information sources, has been a novel tool for robotics frameworks when it was released in 2008. Functionally, it is based in scene graph concepts known from computer graphics [[Foote 2013]](https://ieeexplore.ieee.org/document/6556373), but these only rarely offer distribution, and did not offer temporal histories at all (mainly, because this is not needed for framebased rendering applications like in computer graphics). Distributed scene graphs have become more widely available also in computer graphics. In robotics, work by de Laet et al. [[De Laet et al. 2013]](https://ieeexplore.ieee.org/document/6696693) has extended transforms graphs to also contain twist (i.e., angular motion) information, and to provide more compile-time error checking. This is not currently integrated with distribution mechanisms, but could be used on a single system. + +micro-ROS will go beyond this state of the art by running the dynamic transform tree in an embedded device, while keeping resource use to a minimum based on an analysis of the spatial and temporal details actually necessary. Further, enabling real-time queries even in the face of concurrent updates through integration will be realized through integration with the microROS real-time executor. It is also planned to integrate the embedded TF will with the node lifecycle to achieve further power-savings + + +## Requirements + +... are documented at [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/requirements.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/requirements.md). + + +## Design + +... is documented at [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md). + + +## Implementation of tf2_filter + +... can be found at [github.com/microROS/geometry2/blob/ros2/tf2_filter/](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/). + + +## Roadmap + +... + + +## Acknowledgments + +This activity has received funding from the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation programme (grant agreement n° 780785). diff --git a/index.md b/index.md index ddcd4f2e..0b4a6d29 100644 --- a/index.md +++ b/index.md @@ -17,7 +17,8 @@ We'll update this README as we proceed. For now, you can check out our work on: - Real-Time Operating System: [https://github.com/microROS/NuttX](https://github.com/microROS/NuttX) - Micro-ROS in RTOS example applications: [apps](https://github.com/microROS/apps) - Predictable scheduling and execution: [real-time_executor](real-time_executor/) - - System modes and system hierarchy: [system-modes](system_modes/) + - System modes and system hierarchy: [system_modes](system_modes/) + - Embedded transform (tf) library: [embedded_tf](embedded_tf/) - Reference hardware: [https://github.com/microROS/hardware](https://github.com/microROS/hardware) - Build infrastructure for embedded development using docker: [https://github.com/microROS/docker](https://github.com/microROS/docker) From 5744ab4a6b4f61dd8cc7c6b23ffc35fdfc77d8ed Mon Sep 17 00:00:00 2001 From: Arne Nordmann Date: Mon, 17 Dec 2018 12:53:29 +0100 Subject: [PATCH 2/5] Minor updates --- embedded_tf/index.md | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/embedded_tf/index.md b/embedded_tf/index.md index ae865c11..8558ec66 100644 --- a/embedded_tf/index.md +++ b/embedded_tf/index.md @@ -2,39 +2,34 @@ Table of contents -* [Introduction and Goal](#introduction-and-goal) -* [Requirements](#requirements) -* [Design](#design) -* [Implementation of tf2_filter](#Implementation-of-tf2_filter) -* [Roadmap](#roadmap) -* [Acknowledgments](#acknowledgments) +- [Embedded TF](#embedded-tf) + - [Introduction and Goal](#introduction-and-goal) + - [Requirements](#requirements) + - [Design](#design) + - [Implementation of tf2_filter](#implementation-of-tf2filter) + - [Acknowledgments](#acknowledgments) ## Introduction and Goal -The TF transform graph, with its support for both a temporal history, and distributed information sources, has been a novel tool for robotics frameworks when it was released in 2008. Functionally, it is based in scene graph concepts known from computer graphics [[Foote 2013]](https://ieeexplore.ieee.org/document/6556373), but these only rarely offer distribution, and did not offer temporal histories at all (mainly, because this is not needed for framebased rendering applications like in computer graphics). Distributed scene graphs have become more widely available also in computer graphics. In robotics, work by de Laet et al. [[De Laet et al. 2013]](https://ieeexplore.ieee.org/document/6696693) has extended transforms graphs to also contain twist (i.e., angular motion) information, and to provide more compile-time error checking. This is not currently integrated with distribution mechanisms, but could be used on a single system. +The TF transform graph, with its support for both a temporal history, and distributed information sources, has been a novel tool for robotics frameworks when it was released in 2008. Functionally, it is based in scene graph concepts known from computer graphics [[Foote 2013]](https://ieeexplore.ieee.org/document/6556373), but these only rarely offer distribution, and did not offer temporal histories at all (mainly, because this is not needed for frame-based rendering applications like in computer graphics). Distributed scene graphs have become more widely available also in computer graphics. In robotics, work by de Laet et al. [[De Laet et al. 2013]](https://ieeexplore.ieee.org/document/6696693) has extended transforms graphs to also contain twist (i.e., angular motion) information, and to provide more compile-time error checking. This is currently not integrated with distribution mechanisms, but could be used on a single system. micro-ROS will go beyond this state of the art by running the dynamic transform tree in an embedded device, while keeping resource use to a minimum based on an analysis of the spatial and temporal details actually necessary. Further, enabling real-time queries even in the face of concurrent updates through integration will be realized through integration with the microROS real-time executor. It is also planned to integrate the embedded TF will with the node lifecycle to achieve further power-savings ## Requirements -... are documented at [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/requirements.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/requirements.md). +Embedded TF requirements are documented at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/requirements.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/requirements.md). ## Design -... is documented at [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md). +The Embedded TF design is documented at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md). ## Implementation of tf2_filter -... can be found at [github.com/microROS/geometry2/blob/ros2/tf2_filter/](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/). - - -## Roadmap - -... +Implementation of tf2_filter for ROS2 and micro-ROS can be found at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/). ## Acknowledgments From 7f6b0e2f9a9e0468570edebef51cc4d953fb7440 Mon Sep 17 00:00:00 2001 From: Ralph Lange Date: Mon, 17 Dec 2018 17:59:12 +0100 Subject: [PATCH 3/5] Added roadmap. Signed-off-by: Ralph Lange --- embedded_tf/index.md | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/embedded_tf/index.md b/embedded_tf/index.md index 8558ec66..49504881 100644 --- a/embedded_tf/index.md +++ b/embedded_tf/index.md @@ -2,12 +2,12 @@ Table of contents -- [Embedded TF](#embedded-tf) - - [Introduction and Goal](#introduction-and-goal) - - [Requirements](#requirements) - - [Design](#design) - - [Implementation of tf2_filter](#implementation-of-tf2filter) - - [Acknowledgments](#acknowledgments) +- [Introduction and Goal](#introduction-and-goal) +- [Requirements](#requirements) +- [Design](#design) +- [Implementation of tf2_filter](#implementation-of-tf2filter) +- [Roadmap](#roadmap) +- [Acknowledgments](#acknowledgments) ## Introduction and Goal @@ -27,6 +27,18 @@ Embedded TF requirements are documented at: [github.com/microROS/geometry2/blob The Embedded TF design is documented at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md). +## Roadmap + +**2018** +* Static filter approach in the agent allowing to specify the parts of the kinematic chain that are relevant for an application component on micro-ROS. + +**2019** +* Design and implement an embedded TF implementation which is integrated with the real-time executor in a way that removes the need for costly synchronization primitives. + +**2020** +* Design and implement an API extension, as well as a reference implementation for custom transform representations that increase run-time efficiency. + + ## Implementation of tf2_filter Implementation of tf2_filter for ROS2 and micro-ROS can be found at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/). From 5a1add41b1b2e09143688bffffdc083f47417d1a Mon Sep 17 00:00:00 2001 From: Ralph Lange Date: Mon, 17 Dec 2018 18:01:06 +0100 Subject: [PATCH 4/5] Moved section. Signed-off-by: Ralph Lange --- embedded_tf/index.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/embedded_tf/index.md b/embedded_tf/index.md index 49504881..320a8913 100644 --- a/embedded_tf/index.md +++ b/embedded_tf/index.md @@ -27,6 +27,11 @@ Embedded TF requirements are documented at: [github.com/microROS/geometry2/blob The Embedded TF design is documented at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/docs/design.md). +## Implementation of tf2_filter + +Implementation of tf2_filter for ROS2 and micro-ROS can be found at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/). + + ## Roadmap **2018** @@ -39,11 +44,6 @@ The Embedded TF design is documented at: [github.com/microROS/geometry2/blob/ro * Design and implement an API extension, as well as a reference implementation for custom transform representations that increase run-time efficiency. -## Implementation of tf2_filter - -Implementation of tf2_filter for ROS2 and micro-ROS can be found at: [github.com/microROS/geometry2/blob/ros2/tf2_filter/](https://github.com/microROS/geometry2/blob/ros2/tf2_filter/). - - ## Acknowledgments This activity has received funding from the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation programme (grant agreement n° 780785). From 4ba2e4de9733da724c741a8314e654a79ae482c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ingo=20L=C3=BCtkebohle?= Date: Tue, 18 Dec 2018 16:20:27 +0100 Subject: [PATCH 5/5] Apply suggestions from code review Co-Authored-By: ralph-lange --- embedded_tf/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/embedded_tf/index.md b/embedded_tf/index.md index 320a8913..0706bc96 100644 --- a/embedded_tf/index.md +++ b/embedded_tf/index.md @@ -13,7 +13,7 @@ Table of contents ## Introduction and Goal The TF transform graph, with its support for both a temporal history, and distributed information sources, has been a novel tool for robotics frameworks when it was released in 2008. Functionally, it is based in scene graph concepts known from computer graphics [[Foote 2013]](https://ieeexplore.ieee.org/document/6556373), but these only rarely offer distribution, and did not offer temporal histories at all (mainly, because this is not needed for frame-based rendering applications like in computer graphics). Distributed scene graphs have become more widely available also in computer graphics. In robotics, work by de Laet et al. [[De Laet et al. 2013]](https://ieeexplore.ieee.org/document/6696693) has extended transforms graphs to also contain twist (i.e., angular motion) information, and to provide more compile-time error checking. This is currently not integrated with distribution mechanisms, but could be used on a single system. - +One persistent issue with transform graphs has been their resource use. ROS TF works through replicated copies of the entire transform tree at every node that uses it, and is implemented through unicast TCP connections between nodes. In systems with many dynamic parts, this has sometimes been called the ``TF firehose``, because of the large stream of incoming messages. micro-ROS will go beyond this state of the art by running the dynamic transform tree in an embedded device, while keeping resource use to a minimum based on an analysis of the spatial and temporal details actually necessary. Further, enabling real-time queries even in the face of concurrent updates through integration will be realized through integration with the microROS real-time executor. It is also planned to integrate the embedded TF will with the node lifecycle to achieve further power-savings