### Install Application with Start Menu Entry

Source: https://github.com/eclipse-ecal/ecal/blob/master/app/mon/mon_gui/CMakeLists.txt

Installs the application and defines its name in the start menu. This is typically used for end-user applications.

```cmake
ecal_install_app(${PROJECT_NAME} START_MENU_NAME "eCAL Monitor")
```

--------------------------------

### Project Configuration and Variable Setup

Source: https://github.com/eclipse-ecal/ecal/blob/master/thirdparty/cmakefunctions/cmake_functions/CMakeLists.txt

Sets up the minimum CMake version, includes custom functions, defines project name and version, and configures installation directories based on the compiler.

```cmake
cmake_minimum_required(VERSION 3.5)

include(cmake_functions.cmake)

project(CMakeFunctions VERSION 0.4.1)

include(GNUInstallDirs)
if (MSVC)
# Variable definitions
set(cmake_functions_install_cmake_dir   cmake)
else (MSVC)
set(cmake_functions_install_cmake_dir   "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}-${PROJECT_VERSION}")
endif (MSVC)
set(cmake_functions_config              ${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake)
set(cmake_functions_config_version      ${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake)
```

--------------------------------

### Install eCAL Sample

Source: https://github.com/eclipse-ecal/ecal/blob/master/ecal/samples/cpp/benchmarks/latency_snd/CMakeLists.txt

Use the ecal_install_sample macro to install the compiled sample. This makes the sample executable available in the installation directory.

```cmake
ecal_install_sample(${PROJECT_NAME})
```

--------------------------------

### Build Complete eCAL Setup on Windows

Source: https://github.com/eclipse-ecal/ecal/blob/master/build_win/Readme.md

Use this script to build a complete eCAL setup for Windows.

```bash
win_make_all.bat
```

--------------------------------

### CMake Project Setup for eCAL Sample

Source: https://github.com/eclipse-ecal/ecal/blob/master/serialization/string/samples/pubsub/hello_receive/CMakeLists.txt

This CMake script sets up a new project named 'hello_receive', finds the eCAL package, defines source files, and adds the sample target. It links against eCAL's string core library and sets the C++ standard to C++14. Finally, it installs the sample and sets its folder property.

```cmake
cmake_minimum_required(VERSION 3.15)

project(hello_receive)

find_package(eCAL REQUIRED)

set(hello_receive_src
    src/hello_receive.cpp
)

ecal_add_sample(${PROJECT_NAME} ${hello_receive_src})

target_link_libraries(${PROJECT_NAME} PRIVATE eCAL::string_core)

target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_14)

ecal_install_sample(${PROJECT_NAME})

set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER samples/cpp/pubsub/string)
```

--------------------------------

### Step-by-Step eCAL Build and Setup on Windows

Source: https://github.com/eclipse-ecal/ecal/blob/master/build_win/Readme.md

Execute these scripts sequentially for a step-by-step cmake, build, and setup process of eCAL on Windows.

```bash
win_make_cmake.bat
```

```bash
win_make_build.bat
```

```bash
win_make_install.bat
```

```bash
win_make_csharp.bat
```

```bash
win_make_setup.bat
```

--------------------------------

### Installing Project Files

Source: https://github.com/eclipse-ecal/ecal/blob/master/thirdparty/cmakefunctions/cmake_functions/CMakeLists.txt

Iterates through a list of files and installs them into the destination directory, preserving their subdirectory structure relative to the install prefix. This is used for installing source files or other project assets.

```cmake
foreach (f ${file_list})
  get_filename_component( dir ${f} DIRECTORY )
  install( FILES ${f} DESTINATION "${cmake_functions_install_cmake_dir}/${dir}" )
endforeach()
```

--------------------------------

### Install Qt 6 Deploy Script

Source: https://github.com/eclipse-ecal/ecal/blob/master/thirdparty/qwt/CMakeLists.txt

Installs the generated Qt 6 deployment script to the install directory.

```cmake
install(SCRIPT ${qt_deploy_script})
```

--------------------------------

### Command Line Build Options Example

Source: https://github.com/eclipse-ecal/ecal/blob/master/CMakeLists.txt

Demonstrates how to set build options via the command line using CMake. For example, to enable building apps and samples, use: cmake .. -DECAL_BUILD_APPS=ON -DECAL_BUILD_SAMPLES=ON.

