|
In the past ten years, automotive systems and software design has changed dramatically to meet increased product expectations, new design technologies, and workflow changes. Today's engineers overcome increased design complexity challenges using modeling tools that allow them to leverage abstraction, simulation, and code generation solutions while working in distributed teams.
In addition, many organizations use automated approaches that give them the ability to design, develop, and ultimately implement complex algorithms into their final designs. Even with these advances, however, many engineers are still implementing their algorithms directly into the source code using a textural code editing environment.
Among the numerous challenges facing engineers, the most critical is keeping pace with the rapid increases in design complexity. As many simply cannot keep up, engineers thus look for development software that will help them cope with this challenge. Traditionally, engineers dealt with complexity by leveraging algorithm development-focused tools to assist in meeting the challenge. But these are beginning to fall short because they were not originally designed to address architectural needs—it is difficult to scale these tools up to properly address today's physical (electrical), functional, and software architectural design requirements.
Using algorithm tools or written documents between different organizations can also present problems. This hurdle is a serious consideration as most automotive designs are spread across numerous organizations and geographies. Many of these products use proprietary languages that do not communicate well, and the written documents are usually ambiguous. However, engineers are using these tools to successfully design and develop individual algorithms and as such they would like to continue using them for this purpose.
From the very beginning, the Object Management Group's Unified Modeling Language (UML®) and the Systems Modeling Language (SysMLTM) were designed by engineers to address architectural challenges. Engineers using UML/SysML-based architectural design and integration frameworks have a powerful solution to these challenges because they can effectively capture the architecture while integrating the algorithms developed in other tools as source code.
Using an architectural design and algorithm integration framework, design complexity challenges can be met—allowing engineering teams to continue using the algorithm design method that works best for them while enabling engineers to re-use intellectual property (IP) from design to design.
The challenges
Design complexity is just one of the challenges facing today's engineer. The workflow can be daunting in itself, because many organizations use a parallel or distributed development approach that features multiple teams and company relationships working in different time zones, speaking several languages, and oftentimes using different tools and methods.
In addition, software has become the product differentiator for many of today's automobiles—thus the software is both intricate and important. When you add the fact that many of these electronics and software designs use closed-loop dynamic controls, logical behavior, and complex protocols each requiring a different algorithm tool for development, the additional complexity arises of having diverse sets of algorithms each with its own unique challenges.
If you are creating a design that contains a communication protocol, chances are that you would want to use a solution like Telelogic's (an IBM Company) SDL SuiteTM to develop those algorithms. If part of the design requires compact code with logical behavior, you might want to use Statemate®; if another part requires a complex computational control algorithm, you will most likely want to work with a tool like The MathWorks package Simulink®—but will all the pieces work together?
On top of this, the ability to test your application and the architecture that supports it is highly desirable—it would be best to do this early in the design process where it is the easiest and least expensive to fix issues rather than at the end, when it is costly and difficult. And along the way, requirements may change. Thus having a way to easily trace and follow the impacts that changes have down to the implementation level is important.
In many cases the requirements are captured in tools like Microsoft Word® or Excel®, or perhaps you are using a complete requirements management solution like Telelogic DOORS® to manage this process. Lastly, preserving your investment in models and code is highly desirable, because easily re-using your IP is an operational goal for many organizations. The challenge now is bringing all these concerns into a functional framework.
|
