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:

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

sudo apt install openjdk-11-jre

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

To install optional plugins like support for the AAS (Industry 4.0 Asset Administration Shell), Dependency Graphs, etc., please follow the instructions you can find here in the README.md file:

• Installation Instructions for additional Plugins
• Start with Step [2] Clone or Download the SmartDBE repository on your system

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

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

«To be updated later»

«To be updated later»

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   

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

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

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.

«To be updated later»

«To be updated later»

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.

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

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

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

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

DomainModels consist of CommunicationObjects, ServiceDefinitions, Parameters and StateDefinitions.

For more information see: DomainModels.

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

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”

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”

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

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.

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

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”

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”

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

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/
git clone https://github.com/Servicerobotics-Ulm/BehaviorRepository.git

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.

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

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

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

Have a look at the Tutorials.

Nayabrasul Shaik.