```bash
cmake .. -DECAL_BUILD_APPS=ON -DECAL_BUILD_SAMPLES=ON
```

--------------------------------

### Installing Configuration Files

Source: https://github.com/eclipse-ecal/ecal/blob/master/thirdparty/cmakefunctions/cmake_functions/CMakeLists.txt

Installs the generated configuration files and the main CMake functions script to the specified installation directory. This makes the package discoverable by other CMake projects.

```cmake
install(FILES 
  "${cmake_functions_config}"
  "${cmake_functions_config_version}"
  "cmake_functions.cmake"
  DESTINATION "${cmake_functions_install_cmake_dir}"
)
```

--------------------------------

### Qt 5 DLL Deployment Installation Script

Source: https://github.com/eclipse-ecal/ecal/blob/master/thirdparty/qwt/CMakeLists.txt

An installation script for Qt 5 that uses `windeployqt` to copy necessary DLLs to the install bin directory. It dynamically determines the `windeployqt` executable path and uses `cmake -E copy` for deployment.

```cmake

            set(_file ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Release/qwt.dll)
            execute_process(
                    COMMAND "${CMAKE_COMMAND}" -DQT_DEPLOY_PREFIX=$<TARGET_FILE_DIR:${PROJECT_NAME}> -DQT_DEPLOY_BIN_DIR=. -P ${qt_deploy_script}
                    COMMAND "${CMAKE_COMMAND}" -E
                        env PATH="${_qt_bin_dir}" "${WINDEPLOYQT_EXECUTABLE}"
                            --dry-run
                            --no-compiler-runtime
                            --no-angle
                            --no-opengl-sw
                            --list mapping
                            
                    OUTPUT_VARIABLE _output
                    OUTPUT_STRIP_TRAILING_WHITESPACE
                )
            separate_arguments(_files WINDOWS_COMMAND ${_output})
            while(_files)
                    list(GET _files 0 _src)
                    list(GET _files 1 _dest)
                    execute_process(
                        COMMAND "${CMAKE_COMMAND}" -E
                            copy ${_src} "${CMAKE_INSTALL_PREFIX}/bin/${_dest}"
                    )
                    list(REMOVE_AT _files 0 1)
            endwhile()
            
```

--------------------------------

### Install Generated Documentation

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/CMakeLists.txt

Use this command to install generated documentation files to a specified destination. Ensure the source directory and destination path are correctly defined.

```cmake
install(DIRECTORY ${SPHINX_HTML_DIR}/
  DESTINATION ${eCAL_install_doc_dir}
  COMPONENT doc 
)
```

--------------------------------

### Install Python Requirements and Esbonio on Windows

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/advanced/documentation.md

Installs the 'wheel' and 'esbonio' Python packages, followed by project-specific requirements from 'doc/requirements.txt'.

```batch
pip install wheel esbonio
pip install -r doc/requirements.txt
```

--------------------------------

### Install Build Tools and Build Python Wheel

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/development/building_ecal_from_source.md

Execute these commands from the main project directory to install the required Python build tools and then build the Python wheel. Ensure you have Python 3.8 or newer installed.

```bash
python -m pip install build setuptools wheel
```

```bash
python -m build .
```

--------------------------------

### Install Library

Source: https://github.com/eclipse-ecal/ecal/blob/master/ecal/core_pb/CMakeLists.txt

Installs the compiled library to the appropriate location in the build system.

```cmake
ecal_install_library(${PROJECT_NAME})
```

--------------------------------

### Example C# Core Sample Build

Source: https://github.com/eclipse-ecal/ecal/blob/master/lang/csharp/Eclipse.eCAL.Core.Samples/monitoring/CMakeLists.txt

This is an example of how to use the ecal_add_csharp_core_sample macro to add a specific sample named 'monitoring_class_rec_csharp'.

```cmake
ecal_add_csharp_core_sample(monitoring_class_rec_csharp)
```

--------------------------------

### Start Tasks with Configuration

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/applications/sys/sys_cli.md

Loads a specified .ecalsys configuration file and starts all tasks defined within it. The CLI will terminate after the command is executed.

```bash
ecal_sys -c ~/tutorial.ecalsys --start
```

--------------------------------

### Build and Install eCAL C Sample

Source: https://github.com/eclipse-ecal/ecal/blob/master/lang/c/samples/misc/cake_send/CMakeLists.txt

