Why Open-Source License Compliance Fails in Shipped Embedded Firmware

Embedded firmware development workstation with code, PCB design, and hardware for software license compliance.

 

Quick Overview

Problem: The license manifest exists and the SBOM is generated on every build, and the team still cannot assemble a source package for a specific firmware version already in the field.

Common failure points: Source archive taken from unpatched upstream rather than the patched tree; BSP and distro layers never released; statically linked libraries absent from the manifest; vendor binary blobs with no declared license; MIT and Apache notices stripped during packaging; a written offer that points only at a repository URL.

Where it appears: Embedded Linux CPE, routers and gateways, industrial controllers and HMIs, automotive IVI stacks, medical and laboratory devices, and connected products entering the EU market under the Cyber Resilience Act.

Engineering focus: Build-system compliance artifacts, static versus dynamic linking, patched-source completeness, SBOM scope versus corresponding-source scope, supplier blob inventory.

 

Illustrative Scenario

The scenario below is illustrative. It is a composite of patterns we see in firmware release reviews, not a single client project.

A product ships. Legal signs off on the license review. The Yocto build emits a license manifest, an SPDX document, and a source archive, and all three go into the release package.

Later, a European distributor forwards a written request for the corresponding source code of one specific firmware version in the field. The archive exists and turns out to be incomplete: it holds unpatched upstream tarballs, because the build was configured with ARCHIVER_MODE[src] = "original", copied from a documentation example years earlier. The kernel patches applied by the BSP team are not in it. The kernel configuration is not in it. The meta-layer holding the recipes, patches, and machine configuration was never a release deliverable at all.

Alongside that, a compression library had been linked statically into a proprietary daemon and appears in neither the manifest nor the archive; the Wi-Fi blob from the SoC vendor carries no license file and no version string; and the URL in the written offer points at a repository that has been rewritten since the build.

None of this is a legal failure. Legal reviewed what engineering handed over. What was never engineered is the path from a specific binary back to the sources and scripts that produced it — and that path is what the license asks for.

Wrong Assumption

The assumption behind most late-stage compliance work is that a component inventory is the compliance deliverable. An inventory answers what is in the image. GPL-2.0 section 3 asks for something different: the complete corresponding source code for the covered work, plus the scripts used to control compilation and installation of the executable. That is a question about artifacts, not about lists, and the artifacts live in the build system.

A clean rebuild from the published package is not the legal standard — GPL-2.0 does not require a bit-identical binary. It is the most reliable test of whether the package is complete, which is a different and more useful thing. If nobody can rebuild from it, something is missing, and the rebuild tells you what. LGPL-2.1 then asks a second question that no inventory answers either, because the answer is set by the linker. And MIT, BSD, and Apache-2.0 ask a third: whether the notices survived packaging.

Why It Fails

The archive is generated from the wrong source state. The Yocto documentation example for releasing source is INHERIT += "archiver" with ARCHIVER_MODE[src] = "original", which produces unmodified upstream source. That covers the requirement to provide unmodified source and nothing past it. Corresponding source for a patched component needs "patched" — and, separately, the recipes, patches, and layer configuration that drove the build. Yocto's documentation is explicit that releasing the build system and the layers used during the build is how the compilation-scripts-and-modifications requirement is met, and that a BSP or distro layer used to patch, compile, package, or modify open-source software in the image may itself need releasing under GPL-2.0 section 3 or GPL-3.0 section 1. Most teams release the tarballs and keep the layers. Reproducible firmware build pipelines are the precondition for the rebuild test being meaningful at all.

The generated artifacts do not cover static linking. This gap is documented upstream rather than inferred, and it is specific: it affects the Yocto license and archiver classes. When a package reaches the image through RDEPENDS or RRECOMMENDS and depends on a statically linked library through DEPENDS, that library appears in neither the generated license manifest nor the generated source tarballs, because both classes assume only runtime-dependency packages end up in the image. Yocto does not enable static libraries by default partly for this reason. The practical consequence is that the manifest cannot be used as evidence of what is actually linked. To establish that, read the linker map — -Wl,-Map output, or the .map files the build already produces — and reconcile it against the manifest. On RTOS and bare-metal targets static is the only model available, so this reconciliation is the whole job rather than an edge case.

