NXP Microcontroller Experience: Practical Solutions for Embedded System

Highlights

• Implemented USB CDC-Ethernet tunneling in Zephyr (Ethernet over USB).
• Integrated multiple industrial interfaces (Ethernet, RS-485, CAN-FD, USB OTG).
• Developed multi-level access rights and dynamic reconfiguration for gate control.
• Centralized firmware detection and secure field update system.
• Optimized high-resolution graphical HMI with real-time rendering

Architecture

The Advanced Gate Control System was built around the NXP MCXN236 microcontroller, with Zephyr RTOS as the foundation for its software architecture. One of the primary challenges was integrating multiple industrial interfaces - dual RS-485, dual isolated CAN-FD, USB OTG, and Ethernet - into a unified and reliable communication framework.

We designed and implemented robust drivers and protocol layers in Zephyr to ensure compatibility with external devices, such as Yaskawa GA500 drives, while maintaining deterministic response times. Another major effort was managing the complexity of independent gate section control, which required multi-level access rights (user, installer, and factory modes) and dynamic reconfiguration during operation.

Firmware & Config

Firmware management posed its own difficulties, where we developed a centralized detection and update mechanism for all connected boards, enabling secure field updates without interrupting core functionality. To simplify maintenance, a USB-based configuration system was implemented, requiring careful handling of hot-plug scenarios, concurrent tasks, and file system reliability within Zephyr.

Event logging and diagnostics demanded an efficient storage and retrieval mechanism; we used Zephyr subsystems to log environmental conditions such as temperature, wind load, and current consumption in real time. This adaptive monitoring had to operate under strict timing constraints while also triggering protective actions when thresholds were exceeded.

Communication Resilience

A critical aspect of the software design was ensuring fault tolerance on long CAN-FD lines, which required implementing error recovery strategies, bus-off handling, and maintaining synchronization across distributed modules.

Finally, we achieved seamless coexistence of all communication stacks- Ethernet, CAN, RS-485, and USB - on a single MCU, demonstrating Zephyr’s strength in managing concurrency, interrupts, and resource arbitration in a complex embedded system.

Display UI

In addition, we integrated a high-resolution 480×800 graphical display, where one of the key challenges was achieving smooth, real-time screen updates without visible delay. Using Zephyr’s display and graphics subsystems, we developed a rendering pipeline optimized for immediate refresh of dynamic screens, ensuring the user interface remains responsive under heavy system load.

We carefully tuned memory buffering and DMA-driven transfers to avoid flickering and latency, providing a modern HMI experience comparable to consumer-grade devices. This demanded balancing graphical performance with concurrent communication and control tasks, and demonstrated Zephyr’s capability to handle both real-time control and rich user interfaces on a resource-constrained embedded platform.

Highlights

• Implemented dual USB device classes simultaneously in Zephyr.
• Provided transparent UART bridging and a dedicated device management interface.
• Continuous monitoring of power rails, reset handling, and power sequencing.
• Watchdog-protected scheduling for robustness.
• Served as a lightweight baseboard management controller (pico BMC).

Architecture

The second project was based on the NXP MCXA153 microcontroller, where Zephyr RTOS enabled us to implement a compact and reliable dual-USB and UART bridging solution. One of the main challenges was to expose two independent USB device classes simultaneously - one acting as a UART bridge for transparent communication with the host CPU, and the other providing a dedicated device management interface.

We developed the USB composite stack in Zephyr to ensure both channels could operate without interference, while maintaining low latency and high throughput.

Power Management

On the management side, the system continuously monitored power rails, voltage levels, and “power good” signals, requiring careful integration of Zephyr’s sensor and GPIO subsystems. The device was also responsible for handling remote reset and controlled power sequencing, meaning the firmware had to react deterministically to asynchronous events and ensure safe recovery procedures.