This CMakeLists.txt file configures the build process for a C sample project using eCAL. It finds the eCAL package, adds the sample source files, links against the eCAL C core library, and specifies installation targets. Ensure eCAL is installed and discoverable by CMake.

```cmake
cmake_minimum_required(VERSION 3.15)


project(cake_send_c)

find_package(eCAL REQUIRED)

remove_definitions(-std=c++14)

set(cake_send_c_src
    src/cake_send_c.c
)

ecal_add_sample(${PROJECT_NAME} ${cake_send_c_src})

target_include_directories(${PROJECT_NAME} PRIVATE .)

target_link_libraries(${PROJECT_NAME} PRIVATE eCAL::core_c)

target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_14)

ecal_install_sample(${PROJECT_NAME})

set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER samples/c/misc/cake_send)
```

--------------------------------

### Start eCAL Person Sender (Windows)

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/getting_started/samples.md

Execute this command on Windows to start the eCAL sample application that publishes data to the 'person' topic.

```bash
C:\eCAL\samples\bin\ecal_sample_person_send.exe
```

--------------------------------

### Install Python and Pip on Ubuntu

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/advanced/documentation.md

Installs Python 3, pip, and wheel on Ubuntu systems. Ensure Python 3.7 or higher is used.

```bash
sudo apt install python3 python3-pip python3-wheel
```

--------------------------------

### Install Conan Dependencies

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/development/building_ecal_with_conan_dependencies.md

Installs all project dependencies defined in conanfile.py using the specified Conan profile. The `--build missing` flag is crucial for building dependencies like Qt from source.

```bat
mdkir _build
cd _build
conan install .. --profile <your-profile> --build missing
```

--------------------------------

### Doxygen Project and Path Settings

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/CMakeLists.txt

Sets Doxygen project name, brief description, example path, and file patterns for documentation generation. Recursive search for examples is enabled.

```cmake
set(DOXYGEN_PROJECT_NAME         "eCAL API")
set(DOXYGEN_PROJECT_BRIEF        "enhanced communication abstraction layer")
set(DOXYGEN_EXAMPLE_PATH         ../samples)
set(DOXYGEN_EXAMPLE_RECURSIVE    YES)
set(DOXYGEN_FILE_PATTERNS        "*.h")
set(DOXYGEN_RECURSIVE            NO)
set(DOXYGEN_OUTPUT_DIRECTORY     ${DOC_SOURCE_DIRECTORY})
set(DOXYGEN_XML_OUTPUT           ${DOC_SOURCE_DIRECTORY}/_doxygen)
set(DOXYGEN_DISTRIBUTE_GROUP_DOC NO)
```

--------------------------------

### Install eCAL Launcher Application

Source: https://github.com/eclipse-ecal/ecal/blob/master/app/util/launcher/CMakeLists.txt

Installs the eCAL Launcher application with a specified Start Menu name.

```cmake
ecal_install_app(${PROJECT_NAME} START_MENU_NAME "eCAL Launcher")
```

--------------------------------

### Create and Run eCAL Service Server

Source: https://github.com/eclipse-ecal/ecal/blob/master/ecal/service/Readme.md

Illustrates how to set up an eCAL service server. Requires an io_context and a ServerManager. Callbacks handle service requests and events. Ensure the io_context thread is joined after stopping servers.

```cpp
#include <ecal/service/server_manager.h>
#include <iostream>
#include <thread>
#include <chrono>

int main(int argc, char** argv)
{
  // Create an io_context
  auto io_context = std::make_shared<asio::io_context>();

  // Create a server manager
  auto server_manager = eCAL::service::ServerManager::create(io_context);

  // Create and start an io_context thread.
  // The io_context will be stopped, when the server_manager is stopped.
  std::thread io_context_thread([&io_context]() { io_context->run(); });

  // Server Service callback
  // 
  // This callback will be called, when a client calls the service.
  // It is responsible for filling the response object.
  auto server_service_callback
          = [](const std::shared_ptr<const std::string>& request, const std::shared_ptr<std::string>& response) -> void
            {
                *response = "Response on \"" + *request + "\"";
            };

  // Event callback (empty)
  auto server_event_callback = [](eCAL::service::ServerEventType /*event*/, const std::string& /*message*/) {};

  // Create server on port 1589
  auto server = server_manager->create_server(1, 1589, server_service_callback, true, server_event_callback);

  // Just don't exit
  while(true)
  {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }

  // Use managers to stop servers and clients
  server_manager->stop_servers();

  // Join the io_context thread
  io_context_thread.join();
}
```

