OpenDLV - A modern microservice-based software ecosystem for self-driving vehicles.
chrberger * Bumping to v0.0.39
Signed-off-by: Christian Berger <christian.berger@gu.se>
Latest commit a34425e Sep 7, 2018
Permalink
Failed to load latest commit information.
cluon-livefeed @ 3982b35 * Update to libcluon v0.0.104 Jul 16, 2018
cluon-rec2fuse @ fafc4e4 * Update to libcluon v0.0.104 Jul 16, 2018
opendlv-device-camera-opencv @ 23c99f0 * Updates due to libcluon v0.0.108 updates Aug 14, 2018
opendlv-device-camera-rpi @ 4eb6275 * Updates due to libcluon v0.0.108 updates Aug 14, 2018
opendlv-device-camera-v4l @ e5f61ad * Updates due to libcluon v0.0.108 updates Aug 14, 2018
opendlv-device-gps-ncom @ 7788da2 * Updated versions Jul 28, 2018
opendlv-device-gps-nmea @ 494bb68 * Update to libcluon v0.0.104 Jul 16, 2018
opendlv-device-gps-pos @ bd1c7e7 * Update to libcluon v0.0.104 Jul 16, 2018
opendlv-device-lidar-hdl32e @ 70128ba * Update to libcluon v0.0.104 Jul 16, 2018
opendlv-device-lidar-vlp16 @ 2c3343d * Update to libcluon v0.0.104 Jul 16, 2018
opendlv-device-lidar-vlp32c @ 6b5068e * Renaming HDL32c to VLP32c Sep 7, 2018
opendlv-device-ps3controller @ 16ad892 * Updates Jul 31, 2018
opendlv-device-ultrasonic-srf08 @ dca02e1 * Update to libcluon v0.0.104 Jul 16, 2018
opendlv-signal-viewer @ e35155c * Update to signal viewer for newest OpenDLV SMS Jul 2, 2018
opendlv-standard-message-set @ bd5007e * Renaming HDL32c to VLP32c Sep 7, 2018
opendlv-vehicle-view @ 372ebbd * Bumping to v0.0.39 Sep 7, 2018
opendlv-video-h264-decoder @ 8bba2c0 * Updates due to libcluon v0.0.108 updates Aug 14, 2018
opendlv-video-h264-encoder @ 6b8ca0a * Updates due to libcluon v0.0.108 updates Aug 14, 2018
opendlv-video-vpx-decoder @ 1e268ad * Updates due to libcluon v0.0.108 updates Aug 14, 2018
opendlv-video-vpx-encoder @ 55ffcaf * Updates due to libcluon v0.0.108 updates Aug 14, 2018
opendlv-video-x264-encoder @ 3b7f4d4 * Updates due to libcluon v0.0.108 updates Aug 14, 2018
rec2csv-png @ 660a688 * Updating OpenDLV Vehicle View to v0.0.34 Aug 29, 2018
.gitignore * Updated .gitignore Oct 13, 2016
.gitmodules * Renaming HDL32c to VLP32c Sep 7, 2018
.travis.yml * Removed FUSE and ncurses interface Jul 17, 2018
CMakeLists.txt * Added Velodyne VLP16 Feb 26, 2018
LICENSE * Preparing the new opendlv meta repository Feb 24, 2018
README.md * Bumping to v0.0.39 Sep 7, 2018

README.md

OpenDLV - A modern microservice-based software ecosystem for self-driving vehicles.

OpenDLV is a modern open source software environment to support the development and testing of self-driving vehicles driven by the following design principles:

  • Implemented using high quality and modern C++14 with a strong focus is on code clarity, portability, and performance.
  • Based entirely on microservices.
  • Strong focus on deployment and ease of use: All our microservices are automatically built on Docker hub: We provide turn-key solutions with Docker images for amd64, armhf, and aarch64
  • Realized with libcluon - the world's first and only single-file, header-only middleware for distributed systems for robotic applications.
  • CI-Status: Build Status
  • License: License: GPLv3

Table of Contents

What is an OpenDLV session?

