What I can do — grouped honestly by depth.

My primary language for three years of production automotive firmware and for my personal hardware projects. I write register-level peripheral drivers, bare-metal control logic, and diagnostic stacks in C — configuring registers by hand and structuring clean, testable modules.

Used for modular, non-blocking firmware where I separate hardware, application, and communication concerns into well-defined classes. My UART Command Shell is zero-allocation C++17 — std::string_view tokens, function-pointer dispatch, exception-free.

Wrote Python tooling and test-automation scripts to drive repetitive verification, parse logs, and automate checks alongside my embedded work — and now for LLM/agent workflows.

Scripted CAN/LIN test cases and simulated bus nodes in CAPL inside Vector CANoe to validate ECU communication and diagnostics.

Strong grasp of how MCUs actually work — clock trees, memory maps, interrupt vectors, peripheral registers, and the boot/startup path — which lets me bring up a new chip from a blank flash.

Comfortable debugging at the register and bus level — reading peripheral registers, stepping through startup code, and tracing signals on the wire to find the real root cause instead of guessing.

Developed and integrated AUTOSAR Classic low-level drivers (MCAL) and base software from scratch at the register level, on Tier-1 automotive programs.

Architected and implemented a complete ECU diagnostic stack to ISO 14229 — services 0x22/0x2E/0x31/0x2F/0x14/0x19 — with session concurrency, strict timing, and NVM-backed data.

Configured and integrated AUTOSAR BSW modules — diagnostics (DCM/DEM), non-volatile memory (NvM), and communication (COM/ComStack) via Vector DaVinci — and tied them into application behavior.

Worked with automotive serial protocols day to day — configuring controllers, debugging frames on the bus, and validating timing and signal behavior; built a full SENT sensor-acquisition pipeline.

Delivered work under Automotive SPICE processes with full requirements-to-test traceability across the software engineering process areas (Polarion / EWM).

Three years building production firmware on the AURIX TC36x TriCore — multicore startup, peripheral configuration, PMIC safe-state, and real-time application logic.

Bring-up and bare-metal firmware on ARM Cortex-M — configuring the clock tree, GPIO, ADC, and timers directly from CMSIS register definitions (72 MHz PLL, flash wait-states).

Personal hardware projects on STM32 (Cortex-M) and ATmega (AVR) — register-level drivers, ADC sensing, interrupt-driven timing, and actuation control.

Comfortable starting from a blank chip: writing startup code, configuring peripherals at the register level, and building the minimal driver layer an application needs.

Built real-time, deterministic application logic with priority-aware scheduling and fault handling in the automotive stack, and interrupt-driven real-time timing in my bare-metal projects.

On-target debugging — breakpoints, register/memory inspection, and assembly-level execution tracing on automotive ECUs.

CANoe for bus simulation and test (with CAPL); DaVinci for AUTOSAR configuration and RTE generation.

Configured AUTOSAR BSW/MCAL modules in EB Tresos and generated the corresponding code.

Daily version control across team projects — branching, rebase, merge, and code review with both Git and SVN.

Worked within Jenkins CI/CD pipelines and Bazel builds for automated building and testing of firmware.

Tracked work and requirements with traceability back to deliverables across the ASPICE lifecycle.

Building IoT firmware on the ESP32 in modular, non-blocking C++ — isolating sensor, WiFi, and messaging into separate layers.

Publishing sensor telemetry as JSON over MQTT, including reconnect handling and lightweight message formatting.

Connecting embedded devices to networks over WiFi/TCP and keeping the link resilient to drops.

Reading real sensors — soil moisture, temperature/humidity, and automotive SENT — and turning raw readings into calibrated, usable values.

Actively learning embedded Linux — POSIX programming, device drivers, and building images with Yocto.

Exploring lightweight ML inference on microcontrollers and edge devices — the natural fusion of my embedded core with on-device intelligence.

Building LLM-agent tooling with LangGraph and local/cloud models — including AutoEmbed, an agent that semantically merges AUTOSAR ARXML config beyond line-based git/SVN.

Deepening modern C++ (C++17/20 features) for cleaner, safer embedded and systems code.