The configuration decides the obligation, and nobody diffs the configuration. Treating an RTOS as “permissively licensed” is a per-project claim about a per-file fact. Zephyr is Apache-2.0, and its tree also carries GPL-2.0 scripts, a GPL-2.0-with-Runtime-Library-Exception coverage header, MIT-licensed test sources, and BSD-3-Clause OpenThread interface files. The project documents which of these are linked into firmware conditionally, gated on symbols such as CONFIG_COVERAGE_GCOV, CONFIG_HDLC_RCP_IF, and CONFIG_FUSE_CLIENT. Two builds of the same product that differ only in Kconfig can carry different obligations. A review pinned to a repository rather than to a configuration will not see that.

Vendor blobs arrive without metadata, and no build system can invent it. NPU firmware, Wi-Fi and Bluetooth blobs, GPU microcode, and ODM middleware enter the image as opaque files. If the build system does not know a blob as a package, neither the manifest nor the SBOM will list it. Yocto provides NO_GENERIC_LICENSE for packages such as linux-firmware precisely because their licensing is a per-file patchwork that does not map onto a common license file. At that point the gap stops being an engineering problem and becomes a supplier-contract problem.

The SBOM answers a different question than the license does. An SBOM and a corresponding-source package are not substitutes: different scope, different depth, different audience. Yocto's own documentation notes that its SPDX output can be used to meet license compliance requirements except for sharing the build system and layer sources — which is exactly the part teams omit. Generating SPDX on every build is good practice and strong evidence of component knowledge. It is not what a source request asks for.

Hidden System Complexity

upstream component → recipe metadata (LICENSE, LIC_FILES_CHKSUM) → applied patches → Kconfig / PACKAGECONFIG selection → linking model → image → license manifest / SPDX / source archive → notices in the shipped package → written offer and hosting → a recipient's request, years later

A gap visible at the last step usually originates four or five steps earlier. A missing LIBFOO_LICENSE on a custom Buildroot package surfaces as the word unknown in a manifest a reviewer skims. A DEPENDS on a static library surfaces nowhere. A Kconfig symbol flipped during a performance pass quietly pulls in a differently licensed file.

The build system does give one real automated gate, and it is narrower than people assume. LIC_FILES_CHKSUM stores a checksum of the license text in each recipe's source and fails the build when upstream changes it. It is mandatory for every recipe whose LICENSE is not CLOSED, and it catches relicensing early. It says nothing about linking, archiving, or what the shipped package contains. The structural choice underneath — vendor SDK, Buildroot, Yocto, or PetaLinux — sets the ceiling on which artifacts can be automated.

Buildroot makes the same point from the other side. make legal-info collects a manifest, license texts, and source archives into output/legal-info/, and writes a README warning about relevant material it could not save. The manual states that the output is built from declarative statements in package recipes, that it deliberately produces more than strict compliance requires, and that you or your legal department have to check it before using it as a compliance delivery. The warning file is the most useful artifact in the directory and the least likely to be read.

On RTOS the tooling exists and is narrower. Zephyr generates SPDX through west spdx — enable CONFIG_BUILD_OUTPUT_META, build, then run west spdx -d BUILD_DIR, which writes app.spdx, zephyr.spdx, build.spdx, and modules-deps.spdx into BUILD_DIR/spdx/ with file hashes and SPDX-License-Identifier data, SPDX 2.3 by default and 3.0 on request. Two caveats worth knowing: --init is deprecated from Zephyr 4.5 and is removed in 5.0, and the documents cover what was compiled into the image — a separately built bootloader such as MCUboot needs its own.

Failure Patterns

Pattern 1 — The package that cannot be built from. A source request arrives for a shipped version. The package was generated automatically and contains unpatched upstream trees, no kernel configuration, and no layer sources. Nobody detects this until someone outside the company tries to use it, because nobody inside the company ever has.

Pattern 2 — Secure boot meeting GPL-3.0. A product enforces signed firmware with a manufacturer-held key and ships a GPL-3.0 component. Under section 6, where the product qualifies as a User Product, conveying the object code triggers an obligation to provide Installation Information sufficient to install and run a modified version — and anti-tivoization terms prohibit using technical measures to block modified versions from running. Whether a given device is a User Product is a real threshold question, and it separates a consumer router from an industrial controller sold only into plant environments. Either way the resolution is architectural: a defined, documented path by which a modified component can be installed where the license requires it. Linux itself is GPL-2.0-only and carries no such requirement, so when this bites it usually arrives through an application or library. The secure boot and signed update architecture has to be decided with the component licenses already on the table.

