Model-Based Design enables rapid prototyping, easy debugging, accurate analysis, and a host of other system design benefits. Ken outlines the fundamentals of Model-Based Design and shows how techniques and tools such as automatic code generation and parallel computing with multicore processors can enhance simulation.
ECD: What trends do you see in embedded design?
KARNOFSKY: The overarching trend is accelerating integration of technologies at multiple levels, from hardware to applications. Interaction between system components is causing engineering disciplines to collaborate more effectively. One example stems from the growth of hardware/software coprocessing. Highly integrated computing architectures with multiple cores and hardware accelerators have performance and cost advantages, but they’re difficult to design and debug using conventional tools and processes.
A similar phenomenon is happening at the interface to the real world, where analog meets digital. We’re seeing increasing interest in mixed-signal system design, helping engineers use digital algorithms to lower cost and power consumption and improve the performance of sensors, RF transceivers, and other analog electronics.
Another integration trend is the increasing connectivity of everything. Smart everything – phones, cars, homes, and the power grid contain embedded devices that connect to the Internet and generate huge amounts of data. This requires additional expertise to specify and design the algorithms to communicate and process this data.
Furthermore, the proliferation of inexpensive hardware is transforming the experience of engineering students. Devices like Arduino and BeagleBoard make the integration of classroom and project-based learning a reality. We’re seeing a lot of curriculum innovation that involves integrating MATLAB and Simulink with these hardware platforms. These innovations will make today’s students better prepared for the work they’ll do in industry.
ECD: What are the advantages of Model-Based Design?
KARNOFSKY: Model-Based Design (MBD) uses a system model as an executable specification throughout development (see example in Figure 1). The model represents the embedded system and its environment and enables:
- System-level design and simulation. The system model can include every element that affects system behavior – algorithms, logic, physical components, and IP. Simulation enables analysis of system performance in conditions otherwise too expensive, risky, or time-consuming to consider.
- Automatic code generation. Generate C, C++, or HDL code from models for rapid prototyping and production software and hardware implementation. The generated code can be optimized and combined with handwritten code.
- Continuous test and verification. The system model captures requirements in an executable specification. It also provides a reusable test harness for virtual integration and hardware-in-the-loop testing.
In 2010, Embedded Market Forecasters conducted an analysis to determine the impact of MBD on the Total Cost of Development (TCD). Data was collected from companies worldwide in the automotive, aerospace, communications, industrial automation, and medical industries. The results show that:
- Development teams that used MBD had an average 37 percent lower TCD compared to teams that did not use MBD.
- The number of developers used per project was smaller for MBD across all geographic areas and all vertical markets examined.
- The percent of developer months lost to design cancellation or projects behind schedule was consistently less for MBD development projects across all verticals and geographic areas.
ECD: Can embedded design simulation replace physical prototypes?
KARNOFSKY: Simulation with system models enables rigorous system design verification with less time and expense than physical prototypes. This can significantly reduce the number of prototypes required, and in some cases eliminate them altogether.
The primary advantages of simulation are speed of design iterations and early visibility into system behavior for debugging, analysis, optimization, and verification. This reduces the design cost by identifying errors earlier in the development process, often without physical prototypes.
Engineers working toward an optimized design must develop their software and physical system together. Today, however, advances in tools and techniques enable highly accurate physical models that can replace physical prototypes of electrical, mechanical, and other components.
Many engineering teams also rely on automatic code generation with off-the-shelf rapid prototyping hardware (see Figure 2). Code generation enables reuse of algorithm and physical system models for real-time simulation and hardware-in-the-loop testing. These systems help engineers test more thoroughly by starting before hardware is available and simulating conditions that would be dangerous or costly to examine with the real system. They also significantly reduce development time and cost in the testing lab.
ECD: How does the latest wave of multicore processors affect design analysis and optimization?
KARNOFSKY: Multicore processors affect design in two ways. First, multicore PCs and servers provide an opportunity for dramatic reductions in simulation time. Parallel computing tools that are integrated with an MBD environment can take advantage of this computing power to accelerate execution of large-scale problems such as Monte Carlo simulations. For more information on how parallel computing techniques can speed up parameter optimization for a complex control system, see the MATLAB Digest article “Improving Simulink Design Optimization Performance Using Parallel Computing” at .
Second, multicore embedded processors make software design and development much more complex. Developing applications for these devices requires an understanding of the target processing architecture and careful assessment of execution performance, latency, and task dependencies. This is driving the need for tools that support the mapping of computationally intensive algorithms onto multicore architectures, as well as simulating execution in the target environment.