Embedded Firmware in Rust

Firmware die werkt, en werkbaar blijft

Firmware is het onzichtbare fundament van je slimme product. Het is belangrijk dat je op je firmware kan vertrouwen. Dit begint bij een goede architectuur, sterke tooling en bewuste keuzes in technologie.

PCB met JLink debugger aangesloten

De uitdaging

Met bestaande firmware

  • Je firmware werkt, maar aanpassen voelt risicovol
  • Bugs en crashes die lastig te reproduceren zijn
  • Kennis zit bij één persoon (of is verdwenen)
  • Doorontwikkelen kost steeds meer tijd

Voor nieuwe projecten

  • Je wilt in één keer een solide basis neerzetten
  • Je zoekt een architectuur die kan meegroeien
  • Je wilt snel kunnen itereren zonder instabiliteit
  • Je wilt firmware die overdraagbaar is

Wij bouwen firmware waar je op kunt bouwen. Letterlijk.

Wat we doen

Nieuwe firmware

Van scratch, op jouw hardware of op een platform dat we samen kiezen. Schone architectuur, gebouwd om mee te groeien.

Firmware bij PCB-ontwerp

We ontwerpen ook hardware. Als wij beide doen, zijn ze vanaf het begin op elkaar afgestemd.

Firmware op bestaande hardware

Je hebt al een PCB, van jezelf of van een derde. Wij schrijven de firmware die erop draait.

Hoe we werken

Programma van eisen

We stellen samen de eisen vast: wat moet het systeem doen, onder welke condities, en wat zijn de grenzen? Dat geeft richting aan alle keuzes die volgen.

Architectuur

We beginnen met een heldere software-architectuur: welke taken draait het systeem, hoe communiceren ze, en waar zitten de grenzen? Dat voorkomt spaghetti en maakt je firmware uitbreidbaar. Voor complexere projecten maken we gebruik van async Rust en het actor model om functionaliteit en verantwoordelijkheden netjes af te bakenen.

Voorbeeld van een firmware task-architectuur
Klik om te vergroten

Development environment opzetten

We richten een complete ontwikkelomgeving in: een werkende Blinky of Hello World! als startpunt, flashing tools, CI-workflows met automatische tests en een duidelijke projectstructuur. Zodat je team vanaf dag één productief kan werken.

JLink debugger aangesloten op een PCB Rust firmware in vscode

Tests en code reviews

Elke wijziging wordt getest en gereviewd. Zo vangen we fouten vroeg af en houden we de kwaliteit hoog, ook als het project groeit.

Automatische tests in Github workflows

Kennisoverdracht

Met documentatie valt of staat de toekomst van het project. We documenteren de zaken die ertoe doen: hoe bouw je de firmware, welke configuratie is belangrijk, hoe sluit je de debugger aan om te flashen, hoe zit de architectuur in elkaar, en hoe werkt een firmware-update in het veld.

Voorbeeld van documentatie
Klik om te vergroten

Wat je krijgt

  • Firmware die doet wat het moet, betrouwbaar
  • Code die leesbaar en onderhoudbaar is
  • Documentatie die je team verder helpt
  • Optioneel: begeleiding bij het zelf verder ontwikkelen

Liever firmware in C?

Kan ook. We hebben ruime ervaring met C op embedded.

Wel eerlijk: een C-project kost doorgaans meer tijd dan hetzelfde project in Rust. Niet omdat we C minder goed kennen, maar omdat het meer discipline en testwerk vraagt om dezelfde kwaliteit te halen. Dat zie je terug in de prijs.

Heb je een bestaande C-codebase die je wilt uitbreiden of onderhouden? Dan is C vaak de logische keuze. Voor nieuwe projecten adviseren we Rust, maar de keuze is aan jou.

Over ons

Jitter B.V. ontwikkelt al meer dan tien jaar firmware voor embedded systemen waarvan vijf jaar in Rust, tegenwoordig voornamelijk op STM32. Onze embedded engineers hebben de leercurve doorgemaakt en weten waar de valkuilen zitten. Die ervaring zetten we in voor jouw project.

Veelgestelde vragen