--------------------------------

### Python Virtual Environment Setup (Commented Out)

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/CMakeLists.txt

These commented-out lines show how to set up and use a Python virtual environment for the documentation build. This ensures isolated dependencies.

```cmake
#Setup Python VENV
# find_package(PythonInterp REQUIRED)

# set(PYTHON_VENV_PATH "${CMAKE_BINARY_DIR}/_python_venv")

# message(STATUS "Creating Python venv at ${PYTHON_VENV_PATH}")
# exec_program("${PYTHON_EXECUTABLE}"
    # ARGS -m venv ${PYTHON_VENV_PATH}
# )

# update the environment with VIRTUAL_ENV variable (mimic the activate script)
# set (ENV{VIRTUAL_ENV} "${PYTHON_VENV_PATH}")
# change the context of the search
# set (Python_FIND_VIRTUALENV FIRST)
# unset Python3_EXECUTABLE because it is also an input variable (see documentation, Artifacts Specification section)
# unset (Python3_EXECUTABLE)
# Launch a new search
# find_package(PythonInterp REQUIRED)

# message(STATUS "========Python executable: ${PYTHON_EXECUTABLE}")
```

--------------------------------

### Install GTest Target

Source: https://github.com/eclipse-ecal/ecal/blob/master/lib/ecal_utils/tests/CMakeLists.txt

Installs the configured Google Test target. This makes the test executable available after installation.

```cmake
ecal_install_gtest(ecal-utils-test)
```

--------------------------------

### Migrate Service Client Initialization (eCAL 5 to eCAL 6)

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/versions/6.0/migration_guide.md

Example showing the migration of service client initialization from eCAL 5 to eCAL 6, including event callback handling.

```cpp
#include <ecal/ecal_client.h>

// ...

eCAL::CServiceClient client("service_name");

client.AddEventCallback(eCAL_Client_Event::client_event_connected, [](const char * name_, const struct eCAL::SClientEventCallbackData * data_) {
  // Process event data
});

std::vector<eCAL::SServiceResponse> responses;
client.Call("method_name", "request_payload", 1000, &responses);

// ...
```

```cpp
#include <ecal/service/client.h>

// ...

eCAL::CServiceClient client("service_name", eCAL::ServiceMethodInformationSetT(), [](const eCAL::SServiceId& service_id_, const struct eCAL::SClientEventCallbackData& data_) {
  // Process event data
});

eCAL::ServiceResponseVecT responses;
client.CallWithResponse("method_name", "request_payload", responses, 1000);

// ...
```

--------------------------------

### Install Python 3 on Ubuntu

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/getting_started/howto/setup/python.md

Installs Python 3 and pip on Ubuntu systems. Ensure Python is installed before proceeding with eCAL integration.

```bash
sudo apt install python3 python3-pip
```

--------------------------------

### Mirror Server Implementation

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/getting_started/howto/clientserver/binary_mirror.md

Sets up an eCAL service server that provides 'echo' and 'mirror' methods. Requires eCAL initialization and method callback registration.

```cpp
// This is a placeholder for the actual C++ code. The source only provides a file path.
```

```c
// This is a placeholder for the actual C code. The source only provides a file path.
```

```csharp
// This is a placeholder for the actual C# code. The source only provides a file path.
```

```python
# This is a placeholder for the actual Python code. The source only provides a file path.
```

```python
# This is a placeholder for the actual Python (legacy) code. The source only provides a file path.
```

--------------------------------

### Install Python Library Files

Source: https://github.com/eclipse-ecal/ecal/blob/master/lang/python/src/msg/CMakeLists.txt

Installs the Python message files to the 'ecal' destination for the 'python' component. This is typically done to make the library available for use after installation.

```cmake
install(TARGETS python_msg
  FILE_SET python_msg_files DESTINATION ecal COMPONENT python EXCLUDE_FROM_ALL
)
```

--------------------------------

### Example Input/Output Path Specification

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/applications/meas_cutter/meas_cutter.md

Demonstrates how to specify multiple input and output paths for processing several measurements simultaneously. Ensure a one-to-one correspondence between input and output paths.

```bash
Example: -i measurement_1 -o output_measurement_1 -i measurement_2 -o output_measurement_2
```

--------------------------------

### Project and Qt Configuration

