Project Archive
Professional work, case studies, and hobby projects in one index.A single index of professional work, case studies, and hobby projects. Search by name or keyword, then narrow by category or technology.
Search and filters
24 projects
Case Studies
8 projects
Simplifier Gateway
Simplifier Gateway
The Simplifier Gateway sits between a distributed Safety Simplifier installation in the field and the higher-level safety controller that has to trust it. It gathers validated safety state from Simplifier devices and presents that system to a Siemens controller over PROFIsafe or to a Beckhoff controller over FSoE through one interface. I joined while the product was still in early development. The firmware itself mattered, but the bigger gap was everything around it: no tests, very little review discipline, IDE-bound builds, and weak traceability, all on a product that needed SIL 3 certification under IEC 61508. Most of my contribution ended up there: verification infrastructure, certification-evidence automation, and the embedded DevOps backbone that turned the project from firmware that seemed correct into firmware that could be proven correct to a certifier.
CCMakeDevOpsIEC-61508Production Test Cabinet
Production Test Cabinet
Once SSP's Simplifier Gateway was certified, the next problem was serial production. I implemented the production test cabinet and the complete end-to-end test that now screens every Gateway before it can be shipped. The test runs more than 80 checks across the six connected PCBs, records the measurements in the company ERP system, and stops a failed unit from moving forward until it has been repaired and tested again.
BeckhoffTwinCAT.NETVueJSFrom a BLE Crash to Agentic HIL Testing
From a BLE Crash to Agentic HIL Testing
I have been building a cross-platform Flutter app at SSP for the past few months. It targets ~all platforms: Windows, Android, iOS, MacOS, Linux and Web. And to interface with the BLE of each platform, I am using this excellent "Universal BLE" Flutter package. During early development, the Windows version was randomly crashing during BLE communication. Without throwing a dart-side exception or a trace of any sort. The app would just disappear. It was particularly frustrating because this app is meant to replace a troublesome legacy application and communicate reliably with a functional-safety device. Random crashes were hardly an improvement. I had already used Universal BLE in my Smart Insole project, so I followed the problem into a library I knew and depended on. Moving the BLE device farther away from my laptop made the crash reproducible. I contributed a fix, kept testing, and found more bugs. At that point, I wanted a better way to reproduce these failures than walking around with a Bluetooth device and hoping to hit the right timing. That grew into a hardware-in-the-loop (HIL) test system built around a programmable BLE peripheral. I used loop engineering to coordinate AI agents investigating bugs, writing fault-injection tests, and checking fixes on real hardware. My functional-safety background shaped the checks; the agents wrote changes and reran tests. The work has now identified and fixed 13+ bugs upstream, with a reusable test suite for subsequent releases.
FlutterDartC++WinRTMotion and Light Sensor
Motion and Light Sensor
The MTronic motion and light sensor is a ceiling-mounted, battery-powered device for the MTronic smart home automation platform. It detects room occupancy through a 360-degree passive infrared field and measures ambient light continuously, and it is the input the rest of the system depends on to automate lighting and climate. If the sensor is unreliable or frequently out of battery, the automations that sell the whole ecosystem stop feeling automatic. I was the sole firmware engineer on this sensor across two hardware generations. I joined when the first ESP32-C3 prototypes (V1) had been fabricated, and through systematic power profiling I found that the platform could not be pushed past a roughly 9-month battery life. That was below the product's hard 1-year requirement and made V1 effectively unsellable. I made the technical and supply case for moving to a Nordic Semiconductor nRF52832, rebuilt almost the entire firmware from scratch, and worked closely with the hardware team on the V2 design. The shipped sensor has a publicly stated battery life of 3 years, with installations beginning in late 2022.
CnRF52ZephyrBluetooth MeshWearable Epilepsy Monitor
Wearable Epilepsy Monitor
EPIC, short for EPIlepsy Care, was a research stage wearable built to monitor generalized tonic clonic seizure events, log relevant sensor data, and notify caregivers through a connected mobile app. I developed it at RISETech with the BIOMISA group at The College of Electrical & Mechanical Engineering (CE&ME). This was my first professional embedded project after university. As the Systems Design Engineer at RISETech, I was responsible for the design and implementation of this device, covering electronics architecture, schematic design, PCB layout, sensor integration, firmware, signal acquisition and filtering, BLE communication, battery and charging design, enclosure CAD, prototyping, testing, documentation, and supplier coordination.
CnRF52BLEGATTSmart Insole Firmware
Smart Insole Firmware
A pair of smart insoles for real-time gait and plantar-pressure tracking. They streamed live data to a phone app and also recorded sessions, so clinicians were not stuck relying on what a patient remembered later. I led the embedded side of the product, from firmware and BLE architecture to the electronics redesign and reference tooling. The main issue was simple: clinicians only saw a patient for a short visit, but the movement problems usually happened outside the clinic. Patients then had to describe all of that from memory, which is not much to work with. The insoles were built to capture what actually happened during normal daily use. The hard part was making two battery-powered BLE devices behave like one reliable product. The firmware had to coordinate sensor acquisition, left-right synchronization, offline recording, power management, provisioning, OTA updates with rollback, diagnostics, and the mobile-facing protocol and documentation.
CnRF52ZephyrBLEC C++ Toolkit
C C++ Toolkit
C C++ Toolkit is a Visual Studio Code extension I built to cut down the setup work that usually comes with C and C++ projects. Instead of creating folders, CMake files, launch configurations, and repeated build commands by hand, the extension puts the common workflow behind a smaller set of editor commands and status-bar actions. The project came from a problem I had already been explaining manually. Setting up a multi-file C or C++ project in VS Code is rarely hard in principle, but it is confusing for students and beginners who are still learning what GCC, GDB, CMake, Ninja, and the
.vscodeconfiguration files actually do. I wrote a setup guide first, then turned that setup knowledge into a tool. I built the extension in JavaScript for the VS Code runtime, added project and component generators, wired in build and debug flows, and added cross-platform tool detection and installation support. It went on to become my most widely used open-source project, with more than 27,000 downloads on the Visual Studio Marketplace. It is most useful at the start of the learning curve, where strong defaults help more than they hurt.JavaScriptVsCodeEzLogger
EzLogger
EzLogger is the logger I ended up writing after getting tired of dragging heavier logging frameworks into small .NET tools just to get colored terminal output, timestamps, verbosity levels, and optional file logs. The first rough version of this idea showed up back in the 2022 Energy Logger project. When I came back to desktop and CLI work later, I rebuilt it properly as a reusable library. The newer version kept the part that mattered and dropped the rest: six verbosity levels, colored console output, file logging, background writes, automatic cleanup, and graceful shutdown flushing. Since then it has gone into basically every C# app I write, both for real work and for experiments.
.NET
Professional Work
6 projects
NonSafe Simplifier Gateway
2023Safety System ProductsA more affordable version of the Simplifier Gateway, at the cost of not being functional safety compliant. I am responsible for complete development of this product, including its support software for remote updates, mass setup and programming.
C#.NET2023Safety System ProductsGateway Setup Tool
2023Safety System ProductsAn internal tool for mass programming and repairing the software of our NonSafe Simplifier Gateways. While I did create an underlying CLI for it to be integrated into CI/CD and hardware production pipelines, I also made an intuitive GUI for it to be used by individual users (production staff) when needed. I designed the UI to blend in with our other software in terms of its intuitive layout, company colors and fluid animations.
C#WPF.NET2023Safety System ProductsGateway Config Tool
2023Safety System ProductsAn easy to use device configuration app that can read and create configuration files for our Gateways. This app is made available to the customers so that they can create working configuration files every time. The UI of this app was also made on the same design principles as the setup and repair tool.
C#WPF.NET2023Safety System ProductsBluetooth Firmware Upgrade
2022MRS TechnologiesI created a key part of the firmware for all MTronic devices: their ability to upgrade the firmware remotely. The update architecture contained source verification, firmware integrity checks and rollback in case of faulty updates. This allowed us to push feature and security updates to devices that were already in use by the customers. Naturally, the update mechanism was developed, tested and verified in a much more thorough way, relative to other parts of the firmware, as it is arguably one of the most critical features of any IoT device.
CFreeRTOSBluetooth2022MRS TechnologiesEnergy Logger
2022MRS TechnologiesI developed an energy monitoring system for a Tier 1 automotive electronics manufacturer to track power usage across their facility. Using a .NET backend and a JavaScript/React frontend, I collected consumption data from energy meters using Modbus TCP, processed it, and stored it in an SQL database. The data was then displayed on a visually appealing dashboard. This system provided the client with valuable insights into their energy consumption, enhancing their operational efficiency and supporting regulatory compliance.
C#.NETJavaScriptSQL2022MRS TechnologiesFile Format Converter
2021MRS TechnologiesThis project was the start of my .NET and C# development, which has since been instrumental in my career. I developed a .NET tool for a Tier 1 automotive electronics manufacturer to convert SAE-J1939 CAN bus message information from Excel into .dbc, .sym, and .csv formats. The project involved creating an intuitive WPF GUI with the Prism framework and MVVM architecture. This tool enabled the client to integrate CAN message encoding and decoding into their applications, which are crucial for their operations. The raw data required extensive parsing and cleaning, due to frequent inconsistencies and irregularities in data.
C#.NETWPF2021MRS Technologies
Hobby Projects
10 projects
Genetic Algorithm
2023C implementation of a genetic algorithm that evolves candidate strings toward a user-defined target. Rather than presenting itself as a generic optimization framework, it is designed as a clear and approachable demonstration of evolutionary search, with an emphasis on readability, traceability, and understanding how the core mechanics of a genetic algorithm work in practice. The program takes two command-line inputs: a target string and the number of offspring to generate in each generation. At startup, it validates that the target contains only characters from the predefined gene pool, checks that the offspring count is within the allowed range, seeds the random number generator, and initializes the target genome. Architecturally, the project is intentionally compact and well separated into small functional layers. The `app_init` module handles argument parsing and validation, the `main.c` application layer drives the generational loop, and the `genetic_algorithm_utils` module contains the core genome operations such as initialization, crossover, mutation, fitness calculation, sorting, copying, printing, and cleanup. A gene is represented as a single `char`, while a genome is represented by a structure containing a dynamically managed gene array, its length, and a cached fitness value. This makes the data model simple enough to follow directly while still being structured enough to support clean separation between orchestration and algorithmic logic. The evolutionary process follows a straightforward cycle. Two parent genomes are first created with random genes drawn from the project's character pool. In each generation, the parents are repeatedly mated to produce the configured number of offspring. Mating uses single-point crossover, and the order of the two parents is randomly flipped so that neither parent always contributes the leading segment. After crossover, a slight mutation is applied, implemented as either zero or one random gene replacement. This mutation step is included specifically to reduce the risk of the population settling into a local maximum too early. Once created, each offspring is scored against the target using a fitness function based on exact positional character matches. Selection is equally direct: the offspring population is sorted by fitness, and the two fittest offspring are deep-copied into the parent slots for the next generation. In this implementation, a perfect match has a fitness of `0`, while less accurate genomes have increasingly negative scores. The loop continues until convergence is achieved or an upper iteration bound is reached. As the README notes, the design intentionally favors clarity over optimization, even keeping some routines, such as fitness evaluation and sorting, simple for ease of understanding and debugging. Overall, the project serves as a readable, self-contained example of parent selection, crossover, mutation, survival of the fittest, and generational convergence in C.
C++CMake2023PID Controller
2023An implementation of a PID controller in C. A PID controller, short for Proportional-Integral-Derivative controller, is a closed-loop control system that is widely used in engineering applications to control dynamic systems. It works by continuously comparing a desired target value, also called the setpoint, with the current output of a system. The difference between these two values is used to calculate a correction signal that helps move the system toward the target. This project provides a simple and readable implementation of the PID control concept. It is mainly intended as a practice project and learning resource for anyone who wants to understand how PID controllers work at a software level. The code demonstrates how the proportional, integral, and derivative terms are calculated and combined to produce a control output. The proportional term reacts to the current error between the target and measured value. The integral term considers accumulated error over time, which helps reduce long-term steady-state error. The derivative term estimates how quickly the error is changing, which can help reduce overshoot and improve stability. By tuning the three gain values, `kP`, `kI`, and `kD`, the controller response can be adjusted for different systems. The implementation is written in C and organized into separate source and header files. The controller stores values such as the PID gains, sampling time, goal value, and previous error data. A ring buffer is used to store past error values, allowing the controller to calculate accumulated error and observe recent changes in system behavior. The project also makes use of function pointers for flexibility. Users can provide their own input function and transfer function. The transfer function represents the behavior of the system being controlled, or “plant,” by describing how a given control input affects the system output. In the example program, this allows the PID controller to be tested against a simple simulated system without requiring real hardware. Although this is not intended to be a production-ready control library, it is useful as an educational example. It can help students, hobbyists, and developers connect basic control theory with practical C programming. It may also serve as a starting point for more advanced PID implementations, such as adding output limits, anti-windup protection, realtime sampling, or embedded system integration. Overall, this project is a compact learning exercise that introduces the core ideas behind PID control while keeping the implementation simple enough to read, modify, and experiment with.
CCMake2023Numerical Calculus
2023This is a small C practice project that demonstrates how numerical derivatives and integrals can be calculated from a sampled dataset. The project is intended as an educational example and a testing ground for the more advanced PID controller project, where derivative and integral calculations are important building blocks. It focuses on presenting the core ideas of numerical calculus in a very easy-to-read and understandable manner, making it especially useful for students who are learning numerical methods and how those methods can be implemented in software. The code works by first defining a mathematical function, `f(x)`, which is used to generate a dataset. In the example, the function is `y = x³`. A fixed number of samples and a resolution factor are configured in the program. The resolution factor determines the time interval between samples, meaning a higher resolution creates smaller time steps and usually produces more accurate numerical results. The generated function values are stored in a ring buffer, which is also used in the related PID controller project. The derivative is calculated using a simple finite difference method. For each sample point, the program compares the current value with the previous value and divides the difference by the time interval. This gives an approximation of the rate of change at that point. The integral is calculated using trapezoidal-style methods, where the area under the curve is estimated by summing small sections of the sampled function. The code includes both a typical trapezoidal implementation and a modified integral function, making it easy to compare and understand different numerical approaches. The implementation is intentionally simple. The main logic is contained in readable C functions such as `calculate_derivative`, `trapezoidal`, and `calculate_integral`. The project is built using CMake and links against my ring buffer module, keeping the structure clear while still showing how code can be split into reusable components. Although this is not intended to be a full numerical analysis library, it is useful as a learning resource. Students, hobbyists, and beginner C programmers can use it to understand how mathematical formulas for derivatives and integrals translate into working code. It can also serve as a starting point for more advanced simulations, control systems, signal processing experiments, or embedded software projects that require simple numerical calculations.
CCMake2023Random Particle Optimization
2021An implementation of a Genetic Algorithm in C. Genetic Algorithms, often abbreviated as GAs, are adaptive heuristic search algorithms inspired by natural selection and genetic evolution. They are commonly used to solve optimization and search problems by repeatedly improving a population of possible solutions over multiple generations. This project is a practice implementation of a genetic algorithm and is designed to be easy to read, understand, and experiment with. The README explains the working of the algorithm in a very simple and beginner-friendly way, making it especially useful for students and developers who are learning how evolutionary algorithms work and how they can be implemented in software. In this implementation, a gene is represented as a single character, while a genome is represented as a collection of characters. The program takes a target string as input and tries to evolve randomly generated genomes until one of them matches the target. Each genome is assigned a fitness score based on how closely it matches the target string. A perfect match has a fitness score of zero, while less accurate genomes receive lower scores. The algorithm begins by creating two random parent genomes and a configurable number of offspring genomes. During each generation, the parent genomes are mated to produce offspring. Mating is performed using a single-point crossover, where part of one parent is combined with part of the other parent. A small random mutation may also be applied to prevent the search from getting stuck too early and to introduce variation into the population. After the offspring are generated, their fitness values are calculated and the population is sorted. The two fittest offspring are selected as the new parents for the next generation. This process continues until the best genome converges to the target string or the iteration limit is reached. The project is organized into separate modules for application initialization and genetic algorithm utilities. It also includes unit tests for important functions such as genome initialization, copying, mutation, mating, random number generation, sorting, and fitness calculation. This helps validate the algorithm implementation itself, not just demonstrate it. Overall, this project is a compact and educational example of a genetic algorithm in C. It is useful for learning about evolutionary computation, optimization concepts, string evolution, randomness, fitness functions, and practical software implementation of algorithmic ideas.
C++MATLAB2021C Asserts
2023`c_asserts` is a compact C assertion and unit-test helper library. It provides a small framework for writing test functions, running them, reporting pass/fail status, and printing a summary at the end of a test suite. Instead of requiring a large external testing framework, it gives C projects a lightweight way to structure tests around simple macros and a small runtime implementation. The library is organized around two main parts: a public header, `c_asserts.h`, and an implementation file, `c_asserts.c`. The header defines the central result type, `unit_test_result_t`, with outcomes for passed, failed, and not-implemented tests. It also defines `test_environment_t`, which stores aggregate counts for passed, failed, not-implemented, and total tests. Tests are normally declared with `TEST_JIG`, initialized with `UT_BUILDUP`, cleaned up with `UT_TEARDOWN`, executed with `TEST`, and wrapped between `UT_START()` and `UT_END()`. Assertions are implemented as macros that call internal helper functions while automatically passing `__func__`, `__FILE__`, `__LINE__`, and the string form of the tested expression. This lets the library print useful diagnostics showing where a failure occurred and what expression failed. Hard assertions such as `ASSERT_TRUE`, `ASSERT_FALSE`, `ASSERT_INT`, `ASSERT_UINT`, `ASSERT_UINT64`, `ASSERT_UINT_RANGE`, `ASSERT_PTR`, `ASSERT_MEMORY`, and `ASSERT_SUBTEST` set the current test result to failed and jump to a `cleanup` label when they fail. This cleanup label is supplied by `UT_TEARDOWN`, so tests can still release resources before returning. The header also exposes soft assertion variants, which report failures but do not immediately abort the current test. The implementation file contains the actual comparison logic and formatted output. It uses ANSI color codes for passed, failed, not-implemented, and summary messages. Integer assertions print expected and actual values, unsigned checks include hexadecimal output, range checks clamp the accepted bounds safely, pointer checks print addresses, and memory checks compare byte buffers with `memcmp`, report the first differing offset, and print a limited byte-by-byte dump. There are also bit-reading helpers for extracting single bits or bit ranges from 32-bit values. The intended use case is embedded systems, where unit testing often needs to be simple, portable, and easy to integrate into existing firmware projects. `c_asserts` is designed to make it very quick to add unit tests around embedded C modules, such as register handling, driver logic, protocol encoders, parsers, state machines, and byte-buffer operations. Its only dependency is `stdio.h` and `printf`, which keeps it lightweight and easy to port. In embedded targets where standard console output is unavailable or undesirable, the `printf` calls can be redirected or replaced with a target-specific output method such as UART logging or SEGGER RTT.
CCMake2023C Queue
2023An implementation of a queue in C, just for practicing C.
CCMake2023C Ring Buffer
2023An implementation of a ring buffer in C, just for practicing C.
CCMake2023Manifest Checker
2024A Rust-based command-line tool designed to ensure the integrity of files within a specified directory by comparing them against a manifest file. It can be useful in environments where ensuring the authenticity and integrity of firmware or software is critical.
Rust2024Power Estimator
2023PowerEstimator is a lightweight power consumption and battery life estimation tool for IoT and embedded electronic devices. It is designed to help developers, hardware engineers, and product designers quickly model the expected current consumption of a device and estimate how long it can operate from a given battery or power source. The goal of the project is to make early-stage power budgeting simple, readable, and easy to adapt to real electronics designs. The project models a device using three main concepts: `Source`, `Load`, and `Device`. A `Source` represents the available energy supply, such as a battery, with properties like capacity and voltage. A `Load` represents an electrical consumer in the system, for example a microcontroller, sensor, radio module, regulator, LED, or external peripheral. Each load can define current consumption in different operating states, such as active current during processing and sleep current during low-power operation. A `Device` combines the source and all loads, along with timing information such as cycle time and active operating time per day. Internally, PowerEstimator uses a simple duty-cycle based calculation. Each load contributes a current-time consumption value based on its active and sleep durations. These values are summed across all loads to calculate the total consumption of the complete device over a defined cycle. The tool then relates this average consumption to the available battery capacity and returns an estimated endurance value. The implementation is written in C# using clear object-oriented classes, making the calculation logic easy to understand, extend, and integrate into other .NET-based engineering tools. PowerEstimator is useful during the early design phase of battery-powered products, especially IoT nodes, wireless sensors, handheld devices, and low-power embedded systems. It can help answer questions such as: How long will this device run on a selected battery? Which component dominates the power budget? How much battery life is gained by reducing active time or sleep current? It is also useful for comparing design alternatives, validating low-power design assumptions, and documenting estimated battery performance before hardware prototypes are available. The tool is intentionally simple and transparent. It does not aim to replace detailed lab measurements, but it provides a practical first-pass estimate that can guide design decisions before committing to hardware.
C#.NET2023Serial Logger
2021Logs serial data from available COM ports for specified time, and writes them into a .csv file.
C#.NETPrism2021























