Yocto and board support packages
Reproducible embedded Linux images built with Yocto, BSPs for your carrier board, and a kernel maintenance plan that outlives the first release.
Edge Hardware
Firmware and boards built to last a decade
We write the embedded Linux, drivers, camera pipelines and microcontroller firmware — and design the boards — that put vision and sensing inside the equipment you ship. It is the same work behind every Lensnode, Pulsenode and Gatepoint we build.
The problem
The demo runs. The product doesn't, yet.
Most embedded vision projects reach us at the same point. A prototype works on a development kit, running the vendor's stock image with a camera held on by a clamp. Turning that into a product means a custom carrier board, a board support package you control, a driver for the image sensor you actually chose, and a camera pipeline that does not drop frames when the enclosure is at 50 °C.
Then come the parts customers and regulators now expect: secure boot, updates that cannot brick a unit in the field, a software bill of materials, and a plan for patching the kernel for as long as the machine is supported. Each of these is its own specialty, and small engineering teams rarely have all of them in-house.
How it works
What we build
Drivers
Image-sensor drivers over MIPI CSI-2 and V4L2, industrial I/O, Ethernet and fieldbus interfaces — written, tested and maintained in your own Yocto layers.
Camera pipelines
GStreamer pipelines from sensor to inference with zero-copy buffers, hardware encoding, and timestamps tied to triggers and encoders.
MCU firmware
Real-time firmware for sensor nodes, radios and power management — the layer that lets a wireless node run for years on one battery.
Custom PCBs
Schematics, layout, carrier boards, sensor boards and power stages, designed for manufacture and for test from the first revision.
Secure boot, A/B OTA and SBOMs
A hardware root of trust with TPM 2.0, signed images, dual partitions with automatic rollback, and a software bill of materials generated with every build.
Our own hardware
The same discipline behind our own nodes
Every Perflens product runs firmware we wrote. Pulsenode W's sampling and radio firmware is why it can reach five years on a battery at hourly sampling. Lensnode's on-board pre-processing runs in our camera pipeline. Gatepoint's secure boot and A/B updates are our own implementation, exercised on every release we ship to the field.
Equipment makers get the habits that come with that: watchdogs on every process that matters, graceful degradation when a sensor fails, updates that roll back on their own, logs that survive a power cut, and release notes that say exactly what changed. We call it boring reliability, and we mean it as a compliment.
Process
From development kit to shipping product
-
Architecture review
Requirements, platform choice, security model and support period are agreed in writing, including what happens when key parts go end-of-life.
-
Board bring-up
Carrier or sensor board designed and built, BSP and drivers brought up, and the camera pipeline running on your hardware.
-
Application and hardening
Inference, I/O and protocol integration, then secure boot, signed A/B updates, SBOM generation and a hardened default configuration.
-
Validation and production support
Environmental and long-duration testing, manufacturing test fixtures, and a maintenance plan for kernel and security updates over the product's life.
Deliverables
What you get at handover
- Source code in your repository, with Yocto layers and a reproducible build
- Hardware design files — schematics, layout, bill of materials and fabrication outputs
- Manufacturing test fixtures and scripts
- Update and signing infrastructure, documented, with your own keys
- An SBOM for every release in a standard machine-readable format
- Test reports covering thermal, power interruption and long-duration runs
- A maintenance plan for kernel, library and security updates
Platforms and tools
What we work with
- Application processors
- NVIDIA Jetson Orin and Jetson Thor, Qualcomm Dragonwing, and host processors paired with Hailo-8 or Hailo-10H
- Operating system
- Embedded Linux built with Yocto
- Microcontrollers
- Arm Cortex-M class devices, bare-metal or with a real-time operating system
- Vision and inference
- GStreamer, OpenCV, ONNX Runtime, TensorRT
- Industrial protocols
- OPC UA, MQTT with Sparkplug B, Modbus TCP/RTU, EtherNet/IP, PROFINET
- Security
- TPM 2.0, secure boot, signed A/B over-the-air updates, SBOM per build
Honest fit
When to call us
A good fit when
- You are adding vision or sensing to a machine you build and sell
- A prototype runs on a development kit and needs to become a product
- An existing product needs secure boot, signed updates and SBOMs before EU customers ask
- Your team is strong on the application but thin on embedded Linux and hardware
Probably not when
- The application runs well on a standard industrial PC — no embedded work is needed
- Safety-rated functions (SIL or PL rated) — those belong in a certified safety controller, not in our firmware
See it in context
Where embedded work shows up
Lensnode, Pulsenode and Gatepoint
Our own sensors and gateways, built on the firmware, boards and update system described on this page.
Read more
Packaging, paper & wood products
Machine builders adding inspection and condition monitoring to converting, forming and packaging equipment.
Read more
Pharma & medical devices
Equipment where traceable software, documented changes and secure updates are part of the product.
Read moreFAQ
Questions we hear often
Who owns the code and hardware designs?
You do. Source code, hardware design files and the signing keys for your product are delivered to you, in your repositories.
Can you take over an existing codebase?
Yes. We start with an audit of the build, the BSP, the update path and the security posture, then give you a written list of what to keep, fix and replace.
How do you keep a product patched for years?
Each release carries an SBOM, which we monitor against newly published vulnerabilities. A maintenance plan sets how kernel and library updates are tested and shipped through the signed update channel.
Can you help with the EU Cyber Resilience Act?
On the engineering side, yes — secure boot, signed updates, SBOMs and a vulnerability handling process. See edge and OT security for how we support CRA readiness.
Do you manufacture in volume?
We build prototypes, pilot units and small production runs. For larger volumes we deliver a manufacturing package — fabrication outputs, test fixtures and procedures — for your contract manufacturer.
Show us the development kit on your bench
Tell us what the prototype does today and where it has to ship. We'll tell you what stands between the two.