Skip to content

Service · Devices

Embedded Software Development Services

Commission us to write the firmware and low-level software that runs on your hardware: microcontroller applications, RTOS tasks, device drivers, bootloaders and board bring-up. We work from schematics and datasheets through to firmware that passes your hardware validation.

Hardware-in-the-loop testing

Secure boot and signed images

MISRA-aware C where required

Deliverables

What an embedded software development engagement delivers.

01Delivered

Board bring-up

Clock, power, memory and peripheral initialisation on new hardware, with problems traced to schematic, layout or silicon errata.

02Delivered

Firmware application

Application logic on bare metal or an RTOS such as FreeRTOS or Zephyr, with task design, priorities and timing budgets documented.

03Delivered

Device drivers

Drivers for sensors, displays, radios and storage over SPI, I2C, UART, CAN or USB, and Linux kernel drivers where the platform runs embedded Linux.

04Delivered

Bootloader and update path

A bootloader with signed image verification and dual-bank or A/B slots, so a failed update cannot brick a unit.

05Delivered

Test harness

Host-side unit tests, hardware-in-the-loop tests on real boards and power measurements for battery-powered designs.

Early decisions

Technical decisions we settle early in embedded software development.

01Decided

Bare metal, RTOS or embedded Linux

Bare metal for simple deterministic loops, an RTOS for concurrent tasks with timing constraints, embedded Linux when networking stacks, filesystems or rich interfaces justify a larger processor.

02Decided

Microcontroller selection

Flash, RAM, peripherals and power modes checked against firmware needs before the hardware design is frozen.

03Decided

Language and coding standard

C or C++ with a standard such as MISRA C for safety-related work, or Rust where toolchain support and team skills allow.

04Decided

Power strategy

Sleep modes, wake sources and peripheral power gating designed up front, since retrofitting low power is difficult.

05Decided

Security model

Secure boot, debug port lockdown, key storage in a secure element or TrustZone, and how keys are provisioned on the production line.

Engagement

How an embedded software development engagement runs.

  1. 01Phase 1

    Hardware and requirements review

    We study schematics, datasheets and product requirements, flagging firmware risks while the hardware can still change.

  2. 02Phase 2

    Bring-up and drivers

    Early boards are brought up one peripheral at a time, with drivers verified against oscilloscope and logic analyser traces.

  3. 03Phase 3

    Application and integration

    Application firmware is built on the drivers, integrated with any companion app or cloud service and run on hardware-in-the-loop rigs.

  4. 04Phase 4

    Validation and production support

    We support environmental and EMC testing, fix what it uncovers, and supply manufacturing test firmware and provisioning tools.

Fit

When custom firmware is the right choice.

01Good fit

You are designing new hardware

Firmware written alongside the hardware catches problems before boards are re-spun.

02Good fit

Existing firmware is unmaintainable

Code from a departed contractor with no tests or documentation is a candidate for structured rework.

03Good fit

Constraints are tight

Battery life targets, hard real-time deadlines and safety standards demand specialist embedded work.

Firmware starts before the board exists

Picking a microcontroller without checking firmware needs can leave a product short of RAM or missing a peripheral. We review hardware decisions with the software in mind, so pin assignments, memory and debug access suit what will run there.

Bare metal, RTOS or Linux

A sensor node that reads once a minute and sleeps between needs nothing more than a bare-metal loop. A device juggling radio, display and sensors against deadlines benefits from an RTOS. Embedded Linux earns its power budget only when the product needs its networking and software ecosystem.

Testing on real hardware

Host-based unit tests catch logic errors, but timing, interrupt and peripheral bugs appear only on silicon. Hardware-in-the-loop rigs flash each build onto real boards and drive inputs automatically, catching regressions before they reach a prototype on someone’s desk.

Updates that cannot brick a unit

Sooner or later a device in the field loses power mid-update. A bootloader that verifies signatures and keeps a known-good image means an interrupted or malicious update leaves the unit recoverable rather than dead.

FAQ

Questions to resolve before the build.

01Which microcontrollers do you work with?

Common families including STM32, Nordic nRF, ESP32, NXP and Microchip parts, plus embedded Linux on processors from NXP, TI and others. We study datasheets for unfamiliar parts before committing to estimates.

02Do you need our hardware?

Yes. We start on development boards, then move to your prototypes, with rigs running automated tests on each firmware build.

03Can you work to safety standards?

We follow coding standards such as MISRA C and keep traceability between requirements and tests. Formal certification under IEC 61508 or similar runs through your certification body, and we support that process.

04How are firmware updates handled?

Through a signed bootloader with A/B slots or a fallback image, so a corrupted or interrupted update reverts to the last good firmware.

Primary sources

References behind this page

Dated official documentation, standards, and research that support the factual claims on this page.

  1. 01
  2. 02

How to read this page

Scope, cost and timeline figures are planning guidance until confirmed in a written proposal. Diagrams and screens are illustrations, not client deliverables, and source-code rights and handover follow the signed agreement. See the delivery process and the full disclaimer.

Next decision

Turn the brief into an accepted product scope.

Define outcomes, constraints, evidence, rights and handover before delivery begins.

Commercial rights, repositories, environments, documentation, acceptance and handover remain contract-defined.