Connection of QEMU with SystemC and FMI/FMU for Software Defined Vehicles

In the automotive domain, early-stage system emulation has become a cornerstone of modern embedded development workflows. The increasing complexity of electronic control units (ECUs) and the growing demand for functional safety have led to a widespread adoption of virtual prototyping platforms. In this context, the RISC-V instruction set architecture has gained significant traction due to its openness, modularity, and suitability for customizable embedded designs. Coupled with emulation tools such as QEMU and modeling environments like SystemC, developers can build accurate software/hardware co-simulation setups well before the physical hardware becomes available. The Functional Mock-up Interface (FMI) standard and its associated FMU format enable standardized co-simulation by encapsulating models in a reusable and tool-agnostic way. Integrating Functional Mock-up Units (FMUs) into system emulators such as QEMU allows developers to test, validate, and iterate over functional prototypes early in the development process. This approach not only accelerates time-to-market but also increases test coverage and reduces overall development costs. Several research approaches have already explored the integration of virtual emulators, such as QEMU, with the SystemC simulation environment. However, most of the existing literature focuses on platforms based on ARM or x86 architectures and often relies on direct SystemC integration rather than using standardized interfaces. No documented solution has been found that combines a RISC-V Linux system running on QEMU with a co-simulation model conforming to the FMI (Functional Mock-up Interface) standard. This work therefore represents a novel contribution, bridging the gap between open-source processor emulation and standardized model exchange for embedded systems prototyping. This thesis presents the design and implementation of a co-simulation framework that enables communication between a SystemC-based FMU and a Linux system running on a RISC-V processor which is emulated by QEMU. A Python master component orchestrates the interaction between QEMU and the FMU, using QMP (QEMU Machine Protocol) to control execution flow and socket communication to transmit inputs and receive simulation outputs. The developed synchronization mechanism ensures that QEMU is paused, the FMU is interrogated, and then QEMU is resumed at regular intervals, ensuring temporal consistency between both environments. To optimize execution, the master also automates the entire setup by launching all components and establishing a connection between them. Furthermore, to minimize manual intervention and accelerate the generation of necessary source files, most of the code can be generated automatically. The proposed co-simulation framework was evaluated in different test scenarios, including a multi-FMU configuration modeling a delta-sigma modulator. These tests demonstrate the extensibility of the system and its capability to support complex interactions between virtualized software and standardized simulation models. Overall, this work enables early-stage validation of RISC-V-based embedded systems using open standards, providing a scalable and automated methodology for software/hardware co-simulation before physical hardware is available.