Multi-domain virtual prototyping
Today,micro-electronicsmanufacturers use platforms to test processor applications with companion sensors.
The key objective is to verify the systemresponses to software requests, e.g., interrupts or events assertion upon threshold overruns.Moreover, such tools aimto improve the powermanagement and calibrate the embedded software applications. To this end, these platformsmust include devices likeMEMS to guarantee the coherency and the calibration of the overall system which depends for instance on the device mechanics or sensor positions. The state-of-the-art solutions aim to virtually reproduce the behavior of MEMS either through co-emulation or by reading results of experiments, as summarized in Figure 1.1. In co-emulation, the platform is directly interfaced with the physical sensors while the software is emulated on a virtual platform running on a server. The co-emulation solutions also require a complex setup and are limited to lowparametric configurations. Alternatively, results of experiments on the actual devices can be recorded and stored in database in order to replay the corresponding sequence as input of the HW/SW platform. Despite an easier setup, this solution still remains limited to specific use cases. We therefore explore an alternative solutionwhich is fully based on virtual prototypes in order tomake the platformsmore open andmodular, improve the reproducibility of experiments and fulfill the requirements of the product assembler.
Our motivation is to find a lighter and more reproducible solution than the current ones employed by
electronic manufacturers. To this end, we focus our study on the use of virtual prototypes able to represent complete solutions comprising MEMS, HW and SW parts. A virtual prototype is an analytical model of selected design properties. This allows the engineer to predict the system behavior without building expensive, inflexible, physical prototypes.
Model-based design produces a global view of the system and enables further refinements through highfidelity mathematical models in specific area, e.g., kinematics, multibody dynamics or electronics. The related solutions setup the rules for syntax, semantics and pragmatics to define the representation, the meaning and the edition of the corresponding models, respectively. The ObjectManagement Group standardized most of syntax used in model-based systems engineering  in regard to block-diagram principles.
For instance, UnifiedModeling Language (UML)  provides a generic visual syntax to represent
systems as sets of interconnected blocks, or actors, with respect to connectivity and communication rules.
SysML  restricts UML principles to systems engineering and targets the functional and structural verification of systems. To that purpose, SysML introduces an internal block diagram notation and the use of flow ports. The behavioral description of systems remains flexible enough to allow multiple behavioral definitions of the same entity. Alternatively,MARTE  supports performance analyses and quantitative predictions through a common way of modeling both hardware and software aspects. This enables a better interoperability between development tools used for the specification, design or verification steps. The aforementioned standards only address the syntacticmodeling of systems andmust therefore be complemented by simulation environments to fully anticipate their behavior.
The complexity of systems induces a tight interplay across domains (mechanics, electronics, software, communication networks . . . ) and requires more integrated tools to provide Multi-Domain Virtual Prototyping (MDVP) solutions. MDVP intends tomerge domain-specific methods into unified modeling and simulation environments to address the heterogeneous nature of embedded systems. Co-simulation and coupled simulation are the two complementary approaches commonly employed to this end.
On the one hand, co-simulation combines several domain-specific simulators. This approach defines interfaces between differentmodeling tools. Such frameworks support the necessary concurrency and communicationmechanisms to orchestrate the overall simulation without the structural and abstraction constraints of hierarchy. Based on detailed models, this method ensures the accuracy of results but may lead to long computation time that is not acceptable in early-design phases. The deployment of standard implementations, e.g., High-Level Architecture  or Functional Mock-up Interface (FMI) , aims at the synchronizationof different software tools.Dedicated interfaces, like FunctionalMock-upUnit  inFMI, address the proper cross-tool integration. The corresponding programmable interfaces and software solutions also need to be activelymaintained and documented to guarantee the large adoption and the global compatibility of the tool chain. Additionally, the combination of traditional tools can lead to incompatible syntax,misleading semantics and inconsistent pragmatics, as demonstrated by Lee in .
On the other hand, coupled simulation tackles the heterogeneity of systems by specifying a unified modeling language. Rather than addressing software problems of tool integration, themulti-paradigm modeling is focused on the semantics of inter-operation, i.e., the structural definition and the synchronization of multiple Model of Computations (MoCs). A MoC supports a particular definition of time and refers to domain-specific modeling and simulation rules. Nonetheless such a unified language cannot meet all requirements of a system modeling and specification tool. Therefore, the principle of MoC is generally applied in order to achieve strong semantics, yet address heterogeneity and provide mechanisms to allow heterogeneous models to interact concurrently . In this case, the simulation core allows the addition of new MoCs to cover different physical domains. Such an architecture must preserve the integrity and coherence of simulations while staying scalable .
Ptolemy II [35, 36]provides a coordinationframework and describes systems through the actor-basedmodeling technique. The actor-based description deepens the traditional use of block diagrams by adding information on the structural link that exists between components. Furthermore, this approach supports the notion of hierarchy directly in the model since an actor can itself contain several actors. The Ptolemy approach  influenced many of coupled simulation environments. For instance, SystemC architecture is extensible and could offer high-fidelitymodeling framework with specificMoC structures and simulation facilities. Nevertheless, its current micro-kernel structure implies that any additional MoC must refer to the underlying Discrete Event (DE) simulator. Alternatively, ModHel’X  decouples the modeling from the execution process and refers to meta-modeling techniques in order to support component-oriented and hierarchical semantics. ForSyDe  rather extends the usage of MoCs in abstracting functions and features of complex heterogeneous systems. The low expressive and high-fidelity level of suchmodels can address the abstraction and formal verification, but is not necessarily for HW/SWco-design.
Multiple tools already implement MoC-based fixed solutions to address system-level design of heterogeneous assemblies.MATLAB®  was first intended to provide routines to the powerful LINPACK  and EISPACK  libraries, developed to solve linear equations and eigenvalue problems, respectively. Built upon these initial matrix packages, MATLAB provides a general-purpose programming language that incorporates standard functions for the solution of Ordinary Differential Equations (ODEs). This language can be applied to simulation of continuous and discrete-time systems too.MATLAB/Simulink, or the open1.2 source equivalent Scilab/Scicos , indeed enablesmodel-based designand systemsimulation.Bothprovide a graphical input to definemodels and handle hierarchical structure through block diagrams. Benefiting fromthemathematical foundations ofMATLAB, Simulink can dynamically solve complexmatrix functions.
This environment is extensively used to design applications in micro-mechatronics . Moreover,
toolboxes and APIs enable the co-simulation with external solvers, e.g., to test HW prototype or real-time software .
Alternatively, Modelica®  implements a modeling language with the intent to ease the description of multiphysics systems. This uses expressions essentially referring to themathematical equations of the underlyingmodel.
Hence,Modelicamodels are usually based on a functional description of systems and refer to non-causal modeling with true Differential Algebraic Equations (DAEs) and ODEs . As an objectoriented language, Modelica is well adapted to design purposes and aims to easily exchange models and model libraries. Moreover, Modelica, together associated with simulation tools such as Dymola or Open Modelica, supports the simulation of systems mixing continuous and discrete time descriptions in the FMI environment. LMS Amesim®  is another versatile physical modeling and simulation tool using primitive components and predefined libraries.
Electronic system-level design
HDLs shorten SoC design phases by modeling and verifying digital ICs through virtual prototypes. These languages are constructed on top of a single MoC that defines the elements, relationships and events further combined into models. The associated discrete-event simulator generates and updates the value of variableswith a timestampas defined by operations. Their relative cost canthus be evaluated regarding the underlying hardware obtained fromlogic synthesis. In industry, VHDL  and Verilog  are the de facto standards to address the digital simulation of ICs. In order to include analog front-end components, these HDLswere extended to analog simulation, e.g.,with VHDL-AMS and Verilog-AMS .Nevertheless, these solutions remain decoupled fromthe development of software running on the targeted architectures.
To address SoC growing complexity, specific modeling and analysis methodologies were developed. For instance, ad-hoc C/C++ based models are commonly used by designers to validate basic architectural choices. In addition, algorithms are defined and validated by complementary dataflow models targeting an optimal implementation, either on hardware or software. Moreover, IP reuse and associated techniques, such as platform-based design, notably accelerate SoC back-end implementation processes, i.e., fromRegister Transfer Level (RTL) to the layer definition . These steps are now considered reliable and cost-efficient. As a consequence, the major design phases shift up in abstraction level to system level, denoted Electronic System-Level (ESL) design . ESL enables the concurrent development of applicationspecific software and hardware systems. To that purpose, higher-level languages emerged over the last decade . Involving multiple MoCs, they handle additional timing constraints and data types. Furthermore, these languages extend the capabilities of traditional HDLs with a better support for concurrency, communications and configurability ofmodels .
SystemC became in the last few years a C/C++ modeling standard for systems architects . This C++- based library enables the system-level simulation and the co-development of digital hardware and software.
This is based on a single fixedMoC, the same as existing HDLs, namely the discrete event semantics.
Therefore a system is described as a set of interconnected modules processing threads or methods, each representing the system in a behavioral or functional manner . These functions are then scheduled and executed by the SystemCevent-drivensimulation kernel. Besides the co-development of software and hardware, this standard enables the functional and behavioralmodeling of ICs . Furthermore, this simulation environment enables an early functional and architectural verification through dedicated frameworks like Universal VerificationMethodology (UVM) .
SystemC AMS extensions enable the continuous systems simulation in SystemC . This standard implements the synchronization between discrete-event and discrete-time solvers in charge of digital and analog components simulation, respectively.Moreover, SystemC AMS layered architecture allows the definition of additional MoCs , each dedicated to a specific physical domain. Another potential asset of SystemC-AMS lies in its further coupling with a verification process like UVM. Nonetheless, SystemC AMS still remains limited to efficiently recover time-continuous behaviors, especially the nonlinear ones.
Despite these drawbacks, SystemC AMS is a valuable support to simultaneously handle the simulation of software and digital hardware with additional non-electronic peripherals, in particular MEMS. This standard is used in the commercial software Coside®  which also supports VHDL-AMS to provide a complete design flow for AMS solutions.
The aforementioned solutions address the simulation of heterogeneous systems through specific software tools or dedicated frameworks. Nevertheless, the rise of SoC/SiP in embedded systems encouraged a digital-centric approach to build virtual prototypes. Alternative methods therefore emerged from the electronics community to bindHW/SWdevelopmentwith systemsimulation environments.We reviewed hereafter some of the research projects that contributed to the development of novel standards. RapidMPSOC[ 62] and SMACprojectswere focused onco-simulationenvironments to enable themulti-domain simulation. One interesting result of the SMAC project relies on the automatic extraction of SystemC-AMS and C++ models from heterogeneous system descriptions as shown in . This thesis was conducted during the H-Inception project that followed up the Beyond Dreams project which aimed to enlarge SystemC with AMS extensions . One noticeable contribution of H-Inception is the proof of concept of a unified simulation environment for the MDVP with respect to SystemC and the MoC principles . The aforementioned frameworks, projects and commercial software solutions are summarized in Table 1.1.
MEMSmodeling and simulation
MEMS are generally designed and simulated in dedicated Computer Aided Design (CAD) tools, mostly through Boundary-Element Method (BEM) or FEM . These fined-grain models have a large number of Degrees of Freedom (DoF) and are too complex to be further integrated at higher level in the models of complete heterogeneous systems. The complexity of such descriptions is indeed relatively high and results inmore than thousands ormillions possibly nonlinear coupled Partial Differential Equations (PDEs) or ODEs. The computation and solving of such systems is time consuming and cannot be directly used in a circuit-design environment. Therefore MEMS system-level design intends to produce functional or behavioral equivalent compact models to speed up the simulation.
Macro-modeling encapsulates the multiphysical behavior of MEMS (mechanics, electrostatics, fluidic damping) into small components. Specific commercial solutions  already implement thismodular approach and rely on MEMS dedicated high-order Finite Element Analysis (FEA), which concatenates the multiphysics into one single equations system. This is in contrast to traditional FEM tools, which usually rely on solver coupling formulti-physical simulation.Nevertheless, the transient simulation of FEA is likely perceived as too slow for MEMS/ASIC co-design . To address the system designer’s needs for simulation speed while preserving the critical nonlinear characteristics of a device, the reference modelmust be reduced to a lower but self-sufficient number of DoFs, e.g., through Model Order Reduction (MOR). MOR is a well-established mathematical theory and an efficient technique to generate compact and accurate
models of large-scale dynamical systems . This results in a reduced model, i.e., a small system
of ODEs, that is derived and computed to recover the solution of original system. In MEMS design, MOR can be considered as solved in principle for linear systems regarding the support in simulation software of robust numerical algorithms in order to automate the process . Latest research are focused on establishing error estimators to guarantee the quality of compact views from large-scale systems . In addition configurable reduced models enable to preserve parameters and thus evaluate the design variations without performingMOR again .Moreover, theMORmethods frequently handle nonlinearity of the systemby approximation either through a polynomial of low degree or a translated quadratic bilinear form. An extensive review of MOR techniques in nonlinear cases is provided in . The simplest technique remains the quadraticmethodwhich can be reinforced by the bilinearizationmethod or variational analyses which lead to lower errors. In case of strong nonlinearities, piece-wise linear approximations are preferred to handle the dynamic disparities of the system and refer to « snapshots » of intermediate states . All thesemethods derive fromfrequency-domainMOR methods whose accuracy ismeasured by the related transfer functions.
Combining reduced models with HDLs is a promising way to enable the global system simulation. The digital part is usually described in HDL like VHDL or Verilog and can be broaden to analog parts thanks to AMS extensions. In addition, the AMS extensions of HDLs partly enable the simulation of continuous systems through discrete-time solvers . In the case of MEMS, reduced models have been successfully integrated to AMS extensions of HDLs and found multiple applications as detailed in Section 2.3. Commonly based on VHDL-AMS or Verilog-AMS, we are interested in this work in higher-level descriptions in SystemC-AMS.
Table of contents :
1.1 Multi-domain virtual prototyping
1.2 Electronic system-level design
1.3 MEMS modeling and simulation
2 State of the art
2.2 MEMS system-level design
2.2.1 Electrostatic transducers
2.2.3 Simulation strategies
2.3 HDL-based reducedmodels
2.3.1 Model order reduction principles
2.3.2 Implementation in HDLs
2.4 SystemC, a system-level design language
2.4.1 Basic concepts
2.4.2 AMS extensions
2.4.3 Other extensions
2.4.4 Signal conditioning
3.2.1 Equivalent-circuit representations
3.2.3 Transfer function and state-space system
3.3 MEMS macromodels
4 System-level simulation API
4.2 Motivating example
4.2.1 Model definition
4.2.2 Use case
4.3 API Implementation
4.3.2 Test bench
4.4 API use case
4.4.1 Test-bench configuration
4.4.2 Simulation results
4.4.3 Simulation performance
5 Case study
5.2 Methods &Material
5.2.1 Device under test
5.2.2 Modeling procedure
5.2.3 Test-bench definition
5.4.1 Modeling accuracy
5.4.2 Simulation performance
6.2 Future work
6.3 Closing thoughts