Close
0%
0%

OpenHMI — From UI Idea to Real Embedded Hardware

Turning sketches, Figma designs and HMI ideas into working embedded prototypes — and exploring the path to production hardware.

Similar projects worth following
0 followers
OpenHMI tests a path from sketches, Figma designs and existing prototypes to real embedded HMI hardware.

Idea / Sketch / Figma → Requirements → HMI Definition → GUI → Embedded Hardware → Working Prototype → Production Architecture.

We explore display, MCU/MPU/SoM, LVGL/Qt, memory, I/O, boot time, lifecycle, volume and production cost. A prototype platform is a starting point; production may keep the SoM, use another module or require a custom board.

Project #1 starts from UI definition and identifies missing engineering requirements before moving toward LVGL/UIBuilder and an ArtInChip D133 EVB. Results are still to be demonstrated.

Have an HMI idea? A sketch, Figma UI, photo, block diagram or prototype is enough for evaluation. For a suitable case, we will help define the architecture and may build a small proof-of-concept.

https://openhmi.network

Why this project?

Building an embedded product with a screen often starts in a very different place from where the engineering ends. The starting point may be a sketch on paper, a Figma screen, a photo of an existing product, a Raspberry Pi or SoM prototype, or simply an idea for what the product should do.

Turning that into a real embedded product requires decisions about the display, MCU/MPU/SoM, LVGL/Qt, memory, interfaces, boot time, lifecycle, volume and production cost. OpenHMI is an experiment in connecting these steps.

Idea / Sketch / Figma → Requirements → HMI Definition → GUI → Embedded Hardware → Working Prototype → Production Architecture

What we are testing

The interesting part isn't simply getting another LVGL demo running. We want to test whether an incomplete product idea can be turned into a useful engineering definition.

For example, “I want a touchscreen controller for a machine” may become a set of requirements: a 7-inch display, capacitive touch, CAN + Ethernet, Linux or RTOS, GUI performance requirements, a boot-time target, enclosure constraints, annual volume, lifecycle requirements and a production cost target. These are questions to resolve, not assumptions to lock in.

Principle: a current architecture is not always a product requirement

A Raspberry Pi, development board or SoM may be perfect for a prototype. When the product moves toward production, we should evaluate whether to keep the SoM, use a more optimized module, or design a custom SoC board. The choice should follow the product's requirements and engineering tradeoffs.

First case: Figma → Embedded Hardware

Project #1 starts from a UI definition rather than a hardware platform. The experiment is to extract screen structure, layout, navigation and visual assets; identify the missing engineering requirements; and bring the interface onto real embedded hardware.

The planned path is toward LVGL/UIBuilder and an ArtInChip D133 EVB. This first case will document the decisions and gaps along that path; a working result is still to be demonstrated.

Have an HMI idea we can test?

I'm looking for a few real HMI examples to test this workflow. You don't need a complete specification. A sketch, Figma design, photo, block diagram or existing prototype is enough.

If the project is a good fit, we'll first help define the HMI architecture and may build a small proof-of-concept on real embedded hardware.

https://openhmi.network

  • Can a Figma UI become a real embedded HMI?

    David Du • 5 hours ago • 0 comments

    This test starts from a UI definition rather than a hardware platform.

    Figma can tell us the screen structure, layout, navigation and visual assets. It does not define the machine logic, I/O, CAN/GPIO behavior, startup state, boot-time target, temperature range, annual volume or lifecycle requirements.

    The first engineering task is to identify those missing pieces and turn the design into an engineering definition. What should each control do? What data reaches each screen? What happens before the machine is ready, or when a connection fails? Which performance and hardware constraints must the interface satisfy?

    The OpenHMI experiment will use that definition to move toward LVGL/UIBuilder and real ArtInChip D133 hardware. We will document the assumptions, integration decisions and measured results as the work progresses.

    Have a Figma UI, sketch or existing prototype with a screen? Share it for evaluation. An incomplete idea is a useful starting point.

    https://openhmi.network

View project log

Enjoy this project?

Share

Discussions

Does this project spark your interest?

Become a member to follow this project and never miss any updates