Request a firmware review
Menu
Hardware startups building a connected or battery-powered device

Firmware your team can read, test and update

We write the code that runs on your device, from drivers to power states, so it builds the same way on any machine, passes its tests and can be replaced safely in the field.

Key characteristics

Runs on
Bare metal, Zephyr RTOS or FreeRTOS
Languages
C and C++, with Rust where it fits
You provide
Requirements, hardware samples and one decision owner
You receive
Source in your repository, architecture document, test reports

Application firmware is everything your device does between power-on and power-off: reading sensors, deciding when to talk, storing what it cannot send yet, sleeping, and recovering when something goes wrong. On a prototype, much of that lives in one long loop that grew a feature at a time. On a product it has to be structured so a second engineer can change it without breaking the first engineer’s assumptions, and so the version written today can be replaced in the field next year.

We write that firmware for microcontroller-based products, in your repository, with the update path planned from the first commit.

What we build

  • Drivers for the sensors, radios, memory, displays and power parts on your board, written against the datasheet and checked on your hardware, not only on an evaluation kit.
  • State machines for the behavior that matters: provisioning, measuring, connecting, updating, low battery and fault. Explicit states make the device’s behavior reviewable and testable. On Zephyr we often use its State Machine Framework; elsewhere a small table-driven design does the same job.
  • Power states for every mode the device can be in, with the transitions and wake sources written down. See low-power design.
  • Logging that survives a reset: compact records kept in flash with the firmware version and the reset reason, so a returned unit can tell you what happened before it failed.
  • Stored data with a version number, so a later release can migrate settings instead of erasing them.
  • Tests: unit tests that run on a host computer for logic, and tests on the board for drivers and timing. See test automation.

Bare metal, Zephyr or FreeRTOS

There is no single right answer, so we choose with you and write down why.

Option When it fits What to watch
Bare metal A small part doing one job, very tight memory, very simple behavior You write and maintain the scheduling, the update agent and the radio integration yourself
Zephyr RTOS Bluetooth LE, Thread or IP networking, MCUboot updates, a product that will live for years Learning curve (devicetree and Kconfig) and memory use on the smallest parts
FreeRTOS A vendor SDK built around it, or a small kernel you want to wrap your own structure around Networking, storage and update support come from libraries you assemble and keep current

Support periods matter more than most teams expect. Zephyr now ships major releases on a six-month cadence, each supported for roughly a year, and publishes long-term support (LTS) releases maintained for about five years. The current LTS, Zephyr 3.7, is supported until July 27, 2029, and the next LTS is planned as Zephyr 4.6 in April 2027. FreeRTOS LTS libraries receive security updates and critical bug fixes for two years: the 202406 LTS ended on June 30, 2026, and the 202604 LTS runs to April 30, 2028. We pick the release with you and record when it will need to move. The RTOS selection worksheet scores the options against your own constraints.

C, C++ and Rust

Most microcontroller code is C, and so are most vendor SDKs, RTOS kernels and bootloaders. We write plain, readable C by default, use C++ where your team already knows it and wants its stronger types, and use Rust where it fits: a new component with a clear boundary, a parser that handles untrusted input, or a team that already works in Rust. The Rust Embedded Working Group released embedded-hal 1.0 in January 2024, Zephyr supports Rust applications through an external module, and CISA and NSA published guidance on adopting memory safe languages in June 2025. We do not rewrite working C for its own sake.

Built to be replaced

Every firmware build we start reserves room for its successor. The flash map keeps two image slots from day one (the flash budget calculator shows the arithmetic), the version string records the hardware revision so the wrong image is refused (the version scheme builder generates one), and stored data carries a format version. Releases come from CI, never from a laptop. The update path itself is covered in over-the-air updates.

Example (fictional). Loamwick’s LW-1 probe reads soil moisture and temperature every 5 minutes and sends the readings over Bluetooth LE to a gateway. Its firmware runs on Zephyr, chosen with the RTOS selection worksheet (Zephyr 113, FreeRTOS 93, bare metal 75 of 125). The application image is 412 KB and fills 92.8% of its 448 KB slot, so the team plans to move the second slot to external flash on Rev E. Requirement FW-001, the 5-minute reading, is verified by a 72-hour bench test against a reference probe. Follow the whole story on the example project page.

How the work runs

Requirements go into a worksheet with a way to verify each one; the firmware requirements worksheet is a free version. We agree milestones with you, and each ends with a demonstration on your hardware and a short test report. Your technical lead writes a weekly status in plain English: what was done, what was measured, what is blocked and what is next. When a board revision or a requirement changes mid-build, the status says what it costs before anyone starts on it.

What you receive

  • Source code in your repository, with its full history.
  • An architecture document: tasks or threads, drivers, memory map, power states, boot flow and error handling, with the reasons behind each choice.
  • Build and flash instructions that produce the same image on any machine, and a CI build that follows them.
  • A test report for each milestone and release notes for each release candidate (the release notes builder shows the format).
  • Ownership and licensing terms as set out in your agreement.

Where to start

If you already have code, start with a firmware review: we read it with your schematics and flash layout and tell you in writing what to keep, what to change and in what order. If you are still choosing parts, the review covers that choice too. Request a firmware review, or read more in the firmware architecture section of Field Update.

Send us your board and your plan.

A firmware review reads your schematics, code, flash layout and update plan, and ends with a written plan: what to build first, what could go wrong in the field and how updates will reach your devices.

Request a firmware review

Or email sales@fumbar.com, or call (720) 675-4202.