|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file
CONTRIBUTING
|
yasmin repositoryyasmin yasmin_cli yasmin_demos yasmin_editor yasmin_factory yasmin_msgs yasmin_pcl yasmin_plugins_manager yasmin_ros yasmin_viewer |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/uleroboticsgroup/yasmin.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-04-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| yasmin | 5.0.0 |
| yasmin_cli | 5.0.0 |
| yasmin_demos | 5.0.0 |
| yasmin_editor | 5.0.0 |
| yasmin_factory | 5.0.0 |
| yasmin_msgs | 5.0.0 |
| yasmin_pcl | 5.0.0 |
| yasmin_plugins_manager | 5.0.0 |
| yasmin_ros | 5.0.0 |
| yasmin_viewer | 5.0.0 |
README
YASMIN (Yet Another State MachINe)
YASMIN is a project focused on implementing robot behaviors using Finite State Machines (FSM). It is available for ROS 2, Python and C++.
Table of Contents
- Key Features
- Installation
- Demos
- Cross-Language ROS Interface Communication
- TF States
- YASMIN Editor
- YASMIN Viewer
- YASMIN CLI
- YASMIN Factory
- YASMIN PCL
- YASMIN Plugins Manager
- Citations
Key Features
- ROS 2 Integration: Integrates with ROS 2 for easy deployment and interaction.
- Support for Python and C++: Available for both Python and C++, making it flexible for a variety of use cases.
- Rapid Prototyping: Designed for fast prototyping, allowing quick iteration of state machine behaviors.
- Predefined States: Includes states for interacting with ROS 2 action clients, service clients, and topics.
- Data Sharing with Blackboards: Utilizes blackboards for data sharing between states and state machines.
- State Management: Supports cancellation and stopping of state machines, including halting the current executing state.
- Concurrence: Run multiple states in parallel with configurable join policies.
- XML State Machines: Define state machines in XML files using the Factory and load them at runtime with plugins.
- Graphical Editor: Visual editor for building state machines with drag-and-drop functionality.
- Web Viewer: Features an integrated web viewer for real-time monitoring of state machine execution.
- CLI Tool: Command-line interface for listing, inspecting, running, validating, editing, and testing state machines.
- PCL Integration: Predefined states for Point Cloud Library (PCL) operations, including filtering, segmentation, and point cloud I/O.
- Plugin Architecture: Extensible plugin system for registering custom states usable across C++ and Python.
- State Metadata: States and state machines support descriptions and typed input/output blackboard key annotations.
- Cross-Language Serialization: Share ROS interfaces between Python and C++ states via binary serialization.
-
TF Integration:
TfBufferStatecreates and shares a tf2 buffer and transform listener through the blackboard so all states in the machine can perform coordinate frame lookups.
Installation
Debian Packages
To install YASMIN and its packages, use the following command:
sudo apt install ros-$ROS_DISTRO-yasmin ros-$ROS_DISTRO-yasmin-*
Building from Source
Follow these steps to build the source code from this repository:
cd ~/ros2_ws/src
git clone https://github.com/uleroboticsgroup/yasmin.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
colcon build
Then, you can run the tests as follow:
File truncated at 100 lines see the full file