SRRC Wiki

Service Robotics Research Center
at Ulm University of Applied Sciences

User Tools

Site Tools


installer:start

Table of Contents

Installation of the SmartSoft World

The virtual appliance is the recommended standard way of using everything. See Ready-To-Go Virtual Appliances for download and installation.

See also Getting Started Guide for guidance on different entry points.

This is a step-by-step guide for installing the SmartSoft World. This installation guide sets up a complete software development environment with all the required runtime infrastructure and comes with plenty of domain models, software components and even ready-to-run applications and it also comes with simulators. This installation is fully based on Open Source.

The following table lists the current recommendations for the operating system, the SmartMDSD Toolchain and the Java Runtime Environment:

Software Version
Ubuntu 20.04
SmartMDSD Toolchain v3.17
Java Runtime Environment (JRE) 11
Hardware Version
Architecture x86(-64), ARM/RaspberryPi with experimental support
Memory > 8 GB (sufficient to run systems)
Disk Space > 1 GB (considers only ACE and the SmartSoft Kernel)
+500 MB SmartMDSD Toolchain
+3.5 GB Repos after build
Graphics Card required for running the systems with the Webots simulator

Step 1: Prepare the Folder Structure and the Environment Variables

mkdir -p ~/SOFTWARE/smartsoft/repos
echo "export SMART_ROOT_ACE=\$HOME/SOFTWARE/smartsoft" >> ~/.profile
source ~/.profile
 
echo "export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:\$SMART_ROOT_ACE/lib" >> ~/.bashrc
source ~/.bashrc

Step 2: Install the Java Development Kit

sudo apt install openjdk-11-jre

Step 3: Get the SmartMDSD Toolchain IDE

To install the SmartMDSD Toolchain IDE, please follow the SmartMDSD Toolchain Installation instructions.

Step 4: Install a Middleware

In this step, we install the communication middleware that is used to exchange the information between the SmarSoft ports.

Option A: Installing ACE Middleware

ACE is the currently recommended middleware.

On Ubuntu 20.04, ACE is available as debian package.

sudo apt install libace-6.4.5
sudo apt install libace-dev

Option B: Installing RTI-DDS Middleware

«To be updated later»

Option C: Installing OPC-UA Middleware

«To be updated later»

Step 5: Install the Build Dependencies

Install the dependencies that are required to build the SmartSoftComponentDeveloperAPIcpp, AceSmartSoftFramework, Open62541CppWrapper, Utilities, Domain Models, Components.

sudo apt-get -y --force-yes install bison build-essential cmake cmake-curses-gui cl-cffi doxygen \
                   expect flex freeglut3-dev git htop lib3ds-dev libavformat-dev \
                   libboost-all-dev libdc1394-22-dev libeigen3-dev libftdi-dev \
                   libglew-dev libgtest-dev libjansson-dev libjpeg-dev \
                   libopencv-dev libswscale-dev libtbb-dev libusb-1.0-0-dev \
                   libxml2-dev libxml++2.6-dev libzmq3-dev nlohmann-json3-dev pkg-config sbcl ssh \
                   ssh-askpass sshfs subversion tree vim wmctrl xterm zlib1g-dev zlibc
 
# mrpt libraries required to compile some of the components
# Install mrpt from its own ppa
# Refer : https://docs.mrpt.org/reference/latest/download-mrpt.html
	sudo add-apt-repository ppa:joseluisblancoc/mrpt
	sudo apt-get update
	sudo apt-get install libmrpt-dev mrpt-apps   

Step 6: Build and Install the SmartSoftComponentDeveloperAPIcpp

This repository contains the Component Developer C++ Interface Definition (API) for use of the SmartSoft framework. This repository covers the API to the SmartSoft Communication Patterns and the SmartSoft Component structures.

For more information see: SmartSoft Component-Developer API for C++.

cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/SmartSoftComponentDeveloperAPIcpp.git
cd SmartSoftComponentDeveloperAPIcpp/
mkdir build
cd build/
cmake ..
make
make install

