... from concept to design to success, on time, every time!
Insanity is doing things the same old way and expecting different results!
... from concept to design to success, on time, every time!
Insanity is doing things the same old way and expecting different results!
Foresight's executable system modeling is the foundation of a comprehensive
system engineering and design automation capability.
Foresight operates on the "system of systems" concept. Foresight executable systems are hierarchical, graphical models that fully capture the functional, behavioral, and performance characteristics of a system, along with its information flow and interface requirements. They are clear and precise models, which are analyzed and executed on a desktop workstation. They allow you to model your system - as well as its interfaces and the environment it must operate within - at multiple levels of abstraction, at any point throughout system development. So, from large-scale distributed systems such as air traffic control systems that interact with multiple aircraft, to smaller-scale embedded systems such as VLSI circuits that interact with address and data buses, Foresight executable system models improve systems development.
Foresight automates systems engineering and design with three broad capabilities that can be tailored to your organization's system engineering requirements. They are:
Each of these three broad capabilities also supports the verification of lower level, discipline-specific designs, within the system context as they are developed and before they are implemented.
The development of a complete, correct and unambiguous system specification and design involves:
For complex systems the textual requirements are maintained in a document, spreadsheet, database or requirements tool, and are traced to the system architecture and specifications within Foresight.
Foresight effectively supports the development and refinement of an implementing architecture, and the visualization of the requirements through the executable system model. With Foresight, developers analyze architectural and design trade-offs by rapidly developing alternative approaches and reflecting these in the executable system model. Since system requirements are captured into the Foresight executable system model, developers can easily maintain traceability of the requirements to the system architecture and design.
As shown in Figure 1, you can capture all functional, behavioral, and performance requirements into a Foresight executable system model. Developers then use Foresight to analyze the system model both statically and dynamically. Static analysis ensures the model's completeness, consistency and syntactic correctness. Dynamic analysis vets the model's semantic correctness.
New requirements may be derived as the system architecture is defined and refined. Developers may reflect these derived requirements in the system models. Many programs manage their requirements in a number of tools or databases to ensure traceability from original requirements to derived requirements. Developers typically allocate requirements to their Foresight system models to build traceability from requirements to the system architecture, thereby ensuring the consistency between system requirements and the system design. Foresight develops clear, precise, correct and understandable specifications; specifications which are used at any level for both systems and components - including requirements, design and test. Most importantly, by capturing requirements and designs into executable system models, Foresight promotes correctness of the system being built.
Beyond verifying the correctness of system requirements and designs, Foresight supports the development of operational system prototypes, which have the following advantages:
To maximize an operational prototype's effectiveness, it must be easier to develop than the actual system, and directly linked to the system specification. Constructing the prototype from the Foresight executable system model is much simpler and more cost effective than traditional prototyping methods and it helps eliminate "translation" errors. In addition the resulting prototype is directly linked to the specification through the Foresight executable system model. In this way the system engineer can ensure that the prototype accurately reflects the specification, and that the specification keeps up with the rapidly evolving prototype.
Foresight provides the framework to extend your executable system model in many ways. Portions of your system models may be replaced with detail designs, prototypes, or components (see "Validate system requirements with Foresight operational prototypes" on Page 8). For example, graphical user interfaces are linked with the model to evaluate human interfaces; hardware component simulations (e.g. VHDL) are linked with the model to verify electronic component designs; software modules are called directly from your executable model to verify software interfaces and functionality. Prototyping with Foresight supports incremental development of complex systems. A key advantage is that engineers can continuously integrate and test components against the system specification, as it is reflected in the system model.
Foresight Systems has developed FS/Bridgeway - a remote-procedure-call-based communications backplane - to facilitate prototyping and co-simulation. With FSBridgeway, you can easily link other simulations and programs with your Foresight executable models transparently over a network.
Foresight executable system models, and for more complex systems the operational prototypes, are used to support the verification of lower level, discipline specific designs, within the system context as they are developed and before they are implemented, and to support system integration and test activities throughout the development life-cycle.
This detail design verification and test framework has the advantage that it is directly linked to the specification via the executable system model and it ensures that the design accurately reflects the specification; a result: the specification keeps up with the evolving detail design.
As detailed component de-signs progress, you can insert them back into the Foresight model and run the test cases and scenarios in the same manner as when the system architecture was initially defined. Test data is collected and compared with earlier test runs to verify the correctness of the component designs. Foresight's extensibility, through Bridgeway, provides hardware and software engineers with a comprehensive detail design verification framework throughout system development, thus ensuring early identification and correction of design errors. Since the executable system model is a validated representation of your system requirements, consistency between system implementation and system specification is maintained.
Foresight, and its powerful and expressive executable systems modeling language, allow engineers to model and analyze the system's functionality, behavior, performance, and information flow requirements, regardless of the level of abstraction of the system. Therefore, hardware and software component development can also take advantage of Foresight's capabilities. For example, Foresight allows electronic system designers to model their "system" as well as its environment, where the system may represent a complex ASIC and its environment represents the board on which the ASIC resides. Similarly, software developers can model and analyze their software architecture along with their "environment" (e.g., operating system), which may include a complex combination of hardware and software components.
In many cases, system design of a subsystem or component will proceed after the systems engineering process of generating an executable system model. The subsystem will be one of many elements of an embedded system, and the subsystem designers can take the relevant portion of the Foresight system model and refine their subsystem specification and design. In any case, subsystem and component designers can capture their system architecture into Foresight executable system models, and verify its syntactic and semantic correctness.
Using Foresight executable system models for system level design allows engineers to initially abstract implementation-level details and concentrate on system functionality, behavior, performance, and information flow. Using Foresight, engineers can evaluate and analyze these aspects of the system architecture, and perform design trade-offs at the system level. After a complete, consistent, and correct set of requirements are specified and a system architecture is defined using Foresight, designers can proceed to refine the model abstractions into detailed designs of physical components using their suite of hardware / software development tools.
Foresight supports successive refinement of the system models with its powerful modeling notations. As system design progresses and the system model is refined, system designers may transition to discipline-specific notations and tools, such as CASE tools for software and EDA/VHDL tools for electronic hardware. Foresight's advantage is that when engineers move to detailed component designs with these discipline-specific tools, they can maintain a dynamic link to the Foresight models at all times. This ensures traceability and support for verification testing of the designs. With Foresight, the executable system modeling efforts pay dividends throughout system development.
Subsequent designs are verified, in the system context, with Foresight. For example, FS/Bridgeway links Foresight directly with electronic design automation tools such as VHDL simulators, which allow system designers to incrementally test component designs against the system architecture specified with Foresight. Similarly, software modules are called directly from Foresight system models, thus enabling design verification of embedded software.
Overall, Foresight provides system engineers and designers with a powerful capability for ensuring the correctness of system requirements and designs up front, and then verifying detailed component designs throughout systems development.
Foresight allows you to realize the full benefits of system design automation by providing two fundamental capabilities:
< Previous Page | Next Page>