Senior Engineer/Consult Embedded Software C/C++

1/2024 – 12/2024

Architecture and development of two core components of an Embedded Linux gateway connecting industrial trucks (forklifts) to an IoT cloud platform.

1. Edge Computing Service

Design of the system architecture and development of a Linux system service (systemd) as a central runtime framework for decentralized data processing directly on the vehicle:

- Architecture with an exchangeable interpreter interface: extensible for other scripting languages; technology evaluation and selection of the initial Python interpreter (pybind11), definition of the C++ API for Edge Modules
- Dynamic loading and execution of Python-based Edge Modules, deployed as ZIP bundles from the cloud
- Type-safe C++ API for sensor data access, persistent caching, logging and cloud telemetry
- Real-time data acquisition from CAN bus, CDI and GNSS/GPS via ZeroMQ IPC
- State machine-based lifecycle (Startup → Cloud Configuration → Runtime → Error/Save)
- Persistent module cache (binary format) for offline operation

2. IPC Adapter Library

Architecture and development of a generic, type-safe C++20 middleware for inter-process communication between all vehicle services:

- Design of a channel-based adapter concept with compile-time typing (C++20 Concepts & Templates)
- Three communication patterns: Events (Publish/Subscribe), Request/Response and Deferred Requests (asynchronous)
- Central GlobalAdapter with dedicated receiver thread and thread-safe dispatcher
- Based on ZeroMQ and a proprietary transport protocol
- Used as shared middleware by all vehicle services (CAN, CDI, Communication Manager, Update Manager, etc.)

Language: C++20
Platform: Embedded Linux (Yocto, systemd)
Interfaces: CAN-Bus, CDI, GNSS/GPS, ZeroMQ
Tools: CMake, GitLab CI, pybind11, RapidJSON, spdlog

Canopen, Edge Code, Embedded Entwicklung / hardwarenahe Entwicklung, Embedded Linux, Internet of Things (IoT), Programmierer C, C++, Python-Programmierer, Software Architecture, Software Design

1/2023 – 12/2023

Further Development of an I/O Module. The module was previously operated with an Ethernet Safety Stack. The goal was to replace this stack with a CIP Safety Stack. The architecture of the module consists of six controllers: two for the non-safety area and four for the safety area. The module meets the requirements according to SIL3 (Safety Integrity Level 3).

Language: C
Plattform: BareMetal
Controller: STM32
Interfaces: SPI, GPIOs
Tools: CMake, Tessy

Automatisierungstechnik (allg.), Programmierer C, C++, SafetyBUS p

1/2020 – 12/2022

Redesign of an Existing Library. Various sensors could be connected, and the captured data could be transmitted to different cloud systems, including a proprietary cloud, AWS, and Microsoft Azure. Different transmission technologies such as Ethernet, Cellular, LoRa, and Mioty were used for data transmission. The data was always transmitted in an encrypted format.

Language: C++17
Plattform: FreeRtos
Controller: ESP32
Interfaces: CAN, MODBUS, Tcp/Ip, RS232, SPI, GPIOs, GPS, LoRa, Mioty
Tools: CMake, catch2

Embedded Entwicklung / hardwarenahe Entwicklung, Programmierer C, C++, Software Architecture, Software Design, Microsoft Azure, Amazon Web Services (AWS), Internet of Things (IoT)

11/2017 – 12/2019

Integration of Test Software into Vehicles and Automated Provision of Test Data for AI Developers. This involved integrating the test software into the vehicles and automating the delivery of test data to the AI developers. Additionally, Conan was introduced for dependency management, and the ROS adapter was further developed to improve integration and communication with the vehicle control systems.

Language: C++11, ROS
Plattform: Embedded Linux
Controller: X68
Interfaces: CAN, Tcp/Ip, RS232, SPI, GPIOs, GPS
Process: Autosar
Tools: CMake, Misra, Conan, GoogleTest, CANalyser, CANoe

Embedded Entwicklung / hardwarenahe Entwicklung, Projektleiter Systemanalyse und Systemprogrammierung, Programmierer C, C++

1/2017 – 11/2017

Development of a Prototype for Side Impact Detection. The goal was to develop a prototype capable of detecting side impacts early enough to trigger a side airbag. This involved designing the software architecture and implementing a solution for recording and replaying sensor data in real-time. The vehicle was equipped with cameras, radar, GPS, and LiDAR. Additionally, performance optimization of the existing software was carried out to achieve a data throughput of approximately 0.7 GB/s.

Language: C++11, ROS
Plattform: Embedded Linux
Controller: X68
Interfaces: CAN, Tcp/Ip, RS232, SPI, GPIOs
Process: Autosar
Tools: CMake, Misra, GoogleTest

Software Design, CAN-Bus (controller area network), Embedded Entwicklung / hardwarenahe Entwicklung, Embedded Linux, Programmierer C, C++, Software Architecture

6/2013 – 12/2016

Development of firmware for a product family of washing machines and tumble dryers (ranging from devices for single-family homes to commercial laundry machines with integrated payment options, remote diagnostics, etc.). Separate firmware solutions were developed for both the power section and the user interface. Additionally, a custom-developed bootloader was implemented for programming the firmware during manufacturing.

Language: C, OpenGL for User Interface
Plattform: FreeRTOS
Controller: PIC24
Interfaces: RS232, GPIOs, SPI
Tools: Make, Microchip Tools

Software Design, Embedded Entwicklung / hardwarenahe Entwicklung, Make (Software), Opengl, Python-Programmierer, Software Architecture

1/2011 – 3/2013

Further development of a data logger for vehicle data acquisition. The collected data was stored in the cloud via a cellular module. My task was to design and integrate a Hardware Abstraction Layer (HAL) for the vehicle data. The challenge was to design the HAL in such a way that it could be used with minimal adjustments for various vehicle types (e.g., buses, trains, trucks, etc.).

Language: C++, Java
Plattform: Embedded Linux
Controller: X86
Interfaces: CAN, DBUS, RS232, Modbus, TCP/IP, UDP, USB
Tools: Qt Creator, Maven, CANalyzer, CANoe, gdb

Embedded Linux, Software Design, CAN-Bus (controller area network), Embedded Software, Java-Entwickler, Programmierer C, C++, Software Architecture, TCP / IP

1/1992 – 12/2010

Porting a CAE System to Windows and Linux:
Responsible for adapting and migrating a complex Computer-Aided Engineering (CAE) system to multiple platforms to ensure compatibility and performance on both Windows and Linux-based systems.
• Development of the Ground System for the A400M:
Contributed to the development of a highly reliable ground system for the Airbus A400M, adhering to the stringent requirements of the aerospace industry (DO-178B).
• App Development for iPhone and Android:
Developed mobile applications for iOS and Android, including the design of user-friendly interfaces and integration of various backend services.
• Development of High-Performance Data Structures for CAE Systems:
Designed and implemented optimized data structures to meet the high-performance requirements of CAE systems, enabling efficient processing of large datasets.
• Measurement Data Acquisition System for Pressure Sensors:
Developed a system for the precise acquisition and analysis of measurement data from pressure sensors, intended to be integrated into a manufacturing facility.
• Signal Conditioner for Brake Test Stands:
Developed a signal conditioner to determine whether the tire consistently maintains contact with the ground.

Software Architecture, Java-Entwickler, Programmierer C, C++, Projektleitung / Teamleitung (IT), Softwareentwickler