Measurement from the running firmware
The device samples values in its own cycle with 1 µs timestamps. QInsight displays, logs and replays them — no debug probe, no halting the CPU.
QFW SDK
XCP firmware library for your ECU
A library that adds the XCP protocol to your device firmware. QInsight then measures timestamped values from the running firmware, calibrates parameters, and stimulates signals — over Ethernet or CAN, without a communication protocol of your own.
Functions
Measurement, calibration, and stimulation in the running firmware
Calibration and stimulation at runtime
Change parameters from QInsight directly in the unit's memory. Stream signals from the PC into the firmware (STIM) in sync with your application cycle.
Standard ASAM XCP protocol
The engine implements ASAM MCD-1 XCP 1.4. You write neither a protocol nor a parser; you link the library and connect it to the transport.
SDK structure
Engine, glue layer, and example project
A binary engine, a source glue layer, and a complete example project.
1
OS-free engine
A static library with a single public header. No threads, sockets, heap or blocking calls: it receives transport data, returns data to transmit, and gets time, locking and logging through callbacks. That is why it runs bare-metal and on any RTOS.
2
Source glue
A reference binding of the engine to a concrete environment, shipped as source: FreeRTOS + lwIP for Ethernet, a superloop for CAN (STM32H7 FDCAN). Adapt it to your project.
3
Example project
A complete NUCLEO-H723ZG project (CubeMX/CMake) that builds out of the box: from initialization to live measurement in QInsight.
Transports
XCP on TCP and XCP on CAN with a common API
The package contains the engine in two variants; an image links exactly one of them. Only the receive entry differs.
| XCP on TCP (Ethernet) | XCP on CAN | |
|---|---|---|
| When | devices with Ethernet, high data volumes | devices on a CAN bus, PC with a PEAK CAN adapter |
| Frames | up to 1024 B per DAQ packet | classic CAN, 8-byte frames (CAN FD planned) |
| Glue | FreeRTOS + lwIP, TCP server task | bare-metal superloop, STM32H7 FDCAN |
| Library | libqfw_xcp_eth.a | libqfw_xcp_can.a |
Integration
Connecting the engine to your application
Initialization with callbacks, event creation, and its trigger in your task cycle. Variable addresses are taken from the map or ELF file; no A2L is needed.
qfw_xcp_config_t cfg = QFW_XCP_CONFIG_DEFAULT;
cfg.project_name = "MyEcu";
cfg.epk = "V1.0.0";
cfg.transmit = my_transmit; // TCP stream or CAN frame
cfg.get_clock = my_clock_us; // monotonic time in us
cfg.crit_enter = my_lock;
cfg.crit_leave = my_unlock;
cfg.queue_mem = queue_memory; // static memory, no allocations
cfg.queue_mem_size = sizeof(queue_memory);
qfw_xcp_init(&cfg);
uint16_t ev10ms = qfw_xcp_create_event("task10ms", 10000);
// in the 10 ms task / timer:
qfw_xcp_trigger_event(ev10ms); // samples DAQ lists, applies STIMCompatibility and requirements
Supported platforms and requirements
- Library for Cortex-M7 with FPU (GCC); other cores and toolchains (Cortex-M4F, M33, IAR, Arm Compiler) on request.
- QInsight 1.0.0 or newer (XCP on CAN: build from September 2026 or later).
- Standard XCP 1.4 — any XCP master on TCP works for the standard feature set.
- The engine builds on Vector XCPlite (MIT license), adapted for OS-free operation and STIM.
Evaluation and licensing
Free evaluation build, licensed build with the QInsight license
Free evaluation
The package without an activation key runs with full functionality; the engine stops 30 minutes after device start (until reboot). QInsight gets a clear message, not silence.
Part of the QInsight license
The QFW SDK has no separate price. A Commercial QInsight license comes with an activation key that removes the time limit; the library is then built for your company.
Distribution
You may ship the library only as part of the firmware of your own product. Details in the QENEX Software License Agreement.
Download
The QFW SDK package (evaluation and licensed build) is available after signing in at account.qenex.net — just like the QInsight installer and your license.
Further protocols
XCP as the first SDK protocol
The same model — binary engine, source glue layer, example project — is ready for further protocols QInsight communicates with.