Applications based on OpenDLV are grouped in UDP multicast sessions belonging to IPv4 address 225.0.0.X, where X is from the within the range [1,254]. All microservices belonging to the same UDP multicast group are able to communicate with each other; thus, two applications running in different UDP multicast sessions do not see each other and are completely separated.

The actual UDP multicast session is selected using the commandline parameter --cid=111, where 111 would define the UDP multicast address 225.0.0.111. Microservices exchange data using the message Envelope that contains besides the actual message to send further meta information like sent and received timestamp and the point in time when the contained message was actually sampled. All messages are encoded in Google's Protobuf data format (example) that has been adjusted to preserve forwards and backwards compatibility using libcluon's native implementation of Protobuf.

An Envelope contains in its field serializedData the actually message to be exchanged that is encoded in Protobuf. Furthermore, the Envelope itself is also encoded in Protobuf but prepended with the byte sequence 0x0D 0xA4 as magic number, followed by three bytes 0xXX 0xYY 0xZZ describing the length in bytes of the Protobuf-encoded Envelope. The sequence 0xA4 0xXX 0xYY 0xZZ is encoded in little endian and 0xZZ is usually 0 in practice.

As participants in a UDP multicast session automatically receive any exchanged Envelopes, a receiver can differentiate what message to expect by checking Envelope's field dataType, which is referring to a message identifier (for instance, Envelope's message identifier is 1).

OpenDLV's microservices conform to the OpenDLV Standard Message Set that enables exchangeability across hardware/software interfaces to decouple high-level application logic from low-level device drivers. For instance, OpenDLV's hardware/software interface to access an Applanix GPS unit is called opendlv-device-gps-pos according to Applanix' internal data format POS that is used across several units in their product portfolio. The microservice opendlv-device-gps-pos provides GPS information in messages GeodeticWgs84Reading and GeodeticHeadingReading.

As the microservices for the various GPS units (like, for instance Trimble and Applanix) all broadcast the aforementioned messages, the hardware units can be exchanged transparently for the high-level application logic. However, when several GPS units shall be operated in parallel, it is necessary to distinguish between them. Therefore, the commandline parameter --id=Y can be provided, where Y is a positive number to differentiate between messages of the same type. At the receiving end, the value Y is made available in Envelope's field senderStamp. As an example, when using an Applanix unit next to a Trimble unit, the respective microservices could be supplied with the suffixes --id=1 and --id=2.

Dependencies

You need a C++14-compliant compiler to compile this project as it ships the following dependencies as part of the source distribution:

For building cluon-rec2fuse, libfuse is required.

Usage

We are providing the following microservices as multi-platform (amd64/x86_64, armhf, aarch64) Docker images:

OpenDLV.OS

Complete ArchLinux-based OpenDLV OS Operating System (start here if you want to initialize a blank computing unit - WARNING! All data will be erased!)

Hardware/Software Interfaces:


GPS devices

Applanix POS GPS/INSS units: opendlv-device-gps-pos Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-gps-pos:
        image: chalmersrevere/opendlv-device-gps-pos-multi:v0.0.5
        restart: on-failure
        network_mode: "host"
        command: "opendlv-device-gps-pos --pos_ip=10.42.42.40 --pos_port=5602 --cid=111"

OxTS GPS/INSS units: opendlv-device-gps-ncom Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-gps-ncom:
        image: chalmersrevere/opendlv-device-gps-ncom-multi:v0.0.13
        restart: on-failure
        network_mode: "host"
        command: "opendlv-device-gps-ncom --ncom_ip=0.0.0.0 --ncom_port=3000 --cid=111"

Trimble GPS/INSS units: opendlv-device-gps-nmea Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-gps-nmea:
        image: chalmersrevere/opendlv-device-gps-nmea-multi:v0.0.7
        restart: on-failure
        network_mode: "host"
        command: "opendlv-device-gps-nmea --nmea_ip=10.42.42.112 --nmea_port=9999 --cid=111"

LIDAR devices

