INTUITIVE INTERFACESON BAREMETAL
Polished embedded user interfaces for products that need to feel as good as they work.
Ankh engineers the full embedded interface stack: MIPI DSI and parallel RGB display bring-up, ILI9341/ST7789/RA8875 driver development, capacitive touch integration (FT5x46, GT911, CST816D), LVGL widget customization and animation, font rendering on low-RAM MCUs, rotary encoder with velocity-based acceleration, LED design with WS2812B/APA102, haptic feedback via DRV2605L, and robust UI state machine architecture — an interface that responds within 16 ms on a Cortex-M4 with 256 KB of RAM.
What We Build
Display Integration & Driver Development
Display bring-up across MIPI DSI, parallel RGB with LTDC/DMA2D on STM32, FMC/FSMC, and SPI — with custom drivers for ILI9341, ST7789, GC9A01, SSD1306, and RA8875, including pixel format conversion and DMA transfer optimization.
LVGL Framework Implementation
LVGL widget creation, theme customization, style cascading, and animation engine configuration — custom widgets where the standard library is insufficient, rendering optimization for available frame buffer memory, and port layer (display driver, touch, tick) integrated with the RTOS scheduler.
Capacitive Touch Controller Integration
I2C initialization, interrupt-driven touch event reporting, multi-touch tracking, and gesture recognition (swipe, pinch, long-press) for FT5x46, GT911, and CST816D — with sensitivity, report rate, and noise immunity characterization for gloved operation or thick cover glass.
Physical Button & Rotary Encoder Design
Hardware debounce circuits and software state machines for single-press, double-press, and long-press detection; rotary encoder quadrature decoding with velocity-based acceleration that increases scroll speed as rotation rate increases.
LED Indicator Design & Control
WS2812B and APA102 addressable LED systems, PCA9685 PWM controllers, and discrete RGB LEDs — LED pattern language design, animation engine firmware, and legibility validation in ambient lighting conditions.
Haptic Feedback Integration
DRV2605L with ERM and LRA actuators — type and resonant frequency selected for the form factor, waveform library implemented (TI's 123 built-in effects plus custom waveforms), amplitude and duration tuned for crisp feel in the target enclosure.
Display Dimming & Power Management
Backlight PWM dimming with gamma-corrected curves, ambient light sensor auto-brightness, and display sleep/wake sequencing — current characterized at multiple brightness levels with power policy implemented in the UI state machine.
UI State Machine Architecture
Hierarchical state machine with formal entry/exit/action semantics, transition guards for power state and permissions, and a documented screen graph so future maintainers can add screens without introducing regressions.
Rendering Optimization for Low-RAM MCUs
On ≤256 KB SRAM MCUs: partial rendering with dirty-region tracking, RLE and LZ4 compressed image assets, and heap allocation strategy preventing fragmentation — profiled with DWT cycle counters to achieve consistent 30+ FPS without tearing.
How We Work
UI/UX Requirements & Hardware Constraints
SRAM, CPU/DMA bandwidth, display interface ceiling, and power budget are characterized first — these bound achievable UI complexity. User workflows, personas, and environmental conditions (sunlight legibility, gloved operation, orientation) are captured in a UI requirements document serving as the brief for graphic design and firmware.
Display & Touch Hardware Bring-Up
Display bring-up implements the controller's initialization sequence—often poorly documented—and validates operation with a test pattern before introducing any UI framework. Touch bring-up covers I2C address detection, interrupt configuration, optional firmware download (GT911), and raw coordinate validation, with oscilloscope captures documented as the production test reference.
UI Design & Asset Production
Screen layouts are designed in Figma at target resolution with pixel constraints: integer-pixel text, anti-aliasing budget, and indexed-color limits. Icons are bitmap sprites, fonts are subset and converted to LVGL format; design QA runs on actual hardware, not a desktop monitor.
LVGL Port & Widget Implementation
The LVGL port binds flush callback, touch read callback, and tick to the RTOS scheduler; frame buffer strategy is selected based on RAM budget and tear tolerance. Custom widgets are implemented as LVGL object classes with style support and animation hooks.
Interaction Model & State Machine
A hierarchical FSM routes all event sources (touch, encoder, buttons) through a unified queue on the UI task; screens are top-level states, modals and loading states are nested. Timeout states handle inactivity and errors that must interrupt any active screen without corrupting UI state.
Performance Profiling & Acceptance Testing
Frame time, touch-to-visual latency (target sub-16 ms), and CPU utilization are profiled with DWT cycle counters — typical bottlenecks are image blending and font cache misses. Acceptance testing covers all screen states, input edge cases, and power consumption at each brightness level.
The Detail Behind Premium Embedded UI
LVGL Rendering Architecture on RAM-Constrained MCUs
A full RGB565 frame buffer for a 320×240 display costs 150 KB — more than the entire SRAM of many Cortex-M0+ targets. LVGL's partial rendering is essential, draw buffer sized to DMA bandwidth to eliminate CPU stalls at flush; on STM32 targets, DMA2D routes pixel blending to Chrom-ART while assets decompress from flash.
Firmware DevelopmentCapacitive Touch: From Raw Coordinates to Gesture
The touch pipeline handles coordinate transformation, EMA jitter filtering, debounced lift-off detection, and gesture classification before events reach LVGL. Swipe velocity drives inertial scroll physics, two-finger pinch and long-press with visual progress are implemented, and the interrupt-driven vs. polling trade-off is managed to prevent LVGL re-entrancy during display flush.
Electronics DesignHaptic Feedback: Engineering the Feel
LRA actuators at resonant frequency (170–230 Hz) produce crisp tactile impulses preferred for UI confirmation; ERM actuators' longer spin-up makes sharp clicks difficult. Resonant frequency is characterized in the assembled enclosure with a swept-frequency accelerometer test; custom DRV2605L waveforms are validated with 10+ evaluators scoring click, buzz, and alert effects.
Audio Engineering
Polished embedded user interfaces for products that need to feel as good as they work.
Embedded UI/UX Across Ankh's Product Range
Every product category has a different UI challenge — medical devices need legible alarm displays under clinical lighting, POS hardware needs glove-tolerant touch, and wearables need ultra-low-power always-on watch faces.
Medical Devices
IEC 62366 usability engineering, alarm display legibility, touchscreen under surgical gloves
View ProductPOS & Kiosk Hardware
10-point multi-touch on 21.5" MIPI DSI panel, accessibility-compliant font sizes, glare-resistant display
View ProductWearable Electronics
Always-on watch face at 10 µW, LVGL on 64 KB SRAM, circular display GC9A01 driver
View ProductIndustrial Equipment Monitoring
IP65 resistive touch for gloved use, 1000+ nit display for direct sunlight legibility, simplified operator UI
View ProductSmart Home Automation
Capacitive touch panel with proximity wake, LED ring ambient indication, LVGL home screen widgets
View ProductAI Vision Systems
HDMI output UI for operator review interface, LVGL overlays on camera preview stream
View ProductCold Chain Monitoring
E-ink display for ultra-low-power status indication, bistable update for shipping label integration
View ProductData Loggers
Segment LCD driver for battery-powered operation, minimal OLED interface for field calibration workflow
View ProductHardware and UI Co-Design
DMA2D support, SRAM headroom for the frame buffer, and touch interrupt routing cannot be corrected at the LVGL implementation stage. Hardware and UI are co-designed from kickoff — every hardware decision evaluated against the rendering pipeline.
Production-Quality LVGL Implementations
LVGL code is held to the same quality bar as safety-critical firmware: frame time profiling, multi-day heap fragmentation stress tests, edge case input handling, and static analysis — state machine architecture documented for long-term maintainability.
Multisensory Interface Design
Complete interaction language: which events produce haptic and with what waveform, which states drive LED color and animation, when audio tones supplement visual alerts, and how all channels degrade gracefully — products communicating through multiple sensory channels are genuinely easier to use in the field.
Deliverables
Display & Touch Hardware Bring-Up Package
Initialization source code, register configuration documentation, bring-up test procedure, and oscilloscope captures validating display and touch controller operation.
LVGL Port Layer & Theme Source Code
LVGL port including flush callback, touch read callback, tick source, theme configuration, and frame buffer allocation with memory layout diagram.
Screen & Widget Implementation
All screens as LVGL source files with documented widget hierarchy, style application, and event handler registration; custom widgets as reusable LVGL object classes with API documentation.
UI State Machine Documentation & Source
State machine source code with PlantUML/Mermaid state diagram, transition table, event source documentation, and guard condition logic for all transitions.
Asset Production Files
Figma design files at target resolution, LVGL-compatible bitmap sprites, font files subsetted to required code points, and icon sprite sheets.
LED & Haptic Firmware
WS2812B/APA102 DMA driver, PCA9685 driver, LED animation engine with pattern language documentation, DRV2605L haptic driver with waveform library and effect-to-event mapping.
Performance Characterization Report
Frame time at peak load, touch-to-visual latency, CPU utilization profile, and RAM usage breakdown — with pass/fail assessment against target performance requirements.
Production Test Procedure
Automated test sequence for display initialization, touch calibration, LED, and haptic — Python scripts with pass/fail criteria and visual inspection checklist.
All UI deliverables include source code in the target RTOS/bare-metal environment, asset production files, and documentation sufficient for your team to extend the interface independently.
Often Paired With Embedded UI/UX
Firmware Development
LVGL UI implementation integrated with RTOS application firmware, sensor data display, and connectivity status indication.
ExploreElectronics Design
Display hardware selection, MIPI DSI/RGB interface routing, backlight driver design, and touch controller placement co-designed for optimal UI performance.
ExploreAudio Engineering
Audio tone and voice prompt coordination with the UI state machine for cohesive multisensory interface design.
ExploreEnclosure Design
Display cutout dimensioning, touch panel integration, button and encoder mechanical design, and LED light-pipe routing.
ExploreWork That Demonstrates the Standard
Medical Infusion Pump Touch Interface
Ankh redesigned the UI state machine for an infusion pump that had failed IEC 62366-1 — adding alarm escalation states, persistent alarm indicators, and mandatory 3-step confirmation for dose-critical changes. LVGL on STM32H7 achieved sub-12 ms touch-to-visual latency with DRV2605L haptic confirmation; the redesigned interface passed summative IEC 62366-1 with zero critical use errors across 15 users.
Read the Case StudyIndustrial HMI on STM32H7 with LVGL
Ankh implemented the LVGL port for an 800×480 HMI using STM32H7 DMA2D for alpha-blend acceleration, SDRAM double buffers, and per-widget partial-update optimization with lock-free ring buffers preventing RTOS priority inversion. The result was 60 FPS sustained with 35% CPU headroom, double the client's 30 FPS target.
Read the Case StudyReady to build a device interface people actually want to use?Premium feel on constrained hardware — that is the embedded UI/UX challenge we solve.
Share your display and MCU specs and Ankh will scope the hardware and firmware engagement together — from display bring-up to a complete multisensory interface with touch, haptic, and LED.