Pattern 3 — The component the build never declared. A driver was copied from a vendor reference tree into the product repository. No package, no recipe, no manifest entry, no SBOM line. Black Duck's 2026 OSSRA report, across 947 audited codebases in 17 industries, puts 17 percent of open-source components entering codebases outside standard package managers — copy-pasted snippets, direct vendor inclusions, and AI-generated code — and finds license conflicts in 68 percent of codebases, up from 56 percent. Those figures describe Black Duck's sample rather than embedded firmware specifically, and no public dataset breaks firmware out. The mechanism, though, is the one embedded teams recognise: the vendor BSP drop and the copied driver. Scanning the build cannot find what the build never knew about, which is why binary analysis of the final image belongs alongside build-time generation. That reconciliation is the subject of embedded software supply chain security.

Firmware Release & Open-Source Dependency Review

Incomplete source packages, unmapped static dependencies, undeclared vendor blobs, and secure boot in tension with GPL-3.0 are build-system and architecture problems, not legal-review problems. The review has a defined scope: reproduce one shipped build from the published package, reconcile the linker map against the license manifest, enumerate vendor-supplied binaries and their provenance, and check the release artifacts a recipient would actually receive. Promwad engineers embedded Linux and RTOS firmware, BSPs, and build systems, and runs product-level security audits that produce SBOMs and CVE mapping as release artifacts.

Discuss a Firmware Release Review →

Engineering Experience Across Embedded Linux and RTOS Platforms

 

Two Firmware Audits Where the Component Inventory Was the Starting Point

Promwad has run product-level firmware audits where SBOM generation and CVE mapping were explicit scope items. In both, the inventory was where the work began rather than where it ended.

On a residential and small-business router built on the Realtek RTL9615C platform running OpenWrt and prplOS, an OEM preparing to ship into European markets needed its product-level security posture validated. The audit covered hardware and schematic review, firmware analysis with SBOM generation and CVE identification with mitigation mapping, protocol and attack-surface analysis, and targeted security testing. The output was a structured view of firmware-level risk tied to a specific build, with recommendations for the next release that took CRA expectations into account.

On an industrial system built on a Microchip VSC7558, the cybersecurity audit combined SBOM and CVE analysis with threat modeling against MITRE EMB3D and a compliance matrix against IEC 62443-4-2. Findings included the absence of secure boot and open JTAG and UART interfaces, with remediation recommendations covering firmware signing and a cryptographically verified update mechanism.

What both have in common: producing the component inventory is the cheap part. Establishing that it corresponds to a specific shipped binary — static dependencies and supplier blobs included — is an audit of the build system itself. Teams routinely budget the first and not the second.

Network router and industrial controller undergoing embedded firmware compliance and security audits.

Solution Approach

Step 1: Test the package by building from it. Pick one shipped firmware version. Hand the published source package to an engineer who did not build it and ask them to produce a working image from a clean machine. Everything the team believes about its position is a hypothesis until that run completes, and the run reliably surfaces the missing layer, the missing configuration, and the patches that exist only in a working tree.

Step 2: Fix the archiver configuration, then handle what it does not cover. Set ARCHIVER_MODE[src] = "patched" with ARCHIVER_MODE[diff] = "1" and ARCHIVER_MODE[recipe] = "1", and publish the layers alongside the tarballs. Review COPYLEFT_LICENSE_INCLUDE and COPYLEFT_LICENSE_EXCLUDE rather than leaving them at defaults. Enable COPY_LIC_MANIFEST, COPY_LIC_DIRS, and LICENSE_CREATE_PACKAGE so license texts travel with the image. Then reconcile the linker map against the manifest to find the static dependencies neither class reports.

Step 3: Make the linking model a design decision. Under LGPL-2.1 section 6(a), a statically linked application has to be accompanied by the complete machine-readable “work that uses the Library” as object code and/or source code, sufficient for the user to relink against a modified library. Dynamic linking takes the section 6(b) route instead — a suitable shared-library mechanism — but it is not automatic: the device has to actually permit a compatible modified library to be used, which read-only rootfs, verified-boot policy, or a fixed library path can prevent. Where static linking is forced by the platform, substitution is often cheaper than discharge: musl (MIT) in place of uClibc-ng (LGPL-2.1), Mbed TLS (Apache-2.0) in place of a GPL-or-commercial TLS stack. Those are architecture decisions with footprint and API consequences, which is why they belong in kernel and system design rather than in a pre-release checklist.