Source: https://github.com/eclipse-ecal/ecal/blob/master/app/mon/mon_plugins/string_reflection/CMakeLists.txt

Sets up the CMake project, finds Qt packages (Core and Widgets), and enables automatic handling of Qt meta-object, user interface, and resource files.

```cmake
project(mon_plugin_string_reflection VERSION 0.1.0)

# Legacy Qt5 (pre 5.15) support as suggested by teh Qt Documentation:
# https://doc.qt.io/qt-6/cmake-qt5-and-qt6-compatibility.html#supporting-older-qt-5-versions
find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core Widgets)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core Widgets)

set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC OFF) # Reason for being turned off: AutoUIC will prevent VS from detecting changes in .ui files
set(CMAKE_AUTORCC OFF) # Reason for being turned off: AutoRCC will create an entirely new project in VS which clutters the solution appearance. Additionally, we cannot assign a source group to the generated .cpp files which will clutter the project.
set(CMAKE_INCLUDE_CURRENT_DIR ON)
```

--------------------------------

### Installing GTest and Source Grouping

Source: https://github.com/eclipse-ecal/ecal/blob/master/ecal/tests/cpp/clientserver_test/CMakeLists.txt

Installs the Google Test target and defines source groups for better organization within IDEs. This ensures test executables are properly installed.

```cmake
ecal_install_gtest(${PROJECT_NAME})

set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER tests/cpp/service)

source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES 
    ${${PROJECT_NAME}_src}
)
```

--------------------------------

### C++ Blob Publisher Example

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/getting_started/howto/pubsub/binary_blob.md

This C++ snippet demonstrates how to initialize eCAL, create a binary blob publisher, and send messages in a loop. Ensure eCAL is initialized before creating the publisher and finalized when done.

```cpp
#include <ecal/ecal.h>
#include <ecal/core/core.h>

#include <iostream>
#include <thread>
#include <chrono>
#include <vector>
#include <random>

int main(int argc, char **argv)
{
    // Initialize eCAL API
    std::string process_name = "ecal_blob_sender_cpp";
    if (!ecal::Initialize(argc, argv, process_name.c_str())) {
        return -1;
    }

    // Create a publisher on the topic "blob_data"
    std::shared_ptr<eCAL::CPublisher> pub = eCAL::CFactory::CreatePublisher(
```

```cpp
blob_data");

    if (!pub) {
        std::cerr << "Could not create publisher!" << std::endl;
        return -1;
    }

    // Generate random data
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> distrib(33, 126); // Printable ASCII characters

    // Send messages in a loop
    while (eCAL::Ok())
    {
        // Generate random blob size between 100 and 1000 bytes
        std::uniform_int_distribution<> size_distrib(100, 1000);
        size_t blob_size = size_distrib(gen);

        // Create and fill the blob
        std::vector<char> blob(blob_size);
        for (size_t i = 0; i < blob_size; ++i) {
            blob[i] = static_cast<char>(distrib(gen));
        }

        // Send the blob
        if (pub->Send(blob.data(), blob.size())) {
            // Optional: print confirmation or data size
            // std::cout << "Sent blob of size: " << blob.size() << std::endl;
        } else {
            std::cerr << "Failed to send blob!" << std::endl;
        }

        // Wait for 500 ms
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }

    // Finalize eCAL API
    ecal::Finalize();

    return 0;
}
```

--------------------------------

### Interactive Program Startup Notice (GPL)

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/license/thirdparty_licenses/qt.md

Display this notice when a program starts in interactive mode to inform users about its free software status, warranty, and redistribution conditions.

```text
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
```

--------------------------------

### eCAL Monitoring Plugin Installation

Source: https://github.com/eclipse-ecal/ecal/blob/master/app/mon/mon_plugins/string_reflection/CMakeLists.txt

Installs the monitoring plugin using the eCAL macro.

```cmake
ecal_install_mon_plugin(${PROJECT_NAME})
```

--------------------------------

### Tutorial System File

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/getting_started/sys.md

This is a system configuration file for eCAL, typically used for tutorials. It defines tasks and their execution parameters. Ensure hostnames and paths are valid for your environment.

```default
<i class="far fa-file-alt"></i> [`tutorial.ecalsys`](files/tutorial.ecalsys)
```

--------------------------------

### Build Mirror Server C Sample with CMake