A key part of the design was fault handling: whenever irregularities in power or signaling occurred, the firmware had to isolate the fault and provide diagnostic feedback without disturbing the communication channel.

Fault Tolerance

Because the MCXA153 served as a lightweight baseboard management controller, reliability and robustness were crucial. We introduced watchdog-protected task scheduling in Zephyr to guarantee responsiveness under all operating conditions.

Another significant challenge was resource arbitration between the USB stack, UART handling, and system monitoring tasks, which required precise tuning of interrupts and DMA-driven transfers.

Final Result

The result was a compact but powerful module capable of bridging industrial equipment with higher-level control systems, while simultaneously acting as a management endpoint.

This project demonstrated Zephyr’s ability to support dual-role USB devices alongside real-time monitoring and control, in a footprint small enough to be deployed as an embedded management controller in industrial environments.

Highlights

• Designed for isochronous transfers: real-time streaming of ADC data in a biomedical DNA analysis device (solid-state nanopores).
• RPC interface over control transfers using MessagePack (binary JSON).
• Firmware log streaming to host via USB bulk transfers.
• Fully custom USB 2.0 stack with control, bulk, interrupt, and isochronous transfers.
• Lower latency and smaller footprint than RTOS-based stacks.

Architecture

Developing a USB stack from scratch on a bare-metal environment required full control of both the hardware and the protocol implementation. We had to carefully study the USB 2.0 specification, particularly the device framework, standard requests, and transfer types.

The project began with configuring the USB controller hardware, including endpoint buffers, control registers, and interrupt vectors. A custom enumeration process was implemented to respond correctly to standard host requests such as GET_DESCRIPTOR, SET_CONFIGURATION, and SET_INTERFACE

We prepared complete descriptor sets, including device, configuration, interface, endpoint, and string descriptors, all dynamically adjustable depending on the device role.

Transfer Management

The stack supported multiple transfer types: control transfers for configuration, bulk transfers for data exchange, interrupt transfers for status signaling, and isochronous transfers for time-critical streaming. Error handling was added at the transaction level, including retries, NAK/STALL responses, and timeout recovery.

The data path was implemented with double-buffered endpoints, minimizing latency and ensuring continuous data throughput. We designed an event-driven interrupt service routine that dispatched requests to higher-level handlers without blocking the main execution. The stack provided a modular design, where each USB class (e.g., CDC, HID, Mass Storage) could be implemented on top of the core protocol layer.

Memory & Power

A custom memory manager was required to allocate endpoint buffers efficiently within the USB controller’s limited RAM. Low-power features were integrated, allowing the device to respond correctly to suspend, resume, and reset events from the host.

The stack was tested against Windows, Linux, and macOS hosts to verify interoperability and compliance with host-side drivers.

Debug & Performance

We also integrated debug hooks to log bus traffic, endpoint activity, and error codes, enabling fast troubleshooting during validation.

Performance measurements confirmed that the bare-metal design achieved lower latency and smaller footprint compared to using a full-featured RTOS-based USB library.

Final Result

The final result was a lightweight, fully functional USB stack that could be ported to other NXP Cortex-M devices with minimal adaptation.

Highlights

• Complete FreeRTOS port to 64-bit Cortex-A53 (Armv8-A).
• Implemented MMU configuration, exception/interrupt handling, and context switching.
• Integrated ARM Generic Timer for deterministic scheduling.
• Supported both AArch64 and AArch32 execution states.
• Verified performance with multi-core trace tools.

Architecture

We carried out a complete port of FreeRTOS to the Arm Cortex-A53 cores of the NXP i.MX 8M processor, which is based on the Armv8-A architecture. Unlike typical Cortex-M microcontrollers, the Cortex-A53 introduces features such as virtual memory management, privilege levels, and a more complex exception model, all of which required careful adaptation.

Memory & Peripherals