Step 4: Pin the SBOM to the build. Yocto inherits create-spdx by default through INHERIT_DISTRO and emits SPDX JSON into tmp/deploy/images/MACHINE/ on every image build. Scarthgap (5.0 LTS) emits SPDX 2.2 with 3.0 as opt-in; Styhead (5.1) and later emit 3.0 by default, and support for 2.2 is dropped in 6.1. If you are on a release that has them — SPDX_INCLUDE_KERNEL_CONFIG and SPDX_INCLUDE_PACKAGECONFIG arrived in Yocto 6.0 and were backported into 5.0.15, and both apply to SPDX 3.0 output only — turn them on, so the kernel CONFIG_* set and the PACKAGECONFIG features that selected the components are recorded with them. An SBOM generated once at launch misrepresents the fleet within a quarter, because CRA-driven patching keeps the component set moving.

Step 5: Check the notices, not just the components. MIT and BSD require the copyright notice and the license text to accompany distribution. Apache-2.0 section 4 adds that you must pass on a copy of the license, keep existing copyright, patent, trademark, and attribution notices in the source, and — where the original work ships a NOTICE file — reproduce its attribution content in the distribution. Not every Apache project has a NOTICE file; the obligation only attaches where one exists, so this is a per-component check rather than a blanket rule. In firmware the usual failure is mechanical: a build strips comments, or the notices are collected into a directory that the final image recipe never installs. A device with a web UI can satisfy this through an open-source-notices page; a headless device has to carry it in the accompanying documentation.

Step 6: Close the supplier gap contractually. Require SBOMs and license declarations for every binary blob and ODM-supplied component as a delivery condition, in the same contract that specifies the hardware. This is the only step engineering cannot complete alone, and the one most often deferred past the point where there is still commercial leverage.

What to Check and What to Ship With the Release

Obligation

What to check

What ships with the release

GPL-2.0 §3

Can an outsider build an image from the published package?

Patched source, kernel config, recipes, patches, layer sources, build instructions

GPL-2.0 §3(b)

Is the written offer valid for at least three years, and does it name a medium?

An offer that stands on its own, with hosting that outlives the repository

LGPL-2.1 §6

Linker map reconciled against the manifest; can a modified library be used on the device?

Static: application object and/or source code for relinking. Dynamic: a working replacement path

GPL-3.0 §6

Is the product a User Product? Does signed boot block modified components?

Installation Information, or a documented architectural path, where the condition applies

MIT / BSD / Apache-2.0

Do notices survive the build, and does the image actually install them?

License texts, copyright notices, and NOTICE content where the upstream project has one

CRA Annex I, Part II(1)

Is the SBOM regenerated per firmware release and versioned with the binary?

Machine-readable SBOM covering at least top-level dependencies

Vendor blobs

Is every binary in the image traceable to a supplier, version, and terms?

Supplier SBOMs and license declarations obtained under contract

Real Trade-offs

Dynamic linking versus footprint. Dynamic linking is the cleaner route through LGPL section 6(b) and costs image size, a dynamic linker, and startup time on constrained targets. Static linking is smaller and faster and moves the obligation onto you.

Archiving everything versus archiving what is required. Archiving all sources is simple and defensible and produces very large directories — Yocto warns about the size, and Buildroot deliberately produces more than strict compliance requires, including source for BSD-licensed packages you need not redistribute. Filtering to copyleft only is smaller and introduces a filter that can be wrong.

GPL-3.0 components versus locked-down boot. Keeping GPL-3.0 out of a signed-firmware product avoids the Installation Information question and narrows the component choices available to the firmware team. Supporting a modified-component install path satisfies it and widens the threat model. No configuration gets both for free.

Build-time SBOM versus binary analysis. Build-time generation is accurate because it reads the inputs that produced the image, and it only sees what the build system declared. Binary scanning of the final firmware catches blobs and copied code the build never knew about, and it guesses at versions. Mature programs run both; the difference between them is the interesting part.

