From Dev Board to Bench Tool: Using a FRDM board & Zephyr Shell for Zero Code CAN/I2C Utilities

This session is a fast, practical “pseudo demo” that shows how an FRDM-MCXA156 board running Zephyr can double as a lightweight engineering tool, not just a target for application development. Instead of walking through setup, we jump straight to the knobs that matter: enabling Zephyr’s shell and selecting drivers in Kconfig to bring up interfaces like CAN or I2C with little to no application code. With a minimal sample app that turns on the CAN shell or I2C shell, the FRDM board becomes a low cost, flexible USB to CAN or USB to I2C adapter you can keep on your bench and extend in the same way to USB to GPIO and other quick utilities. Along the way, we highlight why this approach works well for rapid bring up and debugging: the Zephyr shell commands are well documented, easy to script and provide immediate visibility into bus traffic and device interactions. Attendees will leave with concrete patterns for turning a dev board into a reusable test tool using Zephyr configuration as the primary “code” they write.

The Bottom Line

BLUF: If you need quick bench utilities (USB↔CAN, USB↔I2C, USB↔GPIO) you don’t have to write a lot of C or build a custom firmware stack. Using a low-cost FRDM development board (example: FRDM-MCXA156) running Zephyr, enable the appropriate kconfig options and device-tree overlays, turn on the Zephyr shell and the subsystem-specific shells (I2C, CAN, GPIO), and the board immediately becomes a flexible, scriptable test tool routed over serial/USB. Eli’s demos show this end-to-end pattern so you can reproduce it fast.

Technical Prerequisites

• Hardware: a supported Zephyr dev board (FRDM-MCXA156 used in demo; other FRDM/NXP boards like MCX-W71 or MCX-N947 are interchangeable for different peripherals).
• Software/Tools: Zephyr SDK/toolchain, West meta-tool (west build / west flash), a serial terminal or USB CDC-capable host, basic HTML/JS for a simple web-serial GUI (optional).
• Concepts: basic Zephyr build flow, kconfig, device tree and overlays, Zephyr shell and subsystem shells, USB CDC vs UART serial transport, CAN and I2C basics.
• Skills: comfortable with command-line builds, flashing firmware, reading simple device datasheets, and using a serial terminal. No advanced math required.

Key Concepts

• Zephyr build & configuration as the primary “code” — West + kconfig + device tree drive which subsystems and drivers are compiled in. Many behaviors are enabled by flipping kconfig booleans instead of writing C.
• Zephyr Shell + subsystem shells — a single interactive shell (routeable over UART/USB/network) exposes ready-made commands for kernel introspection and for I2C, CAN, GPIO, etc. Turn on I2C_SHELL, CAN_SHELL, GPIO_SHELL to get CLI utilities instantly.
• Device tree & overlays for board-independence — use overlays to create friendly aliases (e.g., sys_i2c, sys_io) so the same application/configuration works across boards without changing C code.
• Transport & integration — route the shell over USB CDC (or UART/network), capture ASCII output, and build tiny host-side tools (e.g., a local HTML web-serial UI) or scripts to parse/respond to shell output for automation or visualization.

Keywords

• Zephyr — an RTOS + meta build system with drivers, APIs, and test framework; opinionated about configuration and build flow.
• West — Zephyr’s meta-tool that orchestrates builds and project workspace commands (west build, west flash).
• kconfig — text-based build-time configuration system (enable features like CONFIG_SHELL, CONFIG_I2C, CONFIG_CAN).
• Device Tree — hierarchical, compiled description of board hardware; used to map peripherals and produce header metadata for the build.
• Overlay — a device-tree patch applied at app-level to alter node names, add aliases, or change pin mappings without editing board files.
• Zephyr Shell — interactive CLI in firmware exposing built-in commands and subsystem-specific shells; can be routed over serial, USB CDC, or network.
• USB CDC — USB serial device class used in the demos to carry shell traffic at higher bandwidth than legacy UART.

Toolbox

• Hardware: FRDM-MCXA156 (demo primary), FRDM-MCX-W71 (CAN sender example), other NXP boards (MCX-N947, RW6x12) as needed for Ethernet/Wi‑Fi.
• Zephyr tooling: West, Zephyr SDK/toolchain, sample app skeleton (main prints), PRJ.conf (kconfig), devicetree overlays (.overlay files).
• Transport & host: serial terminal or USB CDC host, Web Serial API (Chrome/Edge) for lightweight HTML GUIs, simple parsing scripts to ingest shell ASCII output.
• Optional: logic analyzer or multimeter for physical signal checks; CAN transceiver/harness if testing physical CAN bus.

Takeaway

After watching, you will be able to convert a low-cost Zephyr-supported dev board into a reusable bench tool by enabling subsystem shells and using device-tree overlays and kconfig — achieving USB↔CAN, USB↔I2C, or USB↔GPIO adapters with little or no new C code, and scripting a host-side GUI or parser around the shell output.

Why watch this talk

Eli’s presentation is practical and demo-driven: he shows the exact knobs (kconfig options, overlays, shell routing) to flip and demonstrates immediate, visible results (temperature reads, LED control, CAN frame capture) without deep dives into C. It’s a great session if you want high-impact, low-effort ways to turn a cheap dev board into a flexible bench assistant — and it gives reproducible patterns you can apply to your next bring-up.

This overview is AI-generated from the session transcript. Spot an issue? Let us know.