Technical illustration of a firmware stack showing hardware abstraction, drivers, services and application layers
Firmware architecture

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.

  1. Firmware architecture

    A layered structure separating hardware access, services and application logic, so changes in one layer do not ripple through the others.

  2. Hardware abstraction

    A defined boundary between silicon-specific code and the rest of the firmware, which makes testing practical and platform changes survivable.

  3. Device drivers

    Drivers for sensors, actuators, memories, displays and communication peripherals, written against measured hardware behaviour.

  4. Real-time control

    Deterministic control loops, interrupt design and scheduling where response time is a requirement rather than a preference.

  5. Communication protocols

    Implementation of wired and wireless protocol stacks and application-level messaging, including error handling and reconnection behaviour.

  6. 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

QualityWhy it mattersHow it is engineered
DeterminismLate responses can be as bad as wrong onesTiming budgets per task, interrupt design, measurement of worst-case paths
RecoverabilityDevices fail in places engineers cannot reachWatchdogs, safe states, update rollback and defined recovery behaviour
ObservabilityUnexplained field failures are expensiveStructured diagnostics, fault codes and retrievable logs sized to the platform
TestabilityUntestable firmware decays quicklyHardware isolated behind an abstraction layer so logic can be exercised off-target
MaintainabilityProducts outlive the team that built themLayered 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.

  1. Behaviour specification

    What the device must do in every operating state, including startup, fault, recovery and shutdown — not just the happy path.

  2. Architecture

    Layer definition, module boundaries, interface contracts and the decisions about what must be deterministic.

  3. Driver development

    Hardware access implemented and verified against the real board, with measurements confirming the assumptions.

  4. Application logic

    Product behaviour built on the abstraction layer, structured so it can be tested without the full hardware present.

  5. Diagnostics and logging

    Instrumentation that makes field failures explainable, sized to fit the memory and bandwidth available.

  6. Verification

    Unit-level tests where they add value, integration tests on hardware, and timing verification under load.

  7. 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.

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.