Overview
Software written against real hardware, not an abstraction of it
Firmware inherits every property of the board it runs on: supply behaviour at brown-out, peripheral quirks, interrupt latency, clock accuracy, memory limits and the physical realities of the sensors and actuators attached to it.
We write firmware with those properties in front of us. Hardware access is isolated behind a defined abstraction layer so the application logic is testable and portable; timing-critical paths are identified and protected; and failure behaviour is designed rather than discovered.
Diagnostics are treated as a first-class feature. A product that can tell you what it was doing when it failed costs far less to support than one that cannot.
Firmware scope
What we build at the firmware layer
Structured layers rather than a single body of code, so the system stays maintainable as it grows.
-
Firmware architecture
A layered structure separating hardware access, services and application logic, so changes in one layer do not ripple through the others.
-
Hardware abstraction
A defined boundary between silicon-specific code and the rest of the firmware, which makes testing practical and platform changes survivable.
-
Device drivers
Drivers for sensors, actuators, memories, displays and communication peripherals, written against measured hardware behaviour.
-
Real-time control
Deterministic control loops, interrupt design and scheduling where response time is a requirement rather than a preference.
-
Communication protocols
Implementation of wired and wireless protocol stacks and application-level messaging, including error handling and reconnection behaviour.
-
Bootloaders and updates
Field update mechanisms with integrity checking and recovery paths, because a device that can be bricked in the field eventually will be.
Beyond the feature list
What we design for beyond the feature list
| Quality | Why it matters | How it is engineered |
|---|---|---|
| Determinism | Late responses can be as bad as wrong ones | Timing budgets per task, interrupt design, measurement of worst-case paths |
| Recoverability | Devices fail in places engineers cannot reach | Watchdogs, safe states, update rollback and defined recovery behaviour |
| Observability | Unexplained field failures are expensive | Structured diagnostics, fault codes and retrievable logs sized to the platform |
| Testability | Untestable firmware decays quickly | Hardware isolated behind an abstraction layer so logic can be exercised off-target |
| Maintainability | Products outlive the team that built them | Layered structure, documented interfaces and readable, reviewed code |
Firmware process
How firmware is specified, built and proven
Written to be maintained by whoever inherits it, including us in three years.
-
Behaviour specification
What the device must do in every operating state, including startup, fault, recovery and shutdown — not just the happy path.
-
Architecture
Layer definition, module boundaries, interface contracts and the decisions about what must be deterministic.
-
Driver development
Hardware access implemented and verified against the real board, with measurements confirming the assumptions.
-
Application logic
Product behaviour built on the abstraction layer, structured so it can be tested without the full hardware present.
-
Diagnostics and logging
Instrumentation that makes field failures explainable, sized to fit the memory and bandwidth available.
-
Verification
Unit-level tests where they add value, integration tests on hardware, and timing verification under load.
-
Release and maintenance
Versioning, release notes, update mechanism and the documentation needed to support the product after launch.
Applications
Firmware we develop
Firmware we develop
- Control firmware for motors, actuators and power stages
- Sensor acquisition and signal processing firmware
- Communication firmware for wired and wireless interfaces
- Bootloaders and secure field update mechanisms
- Diagnostic, configuration and production-test firmware
- Firmware modernisation for existing products
Working practice
- C / C++
- RTOS
- Bare metal
- Drivers
- Bootloaders
- Protocol stacks
- On-target testing
FAQ
Firmware development questions
The questions that usually decide how a firmware engagement is structured.
Yes. We start by reading the schematic and measuring the board, because firmware written against a datasheet rather than the actual hardware is where a lot of project time disappears.
A mix: logic that can be isolated is tested off-target, hardware-dependent behaviour is tested on the real board, and timing behaviour is verified under load rather than in isolation. The balance depends on the product and its risk profile.
Yes. Source, build instructions, documentation and the toolchain configuration are delivered so your team can build and maintain the firmware. Licensing and IP terms are agreed at the start of the project.
Often, but it depends on the memory layout, bootloader and connectivity available on the current hardware. It starts with an assessment of what the existing platform can support.
Yes. The applicable standard is agreed per project based on the product and sector. Specific certified process claims are not made unless independently confirmed: [CLIENT TO PROVIDE].
Need firmware that will still be maintainable in five years?
Tell us about the hardware and the behaviour it has to deliver. We will outline the architecture we would use.