Compose a simple laser obstacle avoid system with the Pioneer P3dx robot and the Player/Stage simulator.
This tutorial is also available as video tutorial.
|Role||System builder, but also other roles while browsing through the system's building blocks|
|Assumptions||Having complete tutorial Developing Your First Software Component|
|System Requirements||Virtual Machine Image Installed, see ready-to-go virtual machine|
|You will Learn|| What are the different viewpoints in the system
How to compose a system from different components in System Architecture
How to configure a Target Platform
How to choose a Hardware platform for Deployment configurations
How to use developed component in a system
This tutorial describes how a system builder (role) composes previously developed software components to a robotics system that moves around in a simulated environment while avoiding obstacles. The tutorial shows all the necessary steps to reproduce this task using the SmartMDSD Toolchain (v3), an Integrated Development Environment for system composition in a robotics software ecosystem.
The robot is composed from two software components. One component has been developed in the previous tutorial. For demonstration purposes, it realizes a very simple obstacle avoidance algorithm. The second component provides the service-level interfaces of a robot base and simulates a PioneerP3Dx using Player/Stage. The system architecture is an excerpt of the RobMoSys “Flexible Navigation Stack” (see robmosys.eu/wiki). The excerpt includes a laser service and motion command velocity service. The “Flexible Navigation Stack” is in use with real service robots.
The tutorial begins with creating the system component architecture model, then the target platform model, and the deployment model. Finally, it shows the deployment of the system to the robot and its execution.
For working with system projects, we first need to open the System Builder (Tier 3) perspective (available since toolchain version 3.9). To do so, either directly click on the System Builder (Tier 3) tab located at the upper right in the Eclipse window (which will be visible after you opened this perspective for the first time). To open the persepctive initially, use the Open Perspective button and then select the System Builder (Tier 3) in the next popup window (see next screenshot). Please also read the new UI features HowTo for further information on the new perspectives.
We begin with modeling the system component architecture that models instances of software components and how they are connected.
Step 1: Create a System Project that will hold all our models. Name the project “SystemLaserObstacleAvoidP3dxPlayerStageSimulatorNew”
Step 2: Get familiar with the file structure.
Step 3: Next, import the components you want to compose to your project. Use “Import Components” from the palette.
Step 4: Compose the system: create instances of the software components. Instantiate ComponetLaserObstacleAvoidNew (developed by you in the previous tutorial).
Step 5: Also, instantiate ComponentPlayerStageSimulator (a component already existing)
Step 6: Now your component instances are ready to be connected.
Step 7: The components come with ports. They are hidden in earlier versions of the toolchain and needed to be made visible. By version >=3.8, they become visible upon creating the instance. In case they are missing, make them visible by using the “Required Service(s)” or “Provided Service(s)” icon in the palette.
For the InputPort LaserServiceIn:
For the OutputPort NavigationVelocityServiceOut:
Step 8: We also make visible the services of the component ComponentPlayerStageSimulator. See Step 7 for an explanation.
Step 9: Finally, create the initial wiring of the services as illustrated. Use the “Connection” from the palette.
We now have composed the system and modeled the system component architecture. Before we can assign the software component to a processing unit / target, we need to create the model of the target platform.
Step 1: Open the target platform model
Step 2: Add an empty target platform. It will automatically create a default middleware configuration.
Step 3: Add a network interface
Step 4: Add a login account. This will later be used to deploy the software components.
Step 5: Target configuration completed
Now your system is ready to model the deployment of components. The deployment model defines which component is to be deployed/transferred to which target platform/processing unit/computer. Since this is a learing tutorial, we will deploy to your local system. Please see later tutorials on how to deploy your system to an actual robot and/or remote system. It is possible to deploy to multiple systems.
Step 1: Open the deployment model
Step 2: Add the previously modeled target
Step 3: Configure the login. For a local deployment, choose your local user name or leave it blank.
Step 4: Select the upload directory. This will define the deployment location, i.e. the directory where the binaries will be copied to.
Step 5: Select network interface
Step 6: The final platform to deploy to shall look as shown:
Step 7: Add a naming service and model its deployment to PC1. A naming service is a lookup directory that supports components in connecting to each other.
Step 8: Now add the component instances.
Step 9: Repeat this for all component instances.
Step 10: Add a deployment link from all artifacts (Naming Service and components) to the target platform. This will express that the software artifact will be deployed to the PC1. In this tutorial, we have only one target platform as we are using simulator.
Step 11: Now the last model of system modeling is complete. The system is ready for deployment.
Now sytem is ready for deployment. Right click on the project → Smartsoft Build Tools → Deploy.
You may need to build your components before deployment. Do this using “make” and “make all” from the “Smartsoft Build Tools” menu.
You can now start your system. To see how this works, please refer to Simple System: Laser Obstacle Avoid.
To see how to Deploy on a real robot, proceed with tutorial Deploying the Flexible Navigation Stack in Real World