Get a quote

Software

Firmware and software for hardware that has to work.

Embedded C and C++, Verilog for FPGAs, Python for test and tooling, and the signal-processing and neural-network code that turns raw sensor data into something a product can act on.

The circuit board on a bench mat, wired to a debug probe with test clips, in front of a monitor showing lines of code.
Languages
C, C++, Verilog, Python
Targets
Microcontrollers, FPGAs, desktop tools
Sensor work
Lidar and acoustic systems, including neural networks
Pricing
Fixed quote per milestone
Ownership
Source code is yours, with history

What I write

Code that sits close to hardware, and the tools around it. If I designed the board as well, the firmware and the circuit are worked out together and neither is left to compensate for the other.

Firmware
Board bring-up, peripheral drivers, communication protocols, control loops and low-power behaviour, in C or C++ on the microcontroller you have chosen.
FPGA logic
Verilog for interfaces, data paths and timing-critical glue, with test benches that prove it.
Test and production tooling
Python that exercises a board, records what it measured and gives a factory operator a clear pass or fail.
Sensor software and machine learning
Point-cloud and acoustic processing, feature extraction, and neural networks trained and evaluated on your data.
Dashboards and internal tools
Because I also build for the web: device dashboards, configuration pages and data viewers your team will use.

Sensor data is where I have spent the most time.

I have worked on sensor-suite software for lidar and acoustic products, including neural networks. The work is mostly unglamorous: calibration, timing, coordinate frames, and finding out why the output is wrong one time in a thousand.

The figure is a small version of the problem. A simulated sensor sweeps a scene, and the page labels the ground, groups the rest and measures each object, live.

Lidar point cloud · 24 beams · synthetic scene Drag to turn
Returns per sweep
–
Objects found
–
Nearest object
–
Live model A sensor simulated in your browser, and the first stages of a perception pipeline running on its output: label the ground, group what is left, fit a box to each group. The boxes are computed from the points alone. In a product, learned models take over the hard cases; the structure stays the same.

Code you can keep working on

Version control from the first day
In your repository where possible, so the history is yours.
Readable before clever
The next person to open the file should not need me in the room.
Interfaces written down
Registers, message formats and timing documented where the code lives.
Tests where they pay
Protocol parsers, maths and anything that has already broken once.
A clean handover
Build steps that work on a fresh machine and a list of what is still open.

Questions about software work

Can you work in our existing codebase?

Yes. I follow the structure, style and review process you already have, and I ask before changing any of them.

Do you only write firmware for boards you designed?

No. I am glad to write or fix firmware for an existing board. Schematics and a unit on my bench make it much faster.

How do you use AI coding tools on client work?

Where they save time, and I review and test everything they produce. Your code and data go only into tools that do not train on them. If you would rather your files stay out of AI tools, or want none used on your project at all, say so and it is written into your statement of work.

Can you train a model on our data?

Yes. The first step is always an honest look at the data: how much there is, how it was labelled and what a simple baseline already achieves. Sometimes the right answer is not a neural network, and I will say so.

How is the work handed over?

In your repository, with commit history, build instructions that work on a clean machine, and notes on anything unfinished or fragile.