Step 7: Build and Install the SmartSoft Kernel for the Used Middleware

In this step, we install the SmartSoft Kernel corresponding to the communication middleware installed in Step 4.

Option A: SmartSoft Kernel for ACE Middleware

If you choose ACE as the middleware (see Step 4), we install the SmartSoft kernel for ACE i.e AceSmartSoftFramework.

For more information see: ACE/SmartSoft Framework.

#Build and Install AceSmartSoftFramework
cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/AceSmartSoftFramework.git
cd AceSmartSoftFramework/
mkdir build
cd build/
cmake ..
make install

A simple way to test your installation is as follows. Type the following commands in a terminal:

cd $SMART_ROOT_ACE                 # cd into installation directory
./startSmartSoftNamingService      # start the naming service
xterm -e bin/exampleComponent01 &  # start a component in a terminal window
xterm -e bin/exampleComponent02 &  # start another component in another terminal window

Upon successful installation of the SmartSoft Kernel for ACE, the above bash commands launch two example components exchanging data and you will see messages in both terminals (see figure below). Type CTRL+C to quit the components.

Option B: SmartSoft Kernel for RTI-DDS Middleware

«To be updated later»

Option C: SmartSoft Kernel for OPC-UA Middleware

«To be updated later»

Step 8: Installation of the OPC UA Library

This step is required ONLY if you want to use plain OPC UA ports in the components. Plain OPC UA ports are used to communicate with OPC UA devices. It is strongly recommended to install the OPC UA Library.

Step 8a - Optional: Install googletest

cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/google/googletest.git
cd googletest
mkdir build && cd build
cmake .. -DBUILD_SHARED_LIBS=ON -DINSTALL_GTEST=ON -DCMAKE_INSTALL_PREFIX:PATH=/usr
make -j8
sudo make install
sudo ldconfig

Step 8b: Install open62541

sudo apt-get install git build-essential g++ pkg-config cmake python python-six
cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/open62541/open62541.git
cd open62541
git checkout 1.0
git submodule init
git submodule update
mkdir build && cd build/
cmake -DUA_BUILD_EXAMPLES=ON -DUA_ENABLE_DISCOVERY_MULTICAST=ON -DBUILD_SHARED_LIBS=ON ..
make
sudo make install

Step 8c: Install Open62541CppWrapper

cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/Open62541CppWrapper.git
cd Open62541CppWrapper
mkdir build && cd build/
cmake ..
sudo make install
sudo ldconfig
#test the OPC UA by running the following example
./examples/SimpleServer/SimpleServer

For more information see: Open62541CppWrapper Library

Step 9: Clone, Build and Install the UtilityRepository

The UtilityRepository contains utilities (e.g. XML parser, transformationMatrices) used by DomainModels and Components.

cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/UtilityRepository.git
cd UtilityRepository
mkdir build && cd build
cmake ..
make

Step 10: Clone and Build the Domain Model Repositories

DomainModels consist of CommunicationObjects, ServiceDefinitions, Parameters and StateDefinitions.

For more information see: DomainModels.

Step 10a: Clone the Domain Models

cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/DomainModelsRepositories.git
cd DomainModelsRepositories

Step 10b: Code Generation for a Domain Model

We use the toolchain to generate the code from the domain models. This generated code provides the software infrastructure for the CommunicationObjects, ServiceDefinitions, Parameters and StateDefinitions defined in the domain model.

The folder and content of src-gen is auto-generated. It is overwritten each time you run the code generation. So users must not modify anything in this folder. All the user contributions are always to be done in the folders without the \*-gen extension.

This step is needed only when there is a change in the model i.e any file inside the model folder of domain model project.

To generate code for a given domain model follow these steps:

  • Start the Toolchain
  • Select the Domain Expert (Tier 2) perspective
  • Import the Domain Model project
  • Right click on the project and select “Run Code-Generation”

Step 10c - Option 1: Building a Domain Model Project with the Toolchain

After having executed the code generation for a domain model project, you can build it via the toolchain as follows:

  • Right click on the project and select “Build Project”