Substituting a license versus keeping the component. Replacing an LGPL library with a permissively licensed equivalent removes the obligation and costs API migration and revalidation. Keeping it and discharging the obligation costs process. On a ten-year service life, process cost compounds and migration cost does not.

Typical Review Tasks

Build-System and Release-Artifact Check

Reviewing archiver and license-class configuration, layer release scope, patched-source completeness, and whether notices survive into the shipped image.

SBOM and CVE Pipeline Integration

SPDX or CycloneDX generation wired into CI, versioned per firmware release, with CVE mapping against components actually present in the build.

Linking and Dependency Review

Reconciling the linker map against the license manifest, identifying LGPL exposure, and defining substitution or relinking paths where static linking is unavoidable.

Supplier and Blob Inventory

Enumerating vendor firmware, microcode, and middleware, establishing version and license provenance, and defining the contractual requirements that close what engineering cannot.

Qualifying Symptoms

  • No one has ever built an image from the published source package for a shipped firmware version.
  • The archiver configuration was copied from a documentation example and has not been reviewed since.
  • BSP or distro layers holding patches and machine configuration are not part of any release deliverable.
  • Nobody can list which dependencies are statically linked, and the linker map has never been read against the manifest.
  • Vendor binaries are in the image with no version, no license file, and no SBOM entry.
  • The written offer points only at a repository URL that has since been rewritten or rehosted.
  • License texts and NOTICE content are collected by the build but not installed into the final image.
  • The product enforces signed firmware with a manufacturer-held key and ships GPL-3.0 components.
  • The SBOM is generated at launch and not regenerated per firmware release.
  • A customer, distributor, or acquirer has asked for source and assembling the answer took more than a week.

What to Do Next

At this stage the work is a build-system and architecture review, not another pass over the component list. In practice: build one shipped image from the published package, correct the archiver and layer release scope, reconcile the linker map against the manifest, decide the linking model deliberately, check that notices reach the image, and pin SBOM generation to every build rather than to every launch.

The regulatory layer sits alongside this rather than above it. How the EU Cyber Resilience Act reshapes embedded device engineering covers the obligation set driving SBOM adoption in firmware teams; embedded software supply chain security covers verifying an SBOM against the final firmware rather than against the build manifest; and embedded security engineering is where SBOM maintenance, CVE monitoring, and patch delivery across the CRA support period get implemented.

Where the build system itself is the problem — non-reproducible builds, drifting BSP baselines, patches living on one machine — the failure sits upstream of compliance entirely. That is the territory of embedded toolchains breaking after board bring-up, and no artifact generated on top of an unreproducible build can be shown to correspond to anything.

Where This Shows Up in Practice

This pattern concentrates in CPE, router, and gateway programs on OpenWrt or prplOS, in industrial controllers and HMIs on Yocto or Buildroot, and in products entering regulated European markets, where license artifacts and CRA documentation are treated as release-phase paperwork rather than as build-system outputs defined at architecture time. Promwad has been engineering embedded systems since 2004, including OpenWrt and prplOS-based platforms as a prpl Foundation member.

FAQ

What exactly counts as corresponding source for a firmware binary?

 

GPL-2.0 section 3 asks for the complete corresponding source code for the covered work plus the scripts used to control compilation and installation of the executable. For a patched component that means the source in the state that was compiled, the configuration that selected the compiled feature set — the kernel .config for a Linux component — and, in a Yocto build, the layers that hold the recipes, patches, and machine and distro configuration, not just a tarball. An unpatched upstream tarball does not satisfy the obligation if you patched the component. Distribution is either alongside the binary under section 3(a) or through a written offer valid for at least three years under 3(b); a bare repository URL is a convenience rather than a section 3(b) offer in itself, so the offer text and the hosting commitment both need to stand on their own.
 

Does an SBOM satisfy our open-source license obligations?

 

No. The CRA requirement, in Annex I, Part II, point (1) of Regulation (EU) 2024/2847, is an SBOM in a commonly used, machine-readable format covering at the very least the top-level dependencies of the product. It names no format, mandates no license field, and requires no publication. The Commission may specify format and elements by implementing act under Article 13(24) and has not yet done so, which is why BSI TR-03183-2 remains the most concrete technical interpretation available. Reporting obligations apply from 11 September 2026 and the main requirements from 11 December 2027. GPL-2.0, separately, asks for buildable corresponding source for the covered work. An SBOM shows you know what is in your product; it is not the package a source request asks for.
 