Wat kost firmware development?
Dat hangt af van de complexiteit en scope van je project. Een eenvoudig firmware-project begint rond €5.000, terwijl complexere trajecten met meerdere interfaces, protocollen of certificeringseisen €15.000 tot €40.000 of meer kunnen kosten. Na een vrijblijvend intakegesprek maken we een offerte per projectfase, zodat je vooraf weet waar je aan toe bent.
Hoe lang duurt een firmware project?
Een klein firmware-project kan soms al binnen 1 tot 2 weken. Grotere trajecten met meerdere iteraties, hardware-integratie en veldtesten kunnen 3 tot 6 maanden duren. Firmware-ontwikkeling loopt vaak parallel aan het PCB-ontwerp. We geven je aan het begin een realistische planning.
Waarom Rust in plaats van C?
Rust voorkomt op compilerniveau hele categorieën bugs die in C veel voorkomen: null pointers, buffer overflows, race conditions en use-after-free. Dat betekent minder debugging, stabielere firmware en snellere doorlooptijden. Daarnaast biedt Rust moderne tooling voor dependency management, testing en CI. Wij werken al meer dan vijf jaar met Rust op embedded en zijn er productiever in dan in C.
Kan ik de firmware later zelf onderhouden?
Ja, dat is zelfs een expliciet doel. We documenteren de architectuur, de build-omgeving en de ontwikkelworkflows. De code is leesbaar en gestructureerd zodat je eigen team ermee verder kan. Desgewenst bieden we ook begeleiding en kennisoverdracht aan.
Werken jullie ook met bestaande C-codebases?
Ja. We hebben ruime ervaring met C op embedded. Heb je een bestaande C-codebase die je wilt uitbreiden of onderhouden? Dan is C vaak de logische keuze. Voor nieuwe projecten adviseren we Rust vanwege de hogere kwaliteit en productiviteit, maar de keuze is aan jou.
Hoe werkt een firmware-update in het veld (OTA)?
OTA (Over-The-Air) updates maken het mogelijk om firmware op afstand bij te werken, zonder fysiek bij het apparaat te hoeven zijn. We implementeren dit met een veilige bootloader die de integriteit van de update verifieert voordat deze wordt toegepast.
Wat is firmware eigenlijk?
Firmware is software die direct op een microcontroller of processor draait, dicht op de hardware. Het bestuurt sensoren, communicatie-interfaces, actuatoren en andere randapparatuur. In tegenstelling tot 'gewone' software op een computer of telefoon, heeft firmware directe controle over de hardware en draait het vaak zonder besturingssysteem.
Wat is het verschil tussen firmware en software?
Firmware draait direct op de hardware (microcontroller) en heeft directe controle over fysieke componenten zoals sensoren en motoren. Software draait op een besturingssysteem zoals Windows, Linux of Android. Het verschil is niet altijd scherp: embedded Linux-systemen zitten daar ergens tussenin. Bij Jitter gebruiken we 'firmware' voor alles wat bare-metal of op een RTOS draait.
Wat is een RTOS?
RTOS staat voor Real-Time Operating System. Het is een lichtgewicht besturingssysteem voor microcontrollers dat taken met strikte timing-garanties kan uitvoeren. Denk aan het uitlezen van een sensor exact elke milliseconde, of het reageren op een interrupt binnen een vaste deadline. Bekende voorbeelden zijn FreeRTOS en Zephyr. Wij gebruiken in Rust-projecten vaak RTIC of Embassy, async frameworks die vergelijkbare functionaliteit bieden zonder de overhead van een traditioneel RTOS.
Wat is bare-metal firmware?
Bare-metal betekent dat de firmware direct op de microcontroller draait, zonder besturingssysteem ertussen. Je code heeft volledige controle over de hardware. Dit levert de laagste latency en het kleinste geheugengebruik op. Voor eenvoudigere systemen is bare-metal ideaal. Bij complexere systemen met veel parallelle taken kiezen we eerder voor een RTOS of async framework.
Wat betekent 'embedded'?
Embedded betekent 'ingebed'. Een embedded systeem is een computer die is ingebouwd in een groter apparaat en een specifieke taak uitvoert. Denk aan de elektronica in een wasmachine, een medisch apparaat of een industriële sensor. In tegenstelling tot een gewone computer is een embedded systeem ontworpen voor één doel, met beperkingen in geheugen, rekenkracht en energieverbruik.

Firmware-uitdaging waar je tegenaan loopt?

Neem contact op