The first step was to configure the Memory Management Unit (MMU) to provide correct memory mapping, address translation, and protection domains for kernel and user tasks. We implemented a working exception and interrupt handling mechanism, ensuring that FreeRTOS tasks could be scheduled reliably without conflicts with low-level CPU exceptions.

Special attention was given to the timer subsystem, where we integrated the ARM Generic Timer as the system tick source for FreeRTOS, enabling accurate real-time task scheduling. Peripheral driver integration was another major task, as the i.MX 8M includes a wide range of communication interfaces (I2C, SPI, UART, Ethernet) that had to be abstracted for use under FreeRTOS.

Context Switching

The port also required modifying context-switching routines to handle the 64-bit registers of the Cortex-A53, as well as ensuring proper handling of both AArch64 and AArch32 execution states.

Testing & Validation

We tested and validated the port by running multiple real-time workloads, verifying deterministic response times, interrupt latencies, and task prioritization under heavy system load. Debugging was supported with hardware trace tools and performance counters, allowing us to confirm that the FreeRTOS scheduler behaved consistently across all cores.

Final Result

Finally, the solution was documented and packaged so it could be reused for other Cortex-A53-based systems, providing a lightweight real-time operating environment on hardware typically reserved for Linux or other high-level OSes. This project demonstrated our ability to extend FreeRTOS beyond microcontrollers into the application processor domain, opening up possibilities for hybrid designs that combine Linux on some cores and FreeRTOS on others.

Highlights

• Implemented Maximum Power Point Tracking (MPPT) with DMA-driven ADC sampling.
• Supervised DC-DC converters, relays, and safety shutdown logic.
• Real-time monitoring and telemetry with Ethernet, RS-485, and CAN.
• Graphical HMI for local monitoring and remote updates.
• Enabled socket-based communication between RT1060 and Linux host.

Architecture

For another customer, we designed a solar panel controller based on the i.MX RT1060, with Zephyr RTOS providing the foundation for software integration. The system had to combine real-time monitoring, precise control loops, and robust communication with supervisory systems, which posed significant challenges in balancing performance and energy efficiency.

MPPT Control

One of the core modules was the Maximum Power Point Tracking (MPPT) algorithm, which required deterministic execution of control loops to optimize power extraction under rapidly changing sunlight and load conditions. To support this, we leveraged fast ADC sampling combined with DMA transfers, ensuring stable and jitter-free control.

Power Management

Another critical area was power stage management, where the firmware supervised DC-DC converters, switching elements, and safety relays. Fault detection and protective shutdown mechanisms were integrated into Zephyr’s sensor and interrupt subsystems, enabling immediate response to overvoltage, overcurrent, and thermal events. The system also managed battery charging profiles for different chemistries (Li-ion, lead-acid), requiring flexible configuration and precise timing control.

Monitoring & Communication

On the monitoring side, the controller collected real-time data on voltage, current, temperature, and energy production. We implemented efficient data logging and buffering mechanisms, ensuring no loss of telemetry even during communication outages. This telemetry was made available over multiple industrial interfaces, including RS-485 (for local SCADA integration), CAN (for microgrid controllers), and Ethernet (for cloud or remote supervisory systems).

HMI & Updates

For user interaction, we added support for a local graphical HMI display, where Zephyr’s graphics stack was tuned for smooth rendering of status screens and live energy curves. At the same time, remote configuration and firmware updates were supported over USB and Ethernet, which required secure update handling and rollback protection.

Software

The biggest software challenge was orchestrating all these modules - MPPT, fault management, communication stacks, HMI, and logging - within tight real-time constraints. Zephyr’s multi-threading and device driver model allowed us to design a modular architecture where control loops ran with guaranteed priority, while background tasks like data synchronization and user interface updates never interfered with safety-critical processes.

Final Result

The final solution provided a high-performance, flexible, and reliable solar panel controller, demonstrating how Zephyr RTOS and i.MX RT1060 can deliver industrial-grade renewable energy management with both real-time control and advanced connectivity features.