Your fastest path from concept to deployment!
Hindsight is 20/20 ... Foresight is better!
Visualize a system that works!
Engineers building tools for engineers!
Insanity is doing things the same old way and expecting different results!
Your fastest path from concept to deployment!
Hindsight is 20/20 ... Foresight is better!
Visualize a system that works!
Engineers building tools for engineers!
Insanity is doing things the same old way and expecting different results!
The complexity of embedded systems often drives the system design towards
a complex combination of distributed, concurrent, event-driven and data-driven
processes implemented as an integrated collection of custom and off-the-shelf
hardware and software.
To effectively architect these complex systems while satisfying end-user needs, system engineers and designers must model the system and analyze system requirements and designs, thereby ensuring the correctness of the specifications. Moreover, as system design progresses, a framework is required which allows engineers to incrementally integrate and test component designs.
In order to capture complex system functional, behavioral, performance, and information flow requirements, Foresight provides a rich, expressive modeling language that is precise and, therefore, machine executable. Foresight's powerful systems modeling language can model systems at multiple levels of abstraction.
Foresight's graphical and textual modeling constructs allow system designers to capture a model of the most important characteristics of complex systems - their functionality, behavior, and performance. Also, Foresight's data dictionary permits designers to capture information flow and interface requirements in the model.
Any systems modeling language - to be of any use - must be understandable to the entire technical project team. Foresight's modeling language is highly visual, and thus intrinsically intuitive to system designers, yet expressive and rigorous enough to model and analyze complex requirements and designs.
Foresight's executable system modeling language is based on a collection of proven notations for complex systems development that have evolved over the last few decades. Its origins lie in both the newer object-oriented modeling constructs as well as the time-tested modeling constructs of real-time structured analysis. Foresight's modeling language is built from these notations, and is extended with one unique and critical characteristic: execution.
Foresight's modeling language has well-defined syntax and execution semantics, which puts Foresight in a class all by itself. It provides a collection of modeling constructs to accurately model all types of functionality and behavior, as well as performance constraints; its information modeling capabilities support all types of information flow and interface definitions as well.
With Foresight, you integrate multiple views of your system into one, unified view. Your system model integrates the functionality of your system with the control behavior, and the performance constraints. Your information model is integrated into the system model through the data dictionary and information flows. Foresight executable system models allow you to analyze the critical aspects of your entire system - its functional, behavioral, performance, and information requirements - in one integrated model.
Foresight's modeling constructs include:
Foresight supplies the necessary notations to construct models, and empowers engineer to model the system in the most effective way.
Figure 4 - Foresight Data Flow Diagram Example
Foresight models are built hierarchically from a collection of modeling constructs. As shown in Figure 3, at the top level of a Foresight model exists a data flow diagram, which consists of an interconnected collection of objects and/or processes. An example data flow diagram is shown in Figure 4. The data flow diagram nodes may be decomposed with more data flow diagrams, or with Foresight primitive (executable) modules: either state machines, mini-specs, library elements, or user-defined reusable elements. Further, all nodes are connected with information flows, whose information type specifications are stored and maintained in the data dictionary.
Foresight provides system modelers with a variety of information flow connection types by which system model objects and processes communicate, as well as a variety of specification types for defining the precise information content.
This rich set of connections may represent data, material and energy. Embedded systems typically contain a combination of discrete and continuous interactions; for capturing these interactions, Foresight modelers can select from both time-continuous and time-discrete information flow. An example of a time-continuous flow is a +/- 10 Volt signal driving a motor, whereas a time-discrete flow may represent a message packet on a serial RS-232 interface.
In addition to flows which carry information content, Foresight also provides event flows for modeling time-discrete signals that represent the occurrence of an event; examples of an event flow include a microprocessor interrupt or a button push. Prompts are another type of event flow, which are used to control the operation of processes. Prompts can be used to enable, disable, suspend, resume and trigger processes.
Modelers specify the content of information flows in the data dictionary. Foresight provides numerous information types, both simple and composite, to accurately model any type of information flow in a complex system.
Information Specification Types
| Simple | Composite |
| Integer | Fixed-length Record |
| Real | Variable-length Record |
| String | Iteration(Linked List) |
| Complex | Array |
| Boolean | |
| File | |
| Enumeration |
The lowest levels (i.e., leaf nodes) of a Foresight executable system model's hierarchy are primitive modules: mini-specs, state machines, library elements and user-defined reusable components.
Figure 4 illustrates a portion of a Foresight model of an electro-encephalogram (EEG) monitoring system. The data flow diagram in the figure shows three different types of executable modeling constructs: a state machine, mini-spec and library element.
Mini-specs are typically used to describe a procedure, a process or a logical operation. Foresight's mini-spec syntax is a derived from VHDL. It can be easily learned by engineers without extensive programming experience, and it maps well to nearly all high-level programming languages such as C++, C, Ada and JAVA as well as hardware description languages such as VHDL.
Typical of all procedural languages, the mini-spec language includes operators, assignment statements, conditional branching statements (IF-THEN-ELSE, CASE), looping control statements (FOR, WHILE), and both pre-defined and user-defined function calls and procedures.
Mini-spec pre-defined function and procedure calls include mathematical functions, file I/O, timing functions, control functions, and resource modeling constructs. The mini-spec language allows modeling systems at multiple levels of abstraction. For example, developers may initially model the system with timing and resource constructs only to analyze system performance, and then incrementally add functional and behavior detail as the project progresses.
Alternatively, developers may model the system's functionality initially, and then add performance and resource constraints to the system model. Foresight's ability to call user-defined C functions adds further flexibility, allowing engineers to take advantage of existing software, extend the system model into operational prototypes, and test their own software under development. Foresight's mini-spec language empowers developers to model and analyze complex system functionality, behavior and performance.
A mini-spec may be used to model functionality (such as complex mathematical algorithms) or control behavior (to control the activity of other processes). Foresight's execution semantics define a mini-spec as an AND process, which means it executes whenever all of its inputs are available. A mini-spec's inputs may be any combination of data and control flow. Thus, mini-specs are used to model both event-driven and data-driven activities.
Figure 5 - Foresight Mini-Specification
Figure 5 shows a Foresight mini-spec, which displays the Compute Fourier Transform mini-spec from the EEG model. The mini-spec header defines its interface (which must be consistent with the data flow diagram that contains the mini-spec), any locally-scoped variables, and an optional initialization specification. The procedure section of the mini-spec defines the processing steps that are executed whenever the mini-spec is activated.
Figure 6 - Foresight State Transition Diagram
Foresight State Diagrams describe finite state machine behavior in a system. The Read Buffered Data state transition diagram from the EEG model is shown in Figure 6.
Foresight State Diagrams consist of one or more states each shown as a rounded rectangle (with an optional label); initial states are designated with double rounded rectangles, and transition arcs link two states. Each transition has an input specification (prefaced with "i:") and an output specification (prefaced with "o:"). The input specification has two parts: event (condition). When the event occurs and the corresponding condition is true, the state machine makes the transition. The output specification describes what outputs or actions take place when the transition occurs. Foresight's full mini-spec language is available for expressing output actions.
Since output actions are expressed with Foresight's mini-spec language, Foresight state machines can model both functionality and control behavior. Unlike mini-specs, Foresight's execution semantics define a state transition diagram as an XOR process, which means it will execute on exclusively one input event at a time. Its inputs may also be any combination of data and control flow, thereby enabling the modeling of both event-driven and data-driven activities that are sequential in nature.
Foresight supports reusability in two ways: first, Foresight is bundled with over 100 reusable library elements; secondly, Foresight allows users to construct their own reusable elements from the models they build. The reusable components created can be used any number of times within the system model, or across multiple system development projects.
From an object-oriented viewpoint, Foresight reusable components (both library elements and user-defined elements) are classes, which are instantiated as objects throughout your system models. Inheritance is achieved by graphically creating new classes composed of one or more existing classes, along with the additional functionality, behavior and performance specific to the new class. In this way, Foresight users develop and maintain their own class libraries and hierarchies.
This feature allows organizations a method of capturing and distributing their intellectual property through a project.
Foresight is bundled with over 100 pre-defined library elements, which speeds development of your model. Library elements are categorized into five libraries:
Elements for graphically constructing and manipulating complex information structures, as well as queues and stacks.
Elements for constructing primitive user interfaces for interacting with the model and displaying model information.
Includes trigonometric functions, boolean functions, summers, multipliers, comparators, etc.
Includes filters (analog and digital), signal sources, stochastic elements, etc.
Includes delay and timer elements, as well as elements for instrumenting models in order to test assertions and constraints.
Users simply copy and paste library elements in order to use them in their models. Simply click on the graphical element from one of the five libraries, and paste it anywhere into your model. Each element generally has a set of parameters that are adjusted through a dialog window to tailor its behavior; Figure 7 shows the Poisson Source library element, along with its parameter dialog box.
Foresight continually adds new library elements based on customer requests and suggestions, and distributes them with periodic releases.
Foresight allows users to create their own catalogs of reusable components (classes), which may be used by other project team members, or by other projects. It is often the case when modeling a large system, that a number of different engineers will build models of small parts of the system. When these small parts have been defined, they can be combined with all of the other parts to form a complete executable model of the system. In this way, Foresight promotes communication within and across projects by allowing users to specify, simulate and execute their sub-models alone or in concert with the other models in the system.
To the right
is an example of a user-defined reusable component, which may be
graphically resized and its interfaces positioned, and then submitted into a
reusable catalog. After the element is in the catalog, it may be instantiated
throughout the system models, with a simple copy and paste operation. Foresight's
strong support for reusability substantially reduces the total system modeling effort.
Foresight's reusable components, along with the rest of its powerful systems modeling language, provides the basis for a system engineer's workbench for all types system development. Its modeling constructs capture the most important characteristics of a system - its functionality, behavior, performance and information. Foresight executable system models allow users to capture a unified view of the system architecture and design, and ensures its syntactic and semantic correctness. In order to take full advantage of these powerful executable systems modeling language capabilities, Foresight provides an integrated tool suite that is intuitive and easy to use.
< Previous Page | Next Page>