Why does static versus dynamic linking change what we owe under the LGPL?

 

LGPL-2.1 section 6 requires that a user be able to modify the library and relink to produce a modified executable. Section 6(a) covers the static case: supply the complete machine-readable “work that uses the Library” as object code and/or source code, together with the library source, so the user can relink. Section 6(b) covers the dynamic case through a suitable shared-library mechanism — but that only works if the device actually lets a compatible modified library be used, which read-only rootfs, verified boot, or a fixed library path can prevent. So dynamic linking is the easier route, not an automatic pass. On RTOS and bare-metal platforms there is no dynamic linker, so section 6(a) applies whenever LGPL components are present, and substitution before the dependency is baked in is usually the cheaper answer.
 

We ship a signed-firmware device. Does GPL-3.0 block secure boot?

 

It does not block it, and the obligation is conditional rather than universal. GPL-3.0 section 6 requires Installation Information when object code is conveyed in or with a User Product — broadly, consumer goods or anything normally used for personal, family, or household purposes — so a home router and an industrial controller sold only into plant environments are not in the same position, and the classification is worth settling early rather than assuming. Where the condition applies, the requirement is information sufficient to install and run a modified version, and anti-tivoization terms prohibit using technical measures to prevent modified versions from running. The practical answer is an architected install path for a modified component, decided alongside the key and boot-policy design, rather than a late decision about handing over signing material. The Linux kernel is GPL-2.0-only and carries no Installation Information requirement, so this usually arrives through an application or library rather than through the kernel.
 

Our RTOS is permissively licensed. Are we in the clear?

 

Not on the kernel's license alone. FreeRTOS is MIT and Zephyr is Apache-2.0, and neither propagates to components the firmware pulls in alongside them. Zephyr's own licensing documentation lists files in its tree under GPL-2.0, GPL-2.0 with Runtime Library Exception, MIT, BSD-2-Clause, and BSD-3-Clause, with notes on which are linked into firmware and under which configuration symbols. Permissive also does not mean obligation-free: MIT and BSD require the notice and license text to accompany distribution, and Apache-2.0 section 4 requires passing on the license, retaining notices in the source, and reproducing NOTICE attribution content where the upstream project ships such a file. Separately, Apache-2.0 and GPL-2.0 cannot be combined in one binary — Apache-2.0's patent termination clause is an additional restriction GPL-2.0 does not permit — while Apache-2.0 is compatible with GPL-3.0. The useful question is never what the RTOS is licensed under but what is in this build, how it is linked, and which configuration selected it.
 

Who can enforce these obligations against us?

 

Not only copyright holders, and that is the practical shift. The clearest example for firmware teams is a German case concluded in Berlin on 24 June 2024, in which an individual purchaser of a FRITZ!Box 4020 router — not a copyright holder — obtained the complete source and the scripts controlling compilation and installation for the LGPL-2.1 components in its firmware, including uClibc, libblkid, libexif, and libosip2. Manufacturer AVM supplied the remaining material during the proceedings, the court awarded roughly €7,500 in legal costs, and AVM did not appeal. Separately, the Paris Court of Appeal held in February 2024 that a GPL-2.0 breach could be treated as copyright infringement rather than mere breach of contract, with damages in the hundreds of thousands of euros. The engineering consequence is independent of how any single case ends: the release package has to survive a request from an ordinary purchaser, not only a claim from an upstream developer.
 

Related Engineering Cases

Discuss a Firmware Release Review

Share your build system, the licenses in your image, how your components are linked, and what a source request would currently return. We will scope the build, dependency, and release-artifact check.

Tell us about your project

We’ll review it carefully and get back to you with the best technical approach.

All information you share stays private and secure — NDA available upon request.

Prefer direct email?
Write to info@promwad.com

Secured call with our expert in 24h
Secured call with our expert in 24h
Embedded in your team, end-to-end engineering
Embedded in your team, end-to-end engineering
22 years of engineering expertise
500+ projects for OEMs in EU & US
500+ projects for OEMs in EU and US
22 years of engineering expertise
MVP in 8–10 weeks
MVP in 8–10 weeks — predictable delivery
Featured at IBC, Embedded World, MWC
Featured at IBC, Embedded World, MWC