Source: https://github.com/eclipse-ecal/ecal/blob/master/lang/c/samples/services/mirror_server_c/CMakeLists.txt

This CMakeLists.txt file configures the build for the mirror_server_c sample. It finds the eCAL package, specifies source files, and links against the eCAL core C library. Ensure eCAL is installed and discoverable by CMake.

```cmake
cmake_minimum_required(VERSION 3.15)


project(mirror_server_c)

find_package(eCAL REQUIRED)

remove_definitions(-std=c++14)

set(mirror_server_c_src
    src/mirror_server_c.c
)

ecal_add_sample(${PROJECT_NAME} ${mirror_server_c_src})
target_include_directories(${PROJECT_NAME} PRIVATE .)

target_link_libraries(${PROJECT_NAME} PRIVATE eCAL::core_c)

target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_14)

ecal_install_sample(${PROJECT_NAME})

set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER samples/c/services)
```

--------------------------------

### Install Python Requirements and Esbonio on Ubuntu

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/advanced/documentation.md

Installs project-specific Python requirements and the 'esbonio' package using pip3.

```bash
sudo pip3 install -r doc/requirements.txt
sudo pip3 install esbonio
```

--------------------------------

### Configure MMA Startup Application on Linux

Source: https://github.com/eclipse-ecal/ecal/blob/master/app/mma/README.md

Steps to add the MMA as a startup application on Linux using the Startup Applications utility. Specify the name, command, and a brief comment for the entry.

```bash
Name: Machine Monitoring Agent
Command: /usr/local/bin/mma
Comment: Machine monitoring task.
```

--------------------------------

### Install Google Test Target

Source: https://github.com/eclipse-ecal/ecal/blob/master/ecal/tests/cpp/monitoring_test/CMakeLists.txt

Installs the 'test_monitoring' Google Test target using eCAL's CMake functions.

```cmake
ecal_install_gtest(test_monitoring)
```

--------------------------------

### Initialize Service Client (eCAL 5)

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/versions/6.0/migration_guide.md

Use this constructor if you only need to set the service name. For more advanced setup, use the new constructor with method information and event callbacks.

```cpp
eCAL::CServiceClient("service_name");
```

--------------------------------

### Install eCAL Dependencies on Ubuntu 22.04

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/development/building_ecal_from_source.md

Install necessary build dependencies for eCAL on Ubuntu 22.04 using apt-get.

```bash
sudo apt-get install git cmake doxygen graphviz build-essential zlib1g-dev qtbase5-dev libhdf5-dev libprotobuf-dev libprotoc-dev protobuf-compiler libcurl4-openssl-dev libyaml-cpp-dev
```

--------------------------------

### Create hello_write Measurement Sample

Source: https://github.com/eclipse-ecal/ecal/blob/master/serialization/string/samples/measurement/CMakeLists.txt

Example of using the `create_measurement_sample` macro to define the 'hello_write' sample.

```cmake
create_measurement_sample(hello_write  hello_write.cpp)
```

--------------------------------

### Install eCAL Dependencies on Ubuntu 24.04

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/development/building_ecal_from_source.md

Install necessary build dependencies for eCAL on Ubuntu 24.04 using apt-get.

```bash
sudo apt-get install git cmake doxygen graphviz build-essential zlib1g-dev qt6-base-dev qt6-svg-dev libhdf5-dev libprotobuf-dev libprotoc-dev protobuf-compiler libcurl4-openssl-dev libyaml-cpp-dev
```

--------------------------------

### Start eCAL Sample Sender

Source: https://github.com/eclipse-ecal/ecal/blob/master/doc/rst/advanced/ecal_in_docker.md

Executes a sample eCAL application within the container to test communication.

```bash
ecal_sample_person_snd
```

--------------------------------

### Create hello_read Measurement Sample

Source: https://github.com/eclipse-ecal/ecal/blob/master/serialization/string/samples/measurement/CMakeLists.txt

Example of using the `create_measurement_sample` macro to define the 'hello_read' sample.

```cmake
create_measurement_sample(hello_read   hello_read.cpp)
```

--------------------------------

### Install eCAL on Ubuntu

Source: https://github.com/eclipse-ecal/ecal/blob/master/README.md

Installs the latest eCAL release from the official PPA. Ensure your Ubuntu version and architecture are supported.

```bash
sudo add-apt-repository ppa:ecal/ecal-latest
sudo apt-get update
sudo apt-get install ecal
```