Scientific instruments, particularly precision analytical instruments like Isothermal Titration Calorimeters, present a distinctive embedded software challenge. The instrument must simultaneously manage real-time hardware control at the microsecond level, provide a rich operator interface, maintain cloud connectivity for remote monitoring and update, and support a software architecture that allows individual functional components to be updated, replaced, or extended without disrupting the instrument's operation or requiring a complete firmware reflash.
Traditional monolithic embedded firmware architectures, where all instrument functions are compiled into a single binary, are increasingly inadequate for instruments of this complexity. Any change to any part of the software requires rebuilding and revalidating the entire image, creating long release cycles, high validation costs, and a difficult path to field updates for instruments already deployed in customer laboratories.
A global leader in analytical instrumentation approached Embien, through a specialised engineering services partner, to develop the embedded software framework for the next generation of their Isothermal Titration Calorimetry instrument on an NXP iMX8MP based SBC. The mandate was clear, move beyond monolithic firmware to a modular, containerised architecture that would give the instrument team the agility to develop, validate, and deploy individual software components independently, while maintaining the reliability and determinism that a precision scientific instrument demands.
The central challenge was applying containerisation technology, a paradigm well established in cloud and enterprise software, to a resource-constrained NXP iMX8MP ARM Linux SBC in a scientific instrument context. Docker containers bring powerful modularity and deployment flexibility, but they introduce overhead in terms of memory footprint, storage consumption, and startup time that must be carefully managed on embedded hardware where resources are finite and boot time requirements are strict.
Defining the right containerisation granularity was a critical design decision. Containers that are too coarse-grained negate the modularity benefit, a container encompassing too much functionality still requires broad revalidation on change. Containers that are too fine-grained introduce excessive inter-container communication overhead and operational complexity. The framework architecture had to find the right decomposition for the ITC instrument's specific functional structure.
Inter-container communication on an embedded platform also required careful design. The containers needed to exchange data and commands reliably and with low latency, the instrument control container receiving measurement data from the STM32 hardware control module had to deliver it promptly to the UI and cloud containers without introducing jitter that could affect the instrument's measurement pipeline. The Glass-to-Glass latency from the control module through the container stack to the UI had to be maintained at or below 50 milliseconds, a demanding target for a multi-layer containerised architecture.
The PPP serial connection between the NXP iMX8MP SBC and the STM32-based instrument control module, carrying the low-level hardware commands and measurement data, had to be integrated into the containerised architecture cleanly, with the serial interface owned by one container and data made available to others through the gRPC inter-container communication layer.

