Table of Contents
Why embedded development needs a better workflow
What Model-Based Design is
A simple mental model: from idea to executable model to hardware
Why engineers use it: the core advantages
Verification along the way: MIL, SIL, PIL, HIL
How NXP enables this with Model-Based Design Toolbox (MBDT)
What comes next in this article series
1
Why embedded development needs a better workflow
Modern embedded systems are no longer isolated functions running on a single controller. In today's vehicles and intelligent machines, applications span sensing, communication, control, safety logic, diagnostics, and multiple processing nodes that must work together as one system.
As this complexity grows, traditional workflows based mainly on handwritten code and late-stage hardware testing become difficult to scale, hard to validate early in the development cycle, and slow to iterate. Issues are often discovered late, when integration becomes more costly and harder to manage.
Model-Based Design offers an alternative approach designed to address these challenges. It enables earlier validation and a more structured development flow, where verification is not an afterthought, but part of every stage of development.
2
What Model-Based Design is
Model-Based Design is a visual way of programming, where you build your functionality by drawing an engineering diagram, and that diagram can be executed—either as a simulation on your computer or as code running on real hardware.
In this approach, models become the central engineering artifact used to design, simulate, verify, and deploy embedded systems. Instead of starting from low-level implementation details, engineers create an executable model of the application behavior, simulate, verify, refine it, and then generate code for the target system.
This model-centric workflow makes designs easier to understand, easier to reuse, and less prone to errors. It also enables model-based testing, where test cases can be derived directly from system models and used to verify behavior early in development.
3
A simple mental model: from idea to executable model to hardware
A simple way to think about Model-Based Design is this: you describe what the system should do in an executable model, validate that behavior in simulation, and then carry the same design through to the final implementation.
In this approach, the model is not just documentation—it becomes an active engineering asset used for design, simulation, verification, and code generation.
This creates a direct path from idea to application, where requirements, design, prototyping, testing, and deployment are connected in one continuous workflow.
4
Why engineers use it: the core advantages
One of the biggest advantages of Model-Based Design is that it changes where engineering effort is spent. Instead of focusing primarily on how to implement functionality at a low level, engineers can focus on what the system should do—its behavior, control strategy, and response to real-world scenarios.
This approach also enables early validation. System behavior can be simulated on a PC before the final hardware is available, allowing issues to be detected earlier and reducing costly rework late in the development cycle.
In addition, Model-Based Design enables hardware-independent simulation, where algorithms can be developed and validated before being tied to a specific target platform. This allows teams to explore designs faster and reuse validated functionality across different hardware solutions.
As a result, teams benefit from:
faster iteration during development
improved traceability between design and implementation
reduced integration risk
more consistent validation across development stages
Ultimately, this contributes directly to faster time-to-market, as development cycles are shortened and fewer late-stage issues need to be addressed.
Some concrete examples can be found in the following articles:
From Virtual Vehicle to All-Electric Off-Road UTV in Less Than a Year
Dyson Accelerates New Product Development with System-Level Simulation
5
Verification along the way: MIL, SIL, PIL, HIL
A key strength of Model-Based Design is that validation happens continuously throughout development.
This is typically organized into several stages:
Model-in-the-Loop (MIL): the model is tested against a simulated environment
Software-in-the-Loop (SIL): generated code is executed on the host PC and compared to model behavior
Processor-in-the-Loop (PIL): code runs on the target MCU to verify functional correctness and performance
Hardware-in-the-Loop (HIL): the controller is tested against a real-time or emulated system before final deployment
These stages provide a structured validation path, ensuring that issues are detected early and confidence is built progressively before running on final hardware.
Model-Based Design also supports reuse and scalability. A validated model can be adapted, parameterized, or reused across multiple systems, reducing development effort and improving consistency.
6
How NXP enables this with Model-Based Design Toolbox (MBDT)
To make this workflow practical on real embedded hardware, NXP provides the Model-Based Design Toolbox (or MBDT). This acts as a bridge between the MathWorks' and NXP's software ecosystems, and allows the entire workflow to be done from one environment, as depicted in the diagram above. Concretely, this allows engineers to use MATLAB and Simulink to design, simulate, verify, and automatically generate code that can run directly on NXP microcontrollers and processors.
MBDT provides:
block libraries for hardware access
integration with configuration tools for pins, clocks, and peripherals
support for PIL workflows
code generation and deployment capabilities
profiling and runtime monitoring through tools like FreeMASTER
This creates a complete end-to-end flow—from model to validated application running on target hardware. Engineers can explore functionality at a high level, validate behavior through simulation, and deploy with confidence onto real systems.
7
What comes next in this article series
In the articles that follow, we will move from this general introduction to concrete, real application examples. We will show how Model-Based Design and NXP tools can be applied across a modern system architecture, covering applications such as battery management, motor control, radar, steering, lighting, and parking sensors. Each example will illustrate how functions can be designed, validated in simulation, and deployed onto the appropriate hardware nodes.
The key idea is simple: Model-Based Design helps engineers focus on system behavior while reducing the gap between concept, implementation, and validation. With NXP's Model-Based Design Toolbox, this approach can be carried from the modeling environment all the way to a running application on hardware.
MBDT
https://www.nxp.com/mbdt
https://mathworks.com/nxp
查看全文