Step 10c - Option 2: Building a Domain Model Project from Command Line in a Terminal Window

After having executed the code generation for a domain model project, you can also use cmake in a command line within a terminal window to build a particular domain:

#goto < DomainModel Name>/smartsoft/
cd ~/SOFTWARE/smartsoft/repos/DomainModelsRepositories/CommBasicObjects/smartsoft
#create build folder
mkdir build
cd build
cmake -DBUILD_DEPENDENCIES=OFF ..
make

Step 11: Clone and Build Components

This step clones the open source component repository of the Servicerobotics Ulm research group and builds those components. See the README.md files in the individual component subfolders for a detailed explanation of the individual component's services and configurations options.

For more information on the component repository of the Servicerobotics Ulm research group see: ComponentRepository.

Step 11a: Clone the Component Repositories

#clone the Components
cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/ComponentRepository.git

Step 11b: Code Generation for a Component

We use the toolchain to generate the code from the component model. See the tutorial Develop Your First Software Component for more information on code generation for a component.

To generate code for a given component follow these steps:

  • Start the Toolchain
  • Select the Component Supplier (Tier 3) perspective
  • Import the Component project
  • Right click on the project and select “Run Code-Generation”

Step 11c - Option 1: Building a Component Project with the Toolchain

After having executed the code generation for a component model project, you can build it via the toolchain as follows:

  • Right click on the project and select “Build Project”

Step 11c - Option 2: Building a Component Project from Command Line in a Terminal Window

After having executed the code generation for a component model project, you can also use cmake in a command line within a terminal window to build a particular component. Make sure that the 3rd party/external libraries required by a component are already installed. Components contain an Install.txt file which describes how to install required 3rd party/external libraries if this applies.

Below code snippet builds the component ComponentKB:

#goto < Component Name>/smartsoft/
cd ~/SOFTWARE/smartsoft/repos/ComponentRepository/ComponentKB/smartsoft
 
#create build folder
mkdir build
cd build
cmake -DBUILD_DEPENDENCIES=OFF ..
make

Step 12: Cloning the Behavior Repository

This step clones the open source behavior repository of the Servicerobotics Ulm research group. The behavior repository contains task level behavior projects and models. For more information on creating a Behavior Project and adding Behaviors to a system project, refer the tutorials Realizing Tasks in Behavior Project and Adding Behavior to a System Project.

cd ~/SOFTWARE/smartsoft/repos/
https://github.com/Servicerobotics-Ulm/BehaviorRepository.git

Step 13: Cloning the System Repository

This step clones the open source system repository of the Servicerobotics Ulm research group. The system repository contains ready-to-use, deployable and executable systems that are composed out of readily available components and behaviors.

cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/SystemRepository.git

To deploy and execute a particular system, follow these steps:

  • Start the Toolchain
  • Select the System Builder (Tier 3) perspective
  • Import the System project
  • Make sure that Components and Behavior used in the system are already imported in the respective perspectives.
  • Right click on the project and select “Run Code-Generation”
  • Right click on the project and select “Deployment Action”

For more information on deploying and executing a system, please refer to the tutorial System Deployment and Execution.

Step 14: Cloning the Data Repository

The data repository contains additional data that is required by some components or systems. For example, it includes models and environments for simulators (e.g. for use with Webots and Gazebo simulators). You can skip this step if you don't intend to use the Webots and/or Gazebo simulators.

cd ~/SOFTWARE/smartsoft/repos/
git clone https://github.com/Servicerobotics-Ulm/DataRepository.git

Step 15: Using the Webots Simulator with SmartSoft

To install Webots and use it with SmartSoft, see README.md of ComponentWebots.

Step 16: Using the Gazebo Simulator with SmartSoft

To install Gazebo and use it with SmartSoft, see INSTALL.txt of SmartGazeboBaseServer.

Next Step

Have a look at the Tutorials.

Acknowledgments

Nayabrasul Shaik.

installer/start.txt · Last modified: 2021/11/18 21:47 by Christian Schlegel