Containerisation Architecture for Embedded Instruments
Embien designed and implemented a modular containerised framework specifically architected for the ITC instrument's functional decomposition on the NXP iMX8MP platform. The iMX8MP's heterogeneous multicore architecture, combining ARM Cortex-A53 application cores running Linux with a Cortex-M7 real-time core, provided a natural hardware foundation for separating real-time instrument control from the containerised application software stack running on the A53 cores.
The framework partitions the instrument software into a set of discrete Docker containers, each owning a well-defined functional domain, instrument hardware communication, measurement data processing, cloud connectivity, user interface serving, and firmware update management. Each container is independently buildable, testable, deployable, and updatable, the core benefit the customer needed to achieve agile instrument software development and field update capability.
The containerisation approach transforms the instrument software release model fundamentally. Rather than rebuilding and revalidating the entire instrument firmware image to deploy a UI update or a cloud connectivity enhancement, the relevant container image alone is rebuilt, validated in isolation, and deployed to the instrument, with all other containers continuing to run uninterrupted. This dramatically reduces the validation scope and release cycle time for incremental changes, and provides a clear update boundary for regulatory and quality purposes.
gRPC Inter-Container Communication
Inter-container communication is implemented over gRPC using Protocol Buffers, a high-performance, strongly-typed RPC framework that provides both the communication efficiency required for low-latency instrument data paths and the interface rigour required for reliable integration between independently developed containers. Service definitions, specifying the data types and RPC methods available between containers, serve as formal interface contracts, ensuring that changes to one container's internal implementation do not silently break its interactions with other containers.
The measurement data path, from the instrument control container receiving raw calorimetry data over PPP from the STM32 module, through the data processing container applying baseline correction and calibration, to the UI container rendering the results and the cloud container uploading telemetry, was implemented and optimised over gRPC to achieve the 50 millisecond Glass-to-Glass latency target.
PPP Serial Integration
The STM32-based instrument control module, managing the ITC's precision temperature control, injection system, and raw calorimetry data acquisition, communicates with the NXP iMX8MP SBC over a UART serial link using PPP. The instrument control container owns this serial interface, implementing the PPP connection management and the application-layer protocol for command dispatch and data reception. Measurement data and instrument status received from the STM32 are made available to other containers through gRPC service calls, cleanly abstracting the serial hardware interface from the rest of the container stack and enabling the instrument control container to be updated or replaced without requiring changes to containers that consume its data.
Blazor Web UI
The operator interface is implemented as a Blazor Server application running within a dedicated UI container. Blazor Server delivers a rich, responsive web application UI served from the NXP iMX8MP SBC itself, accessible from any browser on the local network without requiring a native application installation on the operator's workstation. The UI provides real-time display of the calorimetry measurement data, experiment configuration, instrument status, and historical result review. ADFS-based user authentication and role-based access control are integrated into the UI layer, ensuring that instrument configuration and sensitive experimental data are accessible only to authorised users. The web-based delivery model also means that UI updates can be deployed as a container update without any change to the operator's workstation or laboratory IT infrastructure.
Azure IoT Cloud Integration
A dedicated cloud connector container manages the instrument's Azure IoT integration, handling device authentication, telemetry upload, firmware update notification reception, and remote monitoring connectivity. The cloud container receives instrument telemetry from other containers via gRPC and publishes it to the Azure IoT hub, enabling remote monitoring of instrument health, usage statistics, and experiment outcomes. Azure IoT's device management capabilities are used to notify the instrument of available software updates, triggering the OTA update process managed by the firmware update container.
BSP Customisation and Fail-Safe OTA
Embien customised the Yocto-based embedded Linux BSP for the NXP iMX8MP platform, enabling the LVDS touch display, configuring the Docker runtime environment within the BSP image, and setting up primary and secondary boot partitions for fail-safe OTA update. The heterogeneous multicore capability of the iMX8MP was leveraged to run the Docker container stack on the Cortex-A53 cores while keeping the Cortex-M7 available for any real-time instrument control functions that required deterministic execution outside the Linux environment.
The OTA update mechanism supports two distinct update scopes, individual Docker container updates for application-level changes, and full BSP updates for OS-level changes, each delivered securely from the Azure IoT backend. A/B partition switching ensures that a failed BSP update does not leave the instrument in an unbootable state, with the bootloader reverting to the last known good partition on a failed boot. Watchdog integration provides an additional safety net, recovering the instrument automatically from unexpected software failures.
This ITC instrument controller project demonstrates Embien's capability to apply modern containerisation architecture to precision scientific instrument embedded software on the NXP iMX8MP platform, delivering the modularity, deployment agility, and independent update capability that instrument software teams need to sustain rapid product development cycles without compromising the reliability that laboratory instruments demand. By designing a Docker-based framework specifically architected for the instrument's functional decomposition, leveraging the iMX8MP's heterogeneous multicore architecture, implementing efficient gRPC inter-container communication, and integrating Azure IoT cloud connectivity and fail-safe OTA within a Yocto-based Linux BSP, Embien provided the customer with an embedded software platform that fundamentally transforms their instrument software release model. This project reflects Embien's growing expertise at the intersection of embedded Linux, containerisation technology, and scientific instrumentation, a combination that is increasingly relevant as the boundary between embedded firmware and cloud-connected software continues to dissolve.
Partner with Embien to design and develop modular Docker-based embedded software frameworks for scientific instruments, industrial controllers, and connected devices.