Velodyne HDL32e lidar units: opendlv-device-lidar-hdl32e Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

  • Provides: PointCloudReading (OpenDLV Standard Message Set v0.9.1)
  • Command to run with Docker: docker run --init --rm --net=host chalmersrevere/opendlv-device-lidar-hdl32e-multi:v0.0.9 opendlv-device-lidar-hdl32e --hdl32e_ip=0.0.0.0 --hdl32e_port=2368 --cid=111 --verbose
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-lidar-hdl32e:
        image: chalmersrevere/opendlv-device-lidar-hdl32e-multi:v0.0.9
        restart: on-failure
        network_mode: "host"
        command: "opendlv-device-lidar-hdl32e --hdl32e_ip=0.0.0.0 --hdl32e_port=2368 --cid=111"

Velodyne VLP32c lidar units: opendlv-device-lidar-vlp32c Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

  • Provides: PointCloudReading (OpenDLV Standard Message Set v0.9.7)
  • Command to run with Docker: docker run --init --rm --net=host chalmersrevere/opendlv-device-lidar-vlp32c-multi:v0.0.1 opendlv-device-lidar-vlp32c --vlp32c_ip=0.0.0.0 --vlp32c_port=2368 --cid=111 --verbose
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-lidar-vlp32c:
        image: chalmersrevere/opendlv-device-lidar-vlp32c-multi:v0.0.1
        restart: on-failure
        network_mode: "host"
        command: "opendlv-device-lidar-vlp32c --vlp32c_ip=0.0.0.0 --vlp32c_port=2368 --cid=111"

Velodyne VLP16 lidar units: opendlv-device-lidar-vlp16 Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

  • Provides: PointCloudReading (OpenDLV Standard Message Set v0.9.1)
  • Command to run with Docker: docker run --init --rm --net=host chalmersrevere/opendlv-device-lidar-vlp16-multi:v0.0.8 opendlv-device-lidar-vlp16 --vlp16_ip=0.0.0.0 --vlp16_port=2368 --cid=111 --verbose
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-lidar-vlp16c:
        image: chalmersrevere/opendlv-device-lidar-vlp16-multi:v0.0.8
        restart: on-failure
        network_mode: "host"
        command: "opendlv-device-lidar-vlp16 --vlp16_ip=0.0.0.0 --vlp16_port=2368 --cid=111"

Ultrasound devices

SRF08 devices connected via I2C bus: opendlv-device-ultrasonic-srf08 Docker (multi) Docker (amd64) Docker (armhf)

  • Provides: PointCloudReading
  • Command to run with Docker: docker run --rm -ti --net=host --privileged --device=/dev/i2c-1 chalmersrevere/opendlv-device-ultrasonic-srf08-multi:v0.0.10 opendlv-device-ultrasonic-srf08 --dev=/dev/i2c-1 --bus-address=112 --cid=111 --freq=5 --id=0
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-ultrasonic-srf08:
        image: chalmersrevere/opendlv-device-ultrasonic-srf08-multi:v0.0.10
        restart: on-failure
        network_mode: "host"
        privileged: true
        devices:
        - "/dev/i2c-1:/dev/i2c-1"
        command: "opendlv-device-ultrasonic-srf08 --dev=/dev/i2c-1 --bus-address=112 --cid=111 --freq=5 --range=100 --gain=1 --id=0 --cid=111"

Camera devices and video processing

OpenDLV contains a highly modular and easy-to-use framework to grab video frames from various cameras, share them via shared memory, and encode/decode them into h264 frames to broadcast into an OD4Session for OpenDLV. The microservices are divided into video sources (e.g., opendlv-device-camera-v4l, opendlv-device-camera-opencv, or opendlv-device-camera-rpi) and video sinks (e.g., opendlv-video-h264-encoder) to process incoming video frames. Video sinks provide frames in two image formats: I420-encoded image and ARGB. The former format can be directly used for video compression (e.g., h264 encoding), while the latter can be directly used for image detection algorithms (opendlv-examples).

Video4Linux cameras (e.g., /dev/video0): opendlv-device-camera-v4l Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

  • This microservice interfaces with a Video4Linux-supported camera and provides both, an I420-encoded image and an ARGB-encoded image residing in two separate shared memory areas. Other OpenDLV microservices can attach to this shared memory area for further processing (for instance opendlv-video-h264-encoder).
  • The following image formats are supported:
    • MJPEG
    • YUYV422
  • Command to run with Docker: docker run --rm -ti --init --ipc=host -v /tmp:/tmp -e DISPLAY=$DISPLAY --device /dev/video0 chalmersrevere/opendlv-device-camera-v4l-multi:v0.0.6 --camera=/dev/video0 --width=640 --height=480 --freq=20 --verbose
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-camera-v4l:
        image: chalmersrevere/opendlv-device-camera-v4l-multi:v0.0.6
        restart: on-failure
        ipc: "host"
        volumes:
        - /tmp:/tmp
        devices:
        - "/dev/video0:/dev/video0"
        command: "--camera=/dev/video0 --width=640 --height=480 --freq=20"

OpenCV-supported cameras: opendlv-device-camera-opencv Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64) Build Status

  • This microservice interfaces with an OpenCV-supported camera and provides both, an I420-encoded image and an ARGB-encoded image residing in two separate shared memory areas. Other OpenDLV microservices can attach to this shared memory area for further processing (for instance opendlv-video-h264-encoder). This microservice also allows to interface with network-attached cameras (i.e., those providing an MJPEG stream for example).
  • Command to run with Docker: docker run --rm -ti --init --ipc=host -e DISPLAY=$DISPLAY --device /dev/video0 -v /tmp:/tmp chalmersrevere/opendlv-device-camera-opencv-multi:v0.0.10 --camera=/dev/video0 --width=640 --height=480 --freq=20
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-camera-opencv:
        image: chalmersrevere/opendlv-device-camera-opencv-multi:v0.0.10
        restart: on-failure
        ipc: "host"
        volumes:
        - /tmp:/tmp
        devices:
        - "/dev/video0:/dev/video0"
        command: "--camera=/dev/video0 --width=640 --height=480 --freq=20"

RaspberryPi camera: opendlv-device-camera-rpi Docker (armhf)

  • This microservice interfaces with an RPi camera and provides both, an I420-encoded image and an ARGB-encoded image residing in two separate shared memory areas. Other OpenDLV microservices can attach to this shared memory area for further processing (for instance opendlv-video-h264-encoder).
  • Command to run with Docker: docker run --rm -ti --init --ipc=host -e DISPLAY=$DISPLAY --device /dev/video0 -v /tmp:/tmp chalmersrevere/opendlv-device-camera-rpi-armhf:v0.0.5 --width=640 --height=480 --freq=20
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    dev-camera-rpi:
        image: chalmersrevere/opendlv-device-camera-rpi-armhf:v0.0.5
        restart: on-failure
        ipc: "host"
        volumes:
        - /tmp:/tmp
        command: "--width=640 --height=480 --freq=20"

opendlv-video-h264-encoder to encode video frames from a shared memory into h264 frames (OpenH264 Video Codec provided by Cisco Systems, Inc.) as ImageReading (OpenDLV Standard Message Set v0.9.6):

  • This microservice attaches to an I420-encoded image residing in a shared memory area to encode it into an h264 frame to be broadcasted to other OpenDLV microservices.
  • During the Docker-ized build process for this microservice, Cisco's binary library is downloaded from Cisco's webserver and installed on the user's computer due to legal implications arising from the patents around the AVC/h264 format.
  • End user's notice according to AVC/H.264 Patent Portfolio License Conditions: When you are using this software and build scripts from this repository, you are agreeing to and obeying the terms under which Cisco is making the binary library available.
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    video-h264-encoder-amd64:
        build:
            context: https://github.com/chalmers-revere/opendlv-video-h264-encoder.git
            dockerfile: Dockerfile.amd64
        restart: on-failure
        network_mode: "host"
        ipc: "host"
        volumes:
        - /tmp:/tmp
        command: "--cid=111 --name=video0.i420 --width=640 --height=480"

opendlv-video-h264-decoder to decode h264 video frames from an ImageReading (OpenDLV Standard Message Set v0.9.6) into a shared memory (OpenH264 Video Codec provided by Cisco Systems, Inc.):

  • During the Docker-ized build process for this microservice, Cisco's binary library is downloaded from Cisco's webserver and installed on the user's computer due to legal implications arising from the patents around the AVC/h264 format.
  • End user's notice according to AVC/H.264 Patent Portfolio License Conditions: When you are using this software and build scripts from this repository, you are agreeing to and obeying the terms under which Cisco is making the binary library available.
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
   video-h264-decoder-amd64:
       build:
           context: https://github.com/chalmers-revere/opendlv-video-h264-decoder.git
           dockerfile: Dockerfile.amd64
       restart: on-failure
       network_mode: "host"
       ipc: "host"
       volumes:
       - /tmp:/tmp
       environment:
       - DISPLAY=${DISPLAY}
       command: "--cid=111 --name=imageData"

opendlv-video-x264-encoder to encode video frames from a shared memory into h264 frames as ImageReading (OpenDLV Standard Message Set v0.9.6):

  • This microservice attaches to an I420-encoded image residing in a shared memory area to encode it into an h264 frame to be broadcasted to other OpenDLV microservices.
  • Due to legal implications arising from the patents around the AVC/h264 format, we are not distributing binaries or Docker images but only provide build instructions that can be easily integrated with a docker-compose.yml file.
  • Section for docker-compose.yml to build for amd64:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    video-x264-encoder-amd64:
        build:
            context: https://github.com/chalmers-revere/opendlv-video-x264-encoder.git
            dockerfile: Dockerfile.amd64
        restart: on-failure
        network_mode: "host"
        ipc: "host"
        volumes:
        - /tmp:/tmp
        command: "--cid=111 --name=video0.i420 --width=640 --height=480"
  • Section for docker-compose.yml to build for armhf:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    video-x264-encoder-armhf:
        build:
            context: https://github.com/chalmers-revere/opendlv-video-x264-encoder.git
            dockerfile: Dockerfile.armhf
        restart: on-failure
        network_mode: "host"
        ipc: "host"
        volumes:
        - /tmp:/tmp
        command: "--cid=111 --name=video0.i420 --width=640 --height=480"
  • Section for docker-compose.yml to build for aarch64:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    video-x264-encoder-aarch64:
        build:
            context: https://github.com/chalmers-revere/opendlv-video-x264-encoder.git
            dockerfile: Dockerfile.aarch64
        restart: on-failure
        network_mode: "host"
        ipc: "host"
        volumes:
        - /tmp:/tmp
        command: "--cid=111 --name=video0.i420 --width=640 --height=480"

opendlv-video-vpx-encoder to encode video frames from a shared memory into VP8 or VP9 frames as ImageReading (OpenDLV Standard Message Set v0.9.6): opendlv-video-vpx-encoder Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64)

  • Command to run with Docker: docker run --rm -ti --init --net=host --ipc=host -v /tmp:/tmp chalmersrevere/opendlv-video-vpx-encoder-multi:v0.0.5 --cid=111 --name=video0.i420 --width=640 --height=480 --vp8
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
   video-vpx-encoder:
       image: chalmersrevere/opendlv-video-vpx-encoder-multi:v0.0.5
       restart: on-failure
       network_mode: "host"
       ipc: "host"
       volumes:
       - /tmp:/tmp
       environment:
       - DISPLAY=${DISPLAY}
       command: "--cid=111 --name=video0.i420 --width=640 --height=480 --vp8"
  • Command to run with Docker: docker run --rm -ti --init --net=host --ipc=host -v /tmp:/tmp -e DISPLAY=$DISPLAY chalmersrevere/opendlv-video-vpx-decoder-multi:v0.0.4 --cid=253 --name=video0.arg0 --verbose

opendlv-video-vpx-decoder to decode h264 video frames from an ImageReading (OpenDLV Standard Message Set v0.9.6) into a shared memory: opendlv-video-vpx-decoder Docker (multi) Docker (amd64) Docker (armhf) Docker (aarch64)

  • Command to run with Docker: docker run --rm -ti --init --net=host --ipc=host -v /tmp:/tmp -e DISPLAY=$DISPLAY chalmersrevere/opendlv-video-vpx-decoder-multi:v0.0.5 --cid=253 --name=video0.arg0 --verbose
  • Section for docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
   video-vpx-decoder:
       image: chalmersrevere/opendlv-video-vpx-decoder-multi:v0.0.5
       restart: on-failure
       network_mode: "host"
       ipc: "host"
       volumes:
       - /tmp:/tmp
       environment:
       - DISPLAY=${DISPLAY}
       command: "--cid=111 --name=imageData"

Data Post Processing:

rec2csv-png to extract messages as .csv and h264 frames as separate .png files from a .rec file from a recorded OpenDLV session (OpenH264 Video Codec provided by Cisco Systems, Inc.):

  • Example for a docker-compose.yml:
version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    rec2csv_png:
       build:
           context: https://github.com/chalmers-revere/rec2csv-png.git
           dockerfile: Dockerfile.amd64
       restart: on-failure
       volumes:
       - .:/opt/data
       working_dir: /opt/data
       command: "--rec=YourRecording.rec --odvd=YourMessageSpec.odvd"

cluon-rec2fuse to mount a recording file to a folder and dynamically map its content as .csv files:

  docker run --rm -ti -v $PWD/myrecording.rec:/opt/input.rec \
                    -v $PWD/opendlv.odvd:/opt/odvd \
                    -v $PWD/mnt:/opt/output:shared \
                    --cap-add SYS_ADMIN \
                    --cap-add MKNOD \
                    --security-opt apparmor:unconfined \
                    --device=/dev/fuse \
                    -v /etc/passwd:/etc/passwd:ro \
                    -v /etc/group:/etc/group \
                    chrberger/cluon-rec2fuse-amd64:v0.0.104 \
                    /bin/sh -c "chown $UID:$UID /opt/output && \
                    su -s /bin/sh $USER -c 'cluon-rec2fuse --rec=/opt/input.rec --odvd=/opt/odvd -f /opt/output' \
                    && tail -f /dev/null"

asciicast

Visualizations:

cluon-livefeed to display any messages exchanged in the communication session 111 on console: docker run --rm -ti --init --net=host chrberger/cluon-livefeed-multi:v0.0.104 --cid=111 asciicast

opendlv-signal-viewer to view any messages from the OpenDLV Standard Message Set exchanged in the communication session 111 (after starting this microservice, point your web-browser to the computer's IP address, port 8080): docker run --rm --net=host -p 8080:8080 chalmersrevere/opendlv-signal-viewer-multi:v0.0.8 --cid=111

version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    signal-viewer:
        image: chalmersrevere/opendlv-signal-viewer-multi:v0.0.8
        restart: on-failure
        network_mode: "host"
        ports:
        - "8080:8080"
        command: "--cid=111"

screenshot from signal viewer

opendlv-vehicle-view to view vehicle messages from the OpenDLV Standard Message Set exchanged in the communication session 111 (after starting this microservice, point your web-browser to the computer's IP address, port 8081): docker run --rm --net=host --name=opendlv-vehicle-view -v ~/recordings:/opt/vehicle-view/recordings -v /var/run/docker.sock:/var/run/docker.sock -p 8081:8081 chalmersrevere/opendlv-vehicle-view-multi:v0.0.39

version: '2' # Must be present exactly once at the beginning of the docker-compose.yml file
services:    # Must be present exactly once at the beginning of the docker-compose.yml file
    vehicle-view:
        container_name: opendlv-vehicle-view
        image: chalmersrevere/opendlv-vehicle-view-multi:v0.0.39
        restart: on-failure
        network_mode: "host"
        volumes:
        - ~/recordings:/opt/vehicle-view/recordings
        - /var/run/docker.sock:/var/run/docker.sock
        ports:
        - "8081:8081"

screenshot from vehicle view

Build from sources on the example of Ubuntu 16.04 LTS

To build this software, you need cmake, C++14 or newer, and make. Having these preconditions, update the contained submodules first.

git submodule update --init --recursive
git submodule update --remote --merge
git submodule status

Now, you can change into the various sub-folders and run cmake and make as follows:

mkdir build && cd build
cmake -D CMAKE_BUILD_TYPE=Release ..
make && make test && make install

License

  • This project is released under the terms of the GNU GPLv3 License.

Publications

The following list contains publications related to the OpenDLV Software Ecosystem: