Martin Lampacher

Freelance Embedded Engineer

2022, Personal project

Rust primer

Rust Github CI clang

Development of CLI applications using Rust.

During various other projects more and more complex CLI applications emerged, implemented using python. Due to limited time allocated to testing, the python based CLI tools always felt very brittle. Looking for a more solid alternative I've decided to explore the Rust programming language, resulting in a first facade crate globmatch and wrappers for the clang-format and clang-tidy CLI applications, named run-clang-format and run-clang-tidy.


Proof-of-concept for APIs for a new software platform

C++ OPC-UA MQTT Protobuffer OpenAPI

Evaluation of available technologies for internal- and customer APIs of a software platform, including a proof-of-concept.

For a C++ based software platform, I performed an evaluation of available API technologies intended to be used for internal and external APIs, including a proof-of-concept integration and implementation in the existing platform. One key aspect of the project was the transition from a monolithic application to a service architecture.

2021, Personal project

Exploring low-power designs with the nRF52840

C nRF52840 FreeRTOS

Development of a low-power PCB for the nRF52840 Dongle.

The classic side project, an automatic watering solution for pot plants. I have used this as an excuse to design an elementary low-power carrier board for the nRF52840 dongle, which was used to explore low-power designs with FreeRTOS and the (now deprecated) Nordic SDK. The PCB included controllable 3V3 and 5V0 power stages, an external flash and LiPo charging/monitoring components such that the board could run for months on a small battery, with optional solar charging.

2020 - 2023

Software architecture and driver development for an ECU platform

C TriCore Pxros ISO 13849 IEC 61508 ISO 26262

Software architecture and development for a new safety-certified ECU platform.

Driver development in C based on a proprietary HAL, complemented by the Infineon MCAL and third-party software, e.g., file systems. The drivers are implemented on bare metal and extended for a real-time OS integration layer.

2019 - 2021

Testkernel for an ECU platform

C Python CANopen TriCore CAN LIN SENT Ethernet Pxros

Development of a CANopen based testkernel for a new safety-certified ECU platform.

For a new ECU platform a generic testkernel, supporting multiple ECU families with several variants, had to be developed. This testkernel is used for compliance-, hardware-, End-Of-Line and system tests.

2019 - 2021

Embedded "DevOps"

C Python MAKE Jenkins Docker PLC Parasoft pytest HIS MISRAC

Integration and configuration of development- and test tooling.

Supporting several development projects I was responsible for the setup of (certified) test frameworks, providing and implementing build-environments, the implementation and configuration of code formatters and static analyzers, scripting for PLC tools as well as the setup and configuration of CI tools.

2019, Personal project

CAN-based "IoT" Solution

C Python golang IoT Cortex-M0 CAN Docker Vue.js Unity MQTT openHAB

Development of a CAN-based solution for modular, wired applications.

For different side-projects, I've developed a complete framework for generic CAN-based nodes, including a simple bootloader/DFU solution. All nodes are accessible via a JSON-API running on a more powerful edge device (e.g., Raspberry-PI or a normal computer). The project setup includes static analysis and unit tests for core firmware modules, API- and DFU services, and a generic web application for accessing the devices. The API architecture has also been extended for a simple adapter implementing the Homie MQTT convention, making devices accessible via openHAB.

2017 - 2018, Personal project

System Test Framework

Python Electron Vue.js Docker OpenOCD

Development of a python-based system test framework including an optional GUI application.

Throughout several projects, I've noticed the lack of a generic, easy-to-use test framework for system tests. Thus I've dedicated a considerable amount of free time to the development of a generic, fully dockerized test framework. The core of this framework is a python application that can be used as a server accepting gRPC calls, or as a standalone CLI for executing tests. An optional GUI application based on Electron and Vue.js serves as a user interface simple enough for untrained personnel such as production testers (e.g., End-Of-Line tests). This framework is in use as an End-Of-Line tester for different PCBs produced as part of the sensor platform project. But no, it is not open source (yet).


Wireless Sensor Platform

C Python golang IoT Cortex-M0 IEEE 802.15.4 Docker Vue.js Unity gcloud

Development of a wireless sensor network with very low-power nodes for climbing applications.

After having evaluated existing solutions I was responsible for the development of a sensor platform for different climbing applications. Strong restrictions on the power consumption required a completely new network design based on IEEE 802.15.4. Throughout the project I was responsible for handling third-party suppliers (HW, housing), unit testing, providing and implementing End-Of-Line testers for production as well as the complete firmware and software development, including bootloader, firmware, API, services and reference web applications.


Gateway ECU


Development of an automotive-grade Gateway ECU for CAN, LIN, FlexRay, and Ethernet.

The most challenging project so far. As a software architect, I was responsible for managing a team of software developers and external suppliers to design and implement a new ECU, featuring most state-of-the-art communication interfaces. Alongside a third-party implementation of the AUTOSAR framework, a matching bootloader supporting signed firmware downloads was integrated. Major efforts went into routing, security features, and hardware testing, e.g., of the integrated Ethernet switch components.


CANopen Bootloader

C Python CANopen ISO 13849 IEC 61508 PTC

Development and integration of a CANopen based bootloader for an existing safety-certified ECU family.

To support a proprietary third-party DFU tool a new bootloader had to be developed and integrated into an existing ECU family without breaking support for existing tools. For this project, I designed and implemented the bootloader and also delivered the required documentation in the form of a requirements document and impact analysis for the existing safety certification.


Safety ECU + CANopen Safety I/O Module

C Python CANopen Safety EN ISO 50325-5 ISO 13849 IEC 61508 PTC

Development of a new safety certified ECU family including CANopen Safety I/O Module applications.

Based on the same concept as for 2013 the family of CANopen Safety I/O Modules was extended for a new ECU family. In this project, I was also responsible for coordinating a small team of software developers as well as handling software safety topics. The ECU family was certified for ISO 13849 PL c.


CANopen Safety I/O Module

C Python CANopen Safety EN ISO 50325-5 ISO 13849 IEC 61508 PTC

Development of the first safety-certified, generic CANopen Safety I/O Module. Software project implemented for an existing ECU platform, certification according to ISO 13849 PL d.

For an existing ECU with matching drivers (HAL) and a CANopen I/O Module implementation, a new CANopen Safety application had to be developed. Requiring PL d certification according to ISO 13849 the application was re-developed from scratch, integrating a third-party CANopen Safety stack. Aside from development tasks, the project allowed me to participate in all life-cycle activities up to the actual certification with TuEV Nord.


OBD Gateway (master's thesis)

C Objective-C PIC32 WiFi CAN ISO 15765 ISO 15031

Implementation of a wireless gateway between the diagnostic port of a car and mobile devices.

The main focus of the project was to have a practical example for the thesis: Interfacing an embedded system with a consumer device (smartphone). It involved the development of a hardware prototype, the firmware including a simple UDS on CAN + OBD stack, a "simulator" to mock the car I did not have back then, and an iOS application.


CANopen Master Application

C CANopen XC 2000 CANalzyer

Implementation and integration of a minimal CANopen master, replacing a generic CANopen stack.

As part of an internship, I was responsible for developing the CANopen master and integrating it into the vehicle platform, including up to four CANopen slaves that were then managed by the device.