If a system is reliable, is it also robust? And is the converse also true: does a robust system have to be reliable? The answers are no and yes. A reliable system performs its intended function when conditions are nominal. As long as design details and environmental conditions remain stable, you can count on a reliable system to do its job time after time. But what happens if these same design details and environmental conditions start drifting significantly off nominal? The answer is simple: system reliability goes out the door. Fortunately, if we have done our jobs right, when variation attacks a system, robust performance takes over. Making a system reliable usually requires a pretty straightforward design process: the nominal design specification gets turned into a functioning system. Making a system robust, however, adds complexity to a design process. First, we need to determine possible variation sources. Next, we need to determine how these variations affect system performance. And finally, knowing how variation affects performance helps us improve our system design. Sound like a lot of work? No doubt it can be. But if system performance must be robust as well as reliable, the extra work is necessary and worthwhile. When designing to just a specification, we often focus on meeting the written specification, but forget our design often plugs into a larger system that has its own set of tolerances – tolerances that quite possibly were not accounted for in our specification. So when the tolerances for our design get thrown into the mix with the parent system’s tolerances – sometimes called tolerance stack-up – strange things can happen. And then we scramble to diagnose the problem and try to find design answers. We end up trying to test-in reliability and robustness. If you have spent much time at the test bench, you know exactly what I am talking about. But there is a better way, and by now you have probably figured out it involves modeling and simulation.
Reliability and robustness can be designed, rather than tested, into a system. But doing so usually means making a few design process changes. Teaching your simulator to tell you the right system story requires two things: the right models, and the right analyses. Getting the model piece right means choosing options that let you model whatever technology your system uses. If your system is 100% electrical, SPICE might be an adequate modeling answer, though there are better and more informative ways to tackle Ohm’s law. But the moment your modeling needs extend beyond Ohm’s law, accurate system modeling requires more horsepower, the horsepower found, for example, in a multi-physics hardware modeling option like the IEEE standard VHDL-AMS language. I’ve commented on the power and flexibility of VHDL-AMS before, so browse my earlier blog posts for more information. Just know that with a language like VHDL-AMS, you can create models that tell some pretty amazing system performance stories.
Getting the analysis piece right means selecting a simulation toolset that takes advantage of your model library to run your system through its paces. Hint: you need more than standard time and frequency domain analyses. Standard analyses will get you to the “reliable design” stage. But the “robust design” stage requires looking at system performance as key parameter values start wiggling of nominal. When parameters start to wiggle, rest assured that performance issues are not far behind. Accurately analyzing variability requires advanced analyses such as those found in the SystemVision modeling and analysis environment:
- Parametric sweep
- Relative, tolerance-based, and statistical sensitivity
- Monte Carlo (statistical), including standard and sequential extreme values
- Worst case
To learn how better modeling practices and advanced analyses can contribute to more reliable and robust systems, grab your lunch and click over to our new seminar: Improving Complex Design Reliability and Robustness. Then post a comment to let me know what design methods you most use to improve system performance when design parameters vary.