|Publication number||US20070288885 A1|
|Application number||US 11/436,475|
|Publication date||Dec 13, 2007|
|Filing date||May 17, 2006|
|Priority date||May 17, 2006|
|Also published as||US20070277151|
|Publication number||11436475, 436475, US 2007/0288885 A1, US 2007/288885 A1, US 20070288885 A1, US 20070288885A1, US 2007288885 A1, US 2007288885A1, US-A1-20070288885, US-A1-2007288885, US2007/0288885A1, US2007/288885A1, US20070288885 A1, US20070288885A1, US2007288885 A1, US2007288885A1|
|Inventors||Jean-Yves Brunel, Nathan E. Brewton, Ebrahim Mehran Mestchian, Pieter J. Mosterman|
|Original Assignee||The Mathworks, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (5), Non-Patent Citations (1), Referenced by (69), Classifications (4), Legal Events (1)|
|External Links: USPTO, USPTO Assignment, Espacenet|
A portion of the disclosure of this patent document contains material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
The present invention relates generally to graphical programming or modeling environments for modeling programs and more particularly to methods, mediums and systems for providing a graphical action language for a model in Unified Modeling Language (UML) or its dialects or extensions.
The Unified Modeling Language (UML) is a modeling and specification language used in software engineering. UML is often used for modeling object-oriented programs. UML includes a standardized modeling notation that may be used to create an abstract representation (“UML model”) of a system. While UML was designed to specify, visualize, construct, and document software-intensive systems, UML is not restricted to modeling software and can be used for modeling systems in general. For example, UML can also be used for business process modeling, engineered system modeling, and modeling of organizational structure.
The present invention relates generally to graphical programming or modeling environments and more particularly to methods, mediums and systems for providing an action language for modeling a system designed or described in a modeling language. For example, the graphical or modeling environment may be used to model the behavior of software, physical and/or control systems described in a software modeling language such as UML, or a specialized dialect of UML with optional extensions, such as, for example, the SysML variant of UML with system-engineering extensions, and the Advanced Architecture Description Language (AADL). The action language may support modeling real-time operations of systems that are at least partially defined in a software modeling language.
UML models are typically designed to capture the structure of a software system. UML does not define a formal and precise-enough semantic to allow a user to automatically build an executable model. Though the behavior of the system can be modeled by statecharts, which is an imperative and untimed language based on state transition diagrams, it is difficult to use statecharts to capture all behavioral aspects of a system. Therefore, users may need to be skilled in a textual programming language, such as C++ and Java, to add textual code for the UML model in order to program methods that implement the operations that are defined by the model. Unfortunately, UML model designers are generally software architects who construct the UML model at an abstract level and are not always skilled in programming languages and coding.
The imperative programming paradigm of text-based languages such as C++ and Java and graphical languages such as statecharts require detailing how a sequence of operations implements a computation. These languages are well-suited for specifying the finer details of sequences of computations, but are poorly suited for implementing extensive applications such as business software applications. Developing applications with imperative programming languages is tedious and error prone. These limitations of imperative programming languages are reflected in the development time and expense and defects found in present day software. The problems are compounded for real-time computation-intensive systems.
The need for using text-based imperative programming languages to write methods for UML models makes it difficult to employ UML for the design of mission critical functions in real-world applications, such as medical, aerospace or automobile applications. Programming such functions requires solving time-ordering and data-precision complexities that are beyond the typical skill set of programmers using imperative languages irrespective of their qualifications in numerical computation sciences. It is often preferable to design these systems in dynamically typed and declarative languages such as time-based block diagrams, which include further domain specific facilities, such as the notion of sample time and data type propagation. Therefore, there is a need to support declarative languages by software modeling languages like UML, especially when these languages are employed for the design of embedded control systems.
In accordance with a first aspect of the invention, the present invention provides a graphical programming or modeling environment for software modeling languages, such as UML and variants. The environment supports at least one of a declarative action language and a dynamically typed action language. The action language may be graphical and/or textual and may enable a user to design and execute a program or model.
The action language may be used for programming behaviors of a model designed using UML or its variants. As used herein, the term UML is understood to include UML and any of its dialects and/or extensions, such as SysML. It will be understood by one of skill in the art that alternative embodiments of the invention may involve models designed in modeling languages other than UML. The behaviors of a UML model may address real-time and computation-intensive needs. The computations may proceed in a distributed manner on multiple core processors, multiple processor platforms, and/or clusters of computers employing distributed computing facilities, such as, for example, the Distributed Computing Toolbox of The MathWorks, Inc. of Natick, Mass.
The terms “graphical environment” and “graphical action language” are interchangeably used to refer to an environment that enables a user to design and execute a graphical program or model.
The programming or modeling environment of the present invention may enable a user to program behaviors of the UML model in an integrated and executable manner, such that there is a relationship between the UML model and the action language model and any changes to one may be reflected in the other. Graphical models that capture the model behavior may be state transition diagrams, data flow diagrams, entity flow diagrams, Petri nets, sequential function charts, time-based block diagrams, rigid-body diagrams, electrical circuit diagrams, bond graphs, network diagrams, etc. These diagrams may represent numerical behavior, which may be computed in real-time. In an alternative embodiment of the invention, the programming or modeling environment may restrict the use of a modeling formalism to only allow diagrams that comply with a predefined style. For example, in one embodiment of the invention, only Moore or Mealy type state machines may be allowed, while in another embodiment of the invention, only time-based block diagram models that produce MISRA compatible code may be allowed. Any other style guideline may be enforced by the programming or modeling environment during different stages of the design of a model such as editing, parsing, compiling, simulating, and code generating.
The graphical model may include extensive textual aspects that can be declarative as well as imperative in nature. In addition, the graphical model may include dynamically typed and statically typed aspects. The graphical action language of the present invention enables a user to graphically program the methods or behaviors of a UML model or components in the UML model so that the UML model can be easily converted to executable code.
In an alternative embodiment of the invention, the UML model with an action language can be simulated in an interpreted fashion. No code needs to be generated. Instead, the behaviors of the model are computed directly from the model or based on an intermediate representation of the UML model with the action language.
In one embodiment of the present invention, the action language for the UML model may be a block diagram modeling language. The environment for block diagram modeling may provide a set of block libraries for programming the methods and behaviors of the UML model or components in the UML model. The graphical action language may be hierarchical and include nesting and referencing language elements. In one aspect of the invention, the reference may be a reference to an element in a library, a separate model, a part of a separate model, and a component that may be a shared library with a well-defined interface or accessible through a message passing protocol.
The programming or modeling environment may contain or have access to block libraries. The block libraries may contain blocks such as one and higher dimensional lookup tables. These lookup table blocks may contain one or multiple input values. A table is specified by a set of data points on a grid that has as many dimensions as the number of input values. The data points at each grid point may be scalar or multi-dimensional as well. For each set of input values, the output is determined by the grid points. In case the input values correspond exactly to a grid point, the data at that grid point can be returned as output. If, however, the input values are in between grid points, an interpolation scheme can be employed to derive the data point for those input values. This may be a linear interpolation, a zero-order hold interpolation, a curve fitting interpolation or any other interpolation scheme. Similarly, if the input values are beyond the grid of the table, an extrapolation scheme can be employed for which similar techniques as for interpolation exist, while different approaches for interpolation and extrapolation may be employed. In case multiple lookup tables with the same input grid are used, the computation of the index and fraction on the grid can be precomputed by a pre-indexing block and directly used as input to the lookup table block. Precomputing prevents repeated computation of the same result.
A block library may further contain a continuous-time integrator block to integrate the set of input values over time. More generally, a transfer function block can be included in the block library. The coefficients of this transfer function may be specified in a number of different forms such as by coefficients in a numerator and denominator, by an observer canonical form, and by a controller canonical form. Sparse representations may be employed where coefficients that are 0 are not explicitly represented unless expressly necessary (for example for tuning purposes or because of the specific canonical form).
Other blocks that may be available from the block library include a truth table block, a state transition diagram block, a zero-crossing detection block, a discrete-time integrator and transfer function, a logic operations block, an arithmetic operations block which facilitates addition, subtraction, multiplication, and division, and a trigonometric operation block. Additionally, data store blocks may be available, to allow shared variables through data read and data write blocks without the need for explicitly drawn connections.
The block diagram modeling language may support the modeling effort by automatically assigning characteristics of variables. These characteristics may include but not be limited to data type, whether complex values (with a real and imaginary part) are used, the dimension of a signal, and the sample rate of a signal. Propagation may be implemented based on a type lattice and a fixed-point iteration over the partial order as provided by the lattice. Degrees of freedom can be resolved in a conservative or optimistic manner. For example, if a signal has to at least have the integer data type, it can be selected to be an integer, but, alternatively, the data type double may be assigned as well. Different algorithms for propagating characteristics of model variables such as signals exist, for example forward propagation, backward propagation, and a combination of the two, supplemented by heuristics that may be used to resolve conflicts and ambiguities.
In another aspect of the invention, the action language is used for coverage analysis to identify which elements of a model have been evaluated during a set of executions. In yet another aspect, the action language is used to analyze the time it takes for model elements to be evaluated. This timing analysis can be used to schedule the execution of model elements so as to achieve real-time behavior on a given computing platform. In a further aspect, the action language is used to automatically generate tests that contain input values to the model. The generated tests are generated so as to invoke certain behavior of the model or so as to enforce evaluation of certain model elements.
In accordance with another aspect of the invention, a medium is provided for use with a computing device holding instructions executable by the computing device for performing a method. The method comprises providing a graphical programming or modeling environment for software modeling languages such as UML and variants, the environment supporting at least one of a declarative action language and a dynamically typed action language. Said action language may be graphical and textual and enable a user to design and execute a program or model.
In accordance with another aspect of the invention, a system is provided for generating and displaying a graphical modeling application. A system for generating and displaying a graphical modeling application, said system includes a UML model generated in a graphical programming or modeling environment; and means for modeling behavior of an aspect of said UML model by using at least one of a declarative action language and a dynamically typed action language. Said action language may be graphical and textual and enable a user to design and execute a program or model.
The aforementioned features and advantages, and other features and aspects of the present invention, will become better understood with regard to the following description and accompanying drawings, wherein:
Certain embodiments of the present invention are described below. It is, however, expressly noted that the present invention is not limited to these embodiments, but rather the intention is that additions and modifications to what is expressly described herein also are included within the scope of the invention. Moreover, it is to be understood that the features of the various embodiments described herein are not mutually exclusive and can exist in various combinations and permutations, even if such combinations or permutations are not made express herein, without departing from the spirit and scope of the invention.
One embodiment of the present invention provides an action language for modeling the temporal behavior of a unified modeling language (UML) model. Declarative and dynamically typed action languages may be provided for modeling the behavior of physical, control, real-time and computation-intensive systems of a UML model. The behavioral model corresponds to a computational representation that is evaluated by the supplied environment or an external product. One embodiment of the present invention additionally provides a graphical environment for creating and executing, either in an interpreted, compiled, or mixed fashion, UML diagrams that instantiate the realized objects. Each execution generates a UML interaction diagram with time-annotated messages between the participating objects as a means for software, control, and system designers to collaboratively refine and document the interfaces.
In accordance with another aspect of the invention, debugging and profiling of the execution of a UML model that has a realization in the action language can be performed. While debugging, the execution of a model can be halted at desired points in the sequence of computations. A breakpoint indicates a point at which the computations are to be halted. When halted, values of model elements and variables can be inspected. Halting execution of the model can be done programmatically based on conditional breakpoints. The debugging facilities of graphical models may allow breakpoints to be set on model elements so as to halt execution immediately before they are evaluated. Breakpoints can also be set in, for example, the numerical solver computations. For example, in the case where a computed integration step is rejected because it leads to too large an error in the numerical approximation, execution can be halted and internal solver variable values as well as model entity and variable values can be inspected. Profiling involves reporting on the computational cycles spent on evaluating model elements. The reports generated by profiling can be hierarchically structured and can provide, for example, insight as to where execution of a model may be optimized.
In a real-time configuration, the time spent evaluating model entities can be profiled. Real-time execution typically depends on implementation factors that may include the ambient temperature and nondeterministic effects of the microprocessor task execution. As such, the real-time execution may vary, and the real time that is required to evaluate model entities may vary. One aspect of system design that can be determined by profiling is the worst-case execution time for model entities. This worst-case execution time can then be used to construct a conservative schedule for model execution such that in the worst case, the model execution still remains below an upper bound in time. This schedule can be automatically generated from the model and information on the execution platform. For example, tasks that can be parallelized based on the model may result in a worst-case execution time of only one of the possible paths of execution for the task. Likewise, the schedule can be established by a designer or a semi-automated approach may be employed. Other design, analysis, and synthesis tasks are facilitated by knowledge of task execution times, including worst-case execution time, as understood by the skilled practitioner in the art.
In one embodiment of the present invention, a UML model may be exported into a text-based format, such as an XML Metadata Interface (XMI) format. The modeling environment may read the XMI format and publish the components of the UML model using hierarchical computational blocks provided in the modeling environment.
The graphical programming or modeling environment enables a user to edit a UML model. Editing the UML model may include adding new modeling elements such as interaction models that show an exchange of messages between run-time objects. In another embodiment of the invention, editing the UML model may involve adding tag-value pairs to one or more UML modeling elements to hold extra information such as information resulting from the graphical modeling and execution activities. In yet another embodiment of the invention, editing the UML model may involve modifying existing model elements, such as existing tagged values, and datatypes of operations.
The graphical programming or modeling environment enables graphical modeling of the behavior of the UML model so that the model can be executed in the graphical programming or modeling environment. Execution may be realized by running of code that results from code generation or by interpreting the model. Different versions of code can be automatically generated from the graphical action language and deployment artifacts of the corresponding elements of the UML model. A deployment artifact is a combination of requirements and instructions for compiling and/or executing the UML model. These different versions may vary between highly instrumented code for debugging, profiling, and prototyping purposes, which may include functionality for data logging and the like, to highly optimized, optionally fixed-point, code to be used in the production version of a system under design. Optimizations that may be employed are the inlining and outlining of functionality, constant propagation, expression folding, unrolling of iteration loops, merging of iteration loops, limiting the scope of local variables by reordering assignments, and the like.
In one embodiment, the graphical programming or modeling environment provides search facilities for the UML model and the model designed using the action language. These search facilities include but are not limited to facilities for searching specific properties of model elements, facilities for searching for strings, facilities for searching for types, facilities for searching for certain parameter values and settings, and facilities for performing customizable searches using a query language such as the Object Constraint Language (OCL) and XQuery.
In another embodiment of the invention, the generated code and the related model entities are hyperlinked. This allows the user to directly navigate between the corresponding parts of the code and model. One embodiment includes hyperlinks in the generated code that, when clicked, bring up the corresponding model part. The model parts may have a right-click popup menu with an option to bring up the generated code that relates to that model part. The relation may be one-to-one (for example, when one addition is executed in code in correspondence to a summation block in the graphical model), many-to-one (for example, when expression folding results in one assignment in the code capturing the computation of a number of blocks in the graphical model and, conversely, when a block in the graphical model requires more than one statement in code), and many-to-many (for example, when the folding of expressions generated by more than one block includes more than one expression that corresponds to one block).
In a further embodiment of the invention, generating production code may additionally generate the construction artifacts of concrete components that have been realized within the graphical programming or modeling environment. These artifacts notably include the generated code (for example, source, include, binary, executable, scripts, and command files) as well as all additional deployment data (for example, a makefile, documentation and report files, and component-description files for a specific component-platform such as CORBA, its real-time extension CORBA-RT, AADL, Autosar, and Software Communication Architecture (SCA) as defined by the Department of Defense, and derivates). The corresponding UML notations for the realized concrete components are additionally generated and added to the initial UML model using the appropriate UML modeling element (for example, description, annotation, and tag-values).
In another embodiment of the present invention, the graphical programming or modeling environment may simulate a UML component diagram that extends to continuous and discrete time aspects of multi-domain systems for physical, chemical, biological, and business applications. The alternative embodiment of the present invention may also generate, optimize and validate the implementation code of a UML component that incorporates the numerical and temporal behavior of the model. The code may be deployed on embedded hardware, rapid prototyping hardware, target hardware as well as wetware. The code may describe an implementation in software, for example as a C or C++ program, but it may also describe an implementation in hardware by means of a hardware description language (HDL).
In an additional embodiment of the present invention, the graphical programming or modeling environment may simulate a UML deployment diagram that enables a user to assess performance, load, reliability, and schedulability requirements of the run-time processing nodes against the time and numerical resolution of control and signal-processing algorithms with safety and reliability constraints. The simulation may include a discrete event model of the implementation part. The parameters of this implementation model may be generated by reading an architecture description from a UML profile such as AADL describing objects such as CPUs, physical buses, memory layout, and device driver performance.
In another embodiment of the present invention, the graphical programming or modeling environment may generate a sequence diagram automatically from the interpreted, compiled, or mixed execution of the model. The sequence diagram is one of the UML interaction models. The generated sequence diagram may be converted into a text-based format, such as the XML format, and merged into the text-based XMI format of the UML component model so that the UML source model contains the component diagram and the sequence diagram.
In one aspect of the invention, a sequence diagram that is part of the UML model is automatically converted into a set of input signals to the behavioral model. The sequence diagram as it is part of the UML model may associate behavioral input to a temporal sequence of message exchange. This sequence can be directly used as input during execution (either interpreted, compiled, or mixed) of the behavior model, while the dependent activities in the sequence diagram emerge during the execution and can be validated against the original sequence diagram.
Another embodiment of the present invention provides a declarative graphical action language for modeling the behaviors of a unified modeling language (UML) model. The behavioral model corresponds to a computational representation that is evaluated by the supplied environment or an external product. One embodiment of the present invention additionally provides a graphical environment for creating and executing, either in an interpreted, compiled, or mixed fashion, UML diagrams that instantiate the realized objects.
One aspect of the present invention is directed to an action language for a UML model by specifying and connecting instances of the components that are declared in the UML model and whose operations have been implemented using the graphical programming or modeling environment or imported from external source program in languages such as Python, C, C++, FORTRAN, ADA, and HDL, and wrapped into a behavioral block model of the graphical programming or modeling environment. This block may be transparent to the modeling environment or opaque and generate interacting behavior by means of co-simulation. The interface of the block can be specified by the S-Function API used by Simulink®. This method may also include the step of representing the components of the model using functional blocks in a block diagram environment. The block diagram environment enables a user to program the behaviors of the UML model.
In another aspect of the present invention, a medium is provided for holding instructions executed in a computer to provide an action language for a UML model. The instructions are executed to receive components of the UML model. The instructions are also executed to represent the components of the model using blocks in a block diagram environment. The medium may be computational hardware such as a central processing unit (CPU), graphics programming unit (GPU), digital signal processor (DSP), field programmable gate array (FPGA), and an application specific integrated circuit (ASIC), etc.
In another aspect of the present invention, a system provides a graphical action language for a Unified Modeling Language (UML) model. The system includes a UML modeling environment for specifying and connecting instances of components of the UML model. The skilled practitioner in the art will acknowledge that in UML, there is no semantic difference between components and classes and any functionality described for components can be practiced for classes. The system also includes a publishing tool for representing the components of the model using blocks in a block diagram environment, wherein the block diagram environment enables a user to model behaviors of the UML model.
An element of the UML model as referred to herein, may be one or more classifiers, and combinations thereof, that describe structural and behavioral features such as operations that are declared in classes. This includes association, class, component, datatype, interface, node, signal, as well as extensions of these modeling elements such as a subsystem that can be described as a stereotype of a class. It also includes instances of those classifiers such as objects that are instances of classes and links that are instances of associations. It furthermore includes UML model elements that specify how messages are exchanged over time among objects during an instance of an interaction.
The illustrative embodiment of the present invention is directed to a graphical programming or modeling environment in which a graphical model is executed in an interpreted, compiled, or mixed fashion, or in which code is generated for the model. In the description of the illustrative embodiment, the simulation of the model is also referred to as the interpreted execution of the model. In one aspect of the invention, a graphical programming or modeling environment enables a user to graphically program the behavior of a Unified Modeling Language (UML) model. The graphical programming or modeling environment represents a software or hardware system as a collection of blocks interconnected by lines. Blocks are entities of the system that perform given functions in the system.
In the illustrative embodiment of the present invention, a UML model may be exported into a text-based format, such as the XML Metadata Interface (XMI) format. The graphical programming or modeling environment may import the UML model and represent the UML model using behavioral blocks provided in the graphical programming or modeling environment. The illustrative embodiment may provide a publishing tool for representing the components of the UML model using hierarchical functional blocks in the graphical programming or modeling environment. The graphical programming or modeling environment enables a user or programmer to graphically define the behaviors of the UML model so that the UML model can be executed. The UML model can be modified based on the execution results. Furthermore, code can be generated from the graphical model that captures behavior of the UML model, and this code can be included in the UML model as its implementation.
The illustrative embodiment will be described below solely for illustrative purposes relative to a time-based block diagram environment and/or a state and flow diagram environment. Although the illustrative embodiment will be described relative to a time-based block diagram environment and/or a state and flow diagram environment, one of skill in the art will appreciate that the present invention may apply to other graphical programming or modeling environments, as long as the block diagram model has some notion of semantics that allows it to be interpreted or transformed into an executable for a computer processor/microcontroller, directly synthesized in general-purpose and application-specific hardware, or synthesized into wetware. For example, the illustrative embodiment may apply to physical modeling and in general ‘plant’ models, and to non-software (or HDL) bound components.
An exemplary state-based and flow diagram and time-based block diagram may be provided in Stateflow® and Simulink®, respectively, both from The MathWorks, Inc. of Natick, Mass. The illustrative embodiment will be described relative to Stateflow® and/or Simulink®. Nevertheless, those skilled in the art will appreciate that the present invention may be practiced relative to other environments for capturing behavior. An example of a textual environment is MATLAB® from The MathWorks, Inc., of Natick, Mass. Examples of graphical models include but are not limited to those facilitated by SimEvents from The MathWorks, Inc., of Natick, Mass., LabVIEW from National Instruments Corporation of Austin, Tex. or to any tool that provides capabilities to capture behavior of UML models with extension to flow modeling of continuous or discrete data items between blocks and with extension to modeling properties of interconnected blocks as a set of mathematical equations to be solved.
Simulink® provides tools for time-based modeling and simulation of a variety of dynamic systems in one integrated, graphical environment. Simulink® enables users to design a block diagram for a dynamic system, simulate the system's behavior, analyze the performance of the system, and refine the design of the system. Simulink® allows users to design models of systems through a user interface that allows drafting of block diagrams representing systems. All of the blocks in a block library provided by Simulink® and other programs are available to users when the users are building the block diagram. Individual users may be able to customize this block library to: (a) reorganize blocks in some custom format, (b) delete blocks they do not use, and (c) add custom blocks they have designed. The blocks may be dragged through some human-machine interface (such as a mouse or keyboard) from the block library onto the window (i.e., model canvas).
Simulink® includes a block diagram editor that allows users to perform such actions as draw, edit, annotate, save, and print out block diagram representations of systems. The block diagram editor is a graphical user interface (GUI) component that allows drafting of block diagram models by users. In Simulink®, there is also a textual interface with a set of commands that allow interaction with the graphical editor, such as the textual interface provided in MATLAB®. Using this textual interface, users may write special scripts that perform automatic editing operations on the block diagram. Simulink® also allows users to simulate the models to determine the behavior of the systems. Simulink® includes a block diagram execution engine that carries out the task of compiling and linking the block diagram to produce an “in-memory executable” version of the model that is used for generating code and/or simulating a block diagram model.
Stateflow® provides a graphical environment for modeling and designing state transition systems. Stateflow® describes complex system behavior using finite state machine theory, flow diagram notations, and state-transition diagrams. Stateflow® models state diagrams that graphically represent hierarchical and parallel states and the event-driven transitions between the states of the systems. Stateflow® is integrated with Simulink®, which enables each of the state diagrams to be represented as its own block. Based on the state diagrams created in Stateflow®, Simulink® executes the systems to analyze the behavior of the systems. This provides Stateflow® with a modularization mechanism. In a Simulink® model, one Stateflow® chart can be separated from another by means of a well-defined interface that can convey data and control. As such the interaction between charts can be limited, which provides modularity to a design that allows a complexity beyond what would have been possible without such interfaces. Optionally, direct interaction between Stateflow® charts can implemented by the designer.
Different forms of code can be generated from a Stateflow® chart. This includes C, C++, and HDL. If the execution of a Stateflow® model is required to be sequential, facilities to establish a unique execution order can be employed. This includes ordering of transition and state evaluations. This ordering can be done automatically or explicitly provided by the user. An implicit ordering based on the geometry of the diagram can be applied instead, or a mixture of the approaches can be used.
A plurality of actions can be modeled in a Stateflow®0 chart. For example, condition actions are evaluated when a condition is evaluated, event actions are evaluated when an event occurs and a corresponding transition is executed, and state entry actions are executed when a state becomes active. These actions may be directly connected to a Simulink® model. Additionally, a Stateflow® chart may invoke a function-call in a Simulink® model.
The abstract model 5 can be exported into a text-based data format 6. The text-based data format 6 may contain information on the graphical and non-graphical aspects of the model 5. The text-based data format 6 may be described using the XML Metadata Interface (XMI) format. One of ordinary skill in the art will appreciate that the text-based data format 6 may be described using other markup languages, such as Hypertext Mark-up Language (HTML) and Standard Generalized Mark-up Language (SGML). Further, the text-based data format need not be a markup language format. For example, the text-based data format could be a text format or other canonical format. An exemplary text-based data format will be described below in more detail with reference to
The text-based data format 6 may be imported into the graphical programming or modeling environment 8, such as a time-based block diagram environment and/or a state and flow diagram environment. The illustrative embodiment may provide a tool for reading and analyzing the text-based data format 6 and generating a block diagram model 9 that can be simulated or executed in the graphical programming or modeling environment 8. With the block diagram model 9, the graphical programming or modeling environment 8 enables a user or programmer to realize the UML model 5 so that the UML model can be executed in an interpreted, compiled, or mixed fashion. One of ordinary skill in the art will appreciate that the time-based block diagram environment or state and flow diagram environment is an exemplary graphical programming or modeling environment and the present invention may apply to other graphical programming or modeling environments, including state-based, event-based, data flow diagrams, physical system diagrams, and entity flow networks.
The computing device 10 may be electronic and include an execution unit 11, memory 12, storage 13, an input control 14, a modem 15, a network interface 16, a display 17, etc. The execution unit 11 controls each component of the computing device 10 to provide a programming or modeling environment. The memory 12 temporarily stores instructions and data and provides them to the execution unit 11 so that the execution unit 11 operates the computing device 10 and runs the modeling or programming environment. The storage 13 usually contains software tools for applications. The storage 13 includes, in particular, code 20 for the operating system (OS) of the device 10, code 21 for applications running on the operation system including applications for providing the modeling or programming environment, and data 22 for models in the programming or modeling environment. Those of ordinary skill in the art will appreciate that the application can be stored in the memory 12 as well, much like the data, and even the OS, or they can be stored on the network described below with reference to
Optionally, the computing device 10 may include multiple Central Processing Units (CPUs) for executing software loaded in the memory 12, and other programs for controlling system hardware. Each of the CPUs can be a single or multiple core processor. The code loaded in the memory 12 may run in a virtualized environment, such as in a Virtual Machine (VM). Multiple VMs may be resident on a single processor. Also, part of the application could be run in hardware (H/W), for example, a graphics processing unit (GPU) or by configuring a field programmable gate array (FPGA) or creating an application specific integrated circuit (ASIC).
The input control 14 may interface with a keyboard 18, a mouse 19, and other input devices. The computing device 10 may receive through the input control 14 input data necessary for creating models, such as the selection of the attributes and operations of components in the models. The computing device 10 may also receive through the input control 14 input data necessary for controlling the execution of the models. The computing device 10 may present in the display 17 user interfaces for the users to create, edit, simulate, and execute the models. The resources depicted in
In the illustrative embodiment, the client 26 may include a UML modeling environment 4 that enables a user to build a UML model. The client 26 may send the UML model to the server 25 for converting the UML models into a different format so that the UML model can be used in other modeling environments. The server 25 may include a publishing tool 28 for generating a corresponding representation of the components of the UML models that can be used in the graphical programming or modeling environment 8, such as blocks in block diagram models. This representation may be in the form of a library file. This library may only contain blocks that have a corresponding representation in the UML model, and so restrict the user to only use blocks with a UML interpretation that are allowed.
Likewise, a block library may be provided that is configured towards a specific platform. For example, a library may only contain blocks that facilitate part or all of the standardized software services of Autosar. This may include blocks that correspond to the send and receive Autosar FlowPort interface. These blocks may be provided in a general purpose interface as well and they may also be made available otherwise.
In order to convert the UML model, the publishing tool 28 may use the text-based data format 6 exported from the UML model 5. The text-based data format 6 contains metadata of the UML model. The publishing tool 28 may read and analyze the text-based data format 6 and generate block diagrams for the components of the UML models based on the information contained in the text-based data format 6. The server 25 then provides the block diagrams to the client 27.
The client 27 may include the graphical programming or modeling environment 8 that enables a user to build and simulate/execute a block diagram model. The client 27 may receive from the server 25 the block diagrams of the components of the UML models and realize the methods of the components in the graphical programming or modeling environment 9. The realization of the methods of the components enables the UML model 5 to be simulated or executed so that the user can determine the behavior of the model 5. Those of ordinary skill in the art will appreciate that the network structure is illustrative and the present invention can be practiced with different structure. For example, the publishing tool 28 can reside and run on the client 27.
In another embodiment, the client 26 or 27 may download the publishing tool 28 from the server 25 and perform the conversion process on the client 26 or 27.
In one embodiment the present invention can be deployed on networked nodes, such as UNIX or Windows/XP terminals. It contains a workflow server that is notably responsible for managing a process between activities on several client applications and for maintaining the consistency of the UML model that is shared between these client applications.
The graphical programming or modeling environment client may request importing a UML model and observes the modifications of the model that result of user actions. On specific execution point of the process, it forwards these modifications to the server. The server is responsible for creating an updated version of the shared UML model with modified or new UML model elements. The server subsequently informs the other client applications that are part of the collaborative process of these modifications.
The graphical programming or modeling environment 8 enables a system designer, programmer or engineer to design, simulate, implement or test the dynamic features of a system. The graphical programming or modeling environment 8 receives the UML model and binds its elements to the specification of the UML model or the components of the UML model to represent the UML model or the components of the UML model in the graphical programming or modeling environment 8 (step 33). The representation of the UML model or the components of the UML model enables the user to realize the methods of the UML model or the components of the UML model in the graphical programming or modeling environment 8. The graphical programming or modeling environment 8 can then simulate or execute the model to determine the dynamic, numerical and real-time behavior of the model. The graphical programming or modeling environment 8 can also generate code for the model so that the code can be deployed on embedded-software, rapid-prototyping and/or hardware targets (step 34). Alternately, mechanical, electrical, or other physics based implementations may be designed to the model specification.
Configuration mechanisms allow the generated code to be tailored to the needs and wishes of the user. For example, a data store memory block can be used to specify the memory location of a variable. Alternate mechanisms to specify the memory location of a variable exist and include the location as part of its data type or being read from an external file. Further configuration mechanisms include directives for the code generation such as whether a function in software should have its arguments passed in or whether it should be global and whether the function data should be kept local to the function or whether it can be stored at the model level. Similarly, it can be specified whether a function should be reusable, the order of the arguments on the argument list, whether structured data types should be employed for each of the arguments or whether it should be a flat list, which include files to use to obtain externally defined data types, and the like.
The state machine diagram allows the user to designate the state of a class or a component in a UML model. The illustrative embodiment of the present invention extends the specification of the behavior of a UML model beyond the state designation of the UML model. The illustrative embodiment extends the specification of the behavior of a UML model to Simulink® and/or Stateflow® diagrams, which support state-based numerical and computational real-time behavior of a dynamic system. The Simulink® and/or Stateflow® environments may integrate mathematical computing and visualization. The illustrative embodiment may support the resolution of numerical algorithms with matrices, complex numbers, linear algebra, etc.
The graphical programming or modeling environment of the illustrative embodiment may support dynamically typed programming. In a dynamically typed programming environment, types are assigned to each data value in memory at runtime, rather than assigning a type to a static, syntactic entity in the program source code. The dynamically typed programming environment catches errors related to the misuse of values at the time the erroneous statement or expression is executed. In contrast, types are assigned to sets of values based on the program's source code in a statically typed programming environment. Static type disciplines operate on program source code rather than on the program execution. Therefore, in the statically typed programming environment, certain kinds of errors are detected without executing the program.
The UML model may then be exported into a text-based data format, such as an XML Metadata Interchange (XMI) format.
The XMI file 70 may include a top level object defining the XMI file. The top level object may also include information on an XMI version and a creation date. The XML file may include sub-level objects, such as <XMI.header> 71 and <XMI.content> 72. The <XMI.header> object 71 may contain information on the exporter of the model, such as an exporter name and an exporter version. The <XMI.content> object 72 contains the metadata information of the model. The <XMI.content> object 72 may contain an object 73 for containing information on the components and interfaces of the components in the model. The <XMI.content> object 72 may also include objects 74 and 75 for containing information on various diagrams of the UML model, such as a class diagram and a sequence diagram. The XMI file 70 may include information on other UML diagrams, such as a UML deployment diagram. The object 73 may include sub-objects 76-80 for containing data for the components and the interfaces between the components of the model. The portion 78 of the XMI file 70 that describes the interface (addSubIF) 63 in more detail is provided as follow.
<UML:Interface xmi.id = ‘Ifd28773m10964b9459cmm7f16’ name =
‘addSubIF’ visibility = ‘public’
isSpecification = ‘false’ isRoot = ‘false’ isLeaf = ‘false’ isAbstract = ‘false’>
<UML:TaggedValue xmi.id = ‘Ifd28773m10964b9459cmm7f30’
isSpecification = ‘false’>
<UML:TaggedValue.dataValue><p>Defines an interface with two
operations for adding and substracting
<UML:TagDefinition xmi.idref = ‘Ifd28773m10964b9459cmm7f42’/>
<UML:Operation xmi.id = ‘Ifd28773m10964b9459cmm7f28’ name = ‘add’
visibility = ‘public’
isSpecification = ‘false’ ownerScope = ‘instance’ isQuery = ‘false’
concurrency = ‘sequential’
isRoot =‘false’ isLeaf = ‘false’ isAbstract = ‘false’>
<UML:Parameter xmi.id = ‘Ifd28773m10964b9459cmm7f2e’ name = ‘a’
isSpecification = ‘false’
kind = ‘in’>
<UML:DataType xmi.idref = ‘Ifd28773m10964b9459cmm7f40’/>
<UML:Parameter xmi.id = ‘Ifd28773m10964b9459cmm7f2c’ name = ‘b’
isSpecification = ‘false’
kind = ‘in’>
<UML:DataType xmi.idref = ‘Ifd28773m10964b9459cmm7f40’/>
<UML:Parameter xmi.id = ‘Ifd28773m10964b9459cmm7f2a’ name =
‘return’ isSpecification = ‘false’
kind = ‘return’>
<UML:DataType xmi.idref = ‘Ifd28773m10964b9459cmm7f40’/>
</UML:Method xmi.id = ‘Ifd28773m10964b9459cmm7f24’ isSpecification
isQuery = ‘false’>
<UML:ProcedureExpression xmi.id = ‘Ifd28773m10964b9459cmm7f26’
language = ‘java’
body = ‘’/>
<UML:Operation xmi.idref = ‘Ifd28773m1964b9459cmm7f28’/>
<UML:Operation xmi.id = ‘Ifd28773m10964b9459cmm7f1c’ name = ‘sub’
visibility = ‘public’
isSpecification = ‘false’ ownerScope = ‘instance’ isQuery = ‘false’
concurrency = ‘sequential’
isRoot = ‘false’ isLeaf = ‘false’ isAbstract = ‘false’>
<UML:Parameter xmi.id = ‘Ifd28773m10964b9459cmm7f22’ name = ‘a’
isSpecification = ‘false’
kind = ‘in’>
<UML:DataType xmi.idref = ‘Ifd28773m10964b9459cmm7f40’/>
<UML:Parameter xmi.id = ‘Ifd28773m10964b9459cmm7f20’ name = ‘b’
isSpecification = ‘false’
kind = ‘in’>
<UML:DataType xmi.idref = ‘Ifd28773m10964b9459cmm7f40’/>
<UML:Parameter xmi.id = ‘Ifd28773m10964b9459cmm7f1e’ name =
‘return’ isSpecification = ‘false’
kind = ‘return’>
<UML:DataType xmi.idref = ‘Ifd28773m10964b9459cmm7f40’/>
<UML:Method xmi.id = ‘Ifd28773m10964b9459cmm7f18’ isSpecification
isQuery = ‘false’>
<UML:ProcedureExpression xmi.id = ‘Ifd28773m10964b9459cmm7f1a’
language = ‘java’
body = ‘’/>
<UML:Operation xmi.idref = ‘Ifd28773m10964b9459cmm7f1c’/>
The publishing tool 28 may read the XMI file 70 and generate hierarchical functional block diagrams using the information contained in the XMI file 70.
After realizing the adding and subtracting operations and error handling operations in the graphical programming or modeling environment, the user may connect the published components to execute the model, as depicted in
In one aspect of the embodiment, the interface specification is represented by a bus. This set of connections then may include the set of arguments of a function call, which may be structured data types themselves and be passed by reference or value. The function-call initiator may be represented by a bus as well and the return value of the function call can be represented by a bus. Different permutations of combinations are possible and so the function-call initiator may be included in the same bus as the function arguments and the return value. This results in a bi-directional bus because the elements in the set of connections have mixed computational causality, one connection may be the input to a block while another connection in the set of connections is output of said block.
Once a block diagram model 9 has been constructed within the graphical programming or modeling environment 8, the model may be executed in the graphical programming or modeling environment 8. Simulink®, which provides an exemplary graphical programming or modeling environment 8, includes an execution engine for carrying out the task of compiling and linking the block diagram to produce an “in-memory executable” version of the model that is used for generating code and/or simulating or linearizing a block diagram model. Model execution is carried out over a user-specified time span for a set of user-specified inputs. The execution begins when the block diagram is compiled. The compile stage marks the start of model execution and involves preparing data structures and evaluating parameters, configuring and propagating block characteristics, determining block connectivity, and performing block reduction and block insertion. The preparation of data structures and the evaluation of parameters create and initialize basic data-structures needed in the compile stage. For each of the blocks, a method forces the block to evaluate all of its parameters. This method is called for all blocks in the block diagram. If there are any unresolved parameters, execution errors are thrown at this point. During the configuration and propagation of block and port/signal characteristics, the compiled attributes (such as dimensions, data types, complexity, or sample time) of each block (and/or ports) are setup on the basis of the corresponding functional attributes and the attributes of blocks (and/or ports) that are connected to the given block through lines. The attribute setup is performed through a process during which block functional attributes “ripple through” the block diagram from one block to the next following signal connectivity. This process (referred to herein as “propagation”), serves two purposes. In the case of a block that has explicitly specified its block (or its ports) functional attributes, propagation helps ensure that the attributes of this block are compatible with the attributes of the blocks connected to it. If not, an error is issued. Secondly, in many cases blocks are implemented to be compatible with a wide range of attributes. Such blocks adapt their behavior in accordance with the attributes of the blocks connected to them. This is akin to the concept of polymorphism in object-oriented programming languages. The exact implementation of the block is chosen on the basis of the specific block diagram in which this block finds itself. Included within this step are other aspects such as validating that all rate-transitions within the model yield deterministic results and that the appropriate rate transition blocks are being used.
The compilation step also determines actual block connectivity. In this step, the virtual blocks in the block diagram, which play no semantic role in the execution of a block diagram, are optimized away (removed) and the remaining non-virtual blocks are reconnected to each other appropriately. This compiled version of the block diagram with actual block connections is used from this point forward in the execution process. The way in which blocks are interconnected in the block diagram does not necessarily define the order in which the equations (methods) corresponding to the individual blocks will be solved (executed). The actual order is partially determined during the sorting step in compilation. Once the compilation step has completed, the sorted order cannot be changed for the entire duration of the block diagram's execution.
Following the compilation stage is the model link stage. After linking has been performed, code may or may not be generated. If code is generated, the model is simulated/executed through accelerated simulation mode in which the block diagram model (or portions of it) is translated into either software modules or hardware descriptions (broadly termed code). If this stage is performed, then the stages that follow use the generated code during the execution of the block diagram. If code is not generated, the block diagram may execute in interpretive mode in which the compiled and linked version of the block diagram may be directly utilized to execute the model over the desired time-span. This interpretive mode of execution is suitable for getting fine-grained signal traceability. Block diagram programming software can be integrated with other software environments that are suitable for modeling and simulating special classes of systems. Models can be tested directly in hardware. Those skilled in the art will recognize that when users generate code, they may choose to not proceed further with the block diagram's execution. They may choose to take the code and deploy it outside of the confines of the modeling software environment. This is normally the last step in the design of dynamic systems in a block diagram software package.
Dynamic systems are typically modeled as sets of differential, difference, algebraic, and/or recursive equations. At any given instant of time, these equations may be viewed as relationships between the system's output response (“outputs”), the system's input stimuli (“inputs”) at that time, the current state of the system, the system parameters, and time. The state of the system may be thought of as a numerical representation of the dynamically changing configuration of the system. For instance, in a physical system modeling a simple pendulum, the state may be viewed as the current position and velocity of the pendulum. Similarly, a signal-processing system that filters a signal would maintain a set of previous inputs as the state. The system parameters are the numerical representation of the static (unchanging) configuration of the system and may be viewed as constant coefficients in the system's equations. For the pendulum example, a parameter is the length of pendulum and for the filter example; a parameter is the values of the filter taps.
Types of mathematical models used in the study of dynamic systems include differential equations, difference equations, algebraic equations, and hybrid models. Inherent in four of the classes of systems (ODE, difference equations, algebraic equations and composite) is the notion of system sample time. The sample-time is the time interval at which the inputs, state, or outputs (collectively referred to as the results) of the system are traced as time progresses. Based on sample times, a system can be described as a discrete-time system, continuous-time system and hybrid system.
A discrete-time system is a system in which the evolution of the system results is tracked at finite intervals of time. In the limit as the interval approaches zero, the discrete-time system becomes a continuous-time system. The intervals of time may be periodic or non-periodic. Sometimes, non-periodic rate systems are referred to as non-uniform rate systems meaning that there is no periodic rate at which the response can be tracked. A continuous-time system is a system in which the evolutions of the system results are continuously changing. Continuous-time signals change during numerical integration. An example of a continuous-time system is one described by an ODE. There can also be algebraic or composite continuous-time systems. A hybrid system is a system with both discrete-time and continuous-time elements.
If a system has only one sample time, it is said to be single-rate. If a system has multiple sample times, it is said to be multi-rate. Multi-rate systems can be evaluated (executed) using either a single-tasking form of execution or a multi-tasking form of execution. When multi-tasking execution is used, it conforms to rate monotonic scheduling principals as defined by Liu, C. L., and Layland, J. W. Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment. ACM 20, 1 (January 1973), 46-61. Systems may also be categorized by the type of numerical integration solver being used. A fixed-step system is one that uses a fixed-step solver. Fixed-step solvers typically use explicit methods to compute the next continuous state at fixed periodic intervals of time. A variable-step system is one that is using a variable-step solver. A variable-step solver can use either implicit or explicit methods to compute the next continuous state at non-periodic intervals of time. Generally, variable-step solvers use a form of error control to adjust the interval size such that the desired error tolerances are achieved.
The monitored signals can be scoped such that both the individual or grouped control-event and data signals that flow through the run-time links between the component objects are displayed. In addition, any internal signal, variable, and parameter, that is defined within a component object may be selectively displayed.
The illustrative embodiment may log calls and reply actions between the components of the model. The graphical programming or modeling environment 8 may construct a sequence diagram 130 based on the simulation and execution data of the model in the graphical programming or modeling environment, as depicted in
The generated sequence diagram 130 may be merged into the source UML model 5 that contains the definition of the components of the model so that the user of the UML model 5 can have a real-time sequential behavior of the UML model 5 or the components of the UML model 5. The sequence diagram 130 may be exported into, for example, an XML format so that the UML environment 4 can recognize the sequence diagram 130 generated in the graphical programming or modeling environment 8.
With the realization of the components of the UML model 5, the graphical programming or modeling environment 8 may simulate or execute a deployment diagram of the UML 5. A deployment diagram is one of UML diagrams that serves to model the hardware used in system implementations and the associations between those components. The elements used in deployment diagrams are nodes, components and associations. Therefore, the simulation or execution of the deployment diagram assesses performance and schedulability requirement of run-time processing nodes against the time and numerical resolution of control and signal processing algorithms with safety and reliability constraints.
Since changes may be made without departing from the scope of the present invention, it is intended that all matter contained in the above description or shown in the accompanying drawings be interpreted as illustrative and not in a literal sense. Practitioners of the art will realize that the sequence of steps and architectures depicted in the figures may be altered without departing from the scope of the present invention and that the illustrations contained herein are singular examples of a multitude of possible depictions of the present invention.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US6874146 *||Jun 30, 1999||Mar 29, 2005||Unisys Corporation||Metadata driven system for effecting extensible data interchange based on universal modeling language (UML), meta object facility (MOF) and extensible markup language (XML) standards|
|US20050071803 *||Sep 30, 2003||Mar 31, 2005||Markus Cherdron||Development environment for developing applications using a metamodel|
|US20050234976 *||Dec 14, 2004||Oct 20, 2005||Relativity Technologies, Inc.||System and method for deriving an object oriented design from the business rules of a legacy application|
|US20060136482 *||Dec 22, 2004||Jun 22, 2006||Conn Sharon T||Defining and generating a viewtype for a base model|
|US20070198968 *||Feb 2, 2006||Aug 23, 2007||Michael Shenfield||System and method and apparatus for using UML tools for defining web service bound component applications|
|1||*||Simulink, "Using Simulink", Version 5, copyright 2002, chp. 1-14, 472 pg|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7849394 *||Oct 25, 2001||Dec 7, 2010||The Math Works, Inc.||Linked code generation report|
|US7908587 *||Sep 13, 2006||Mar 15, 2011||Knox Lee B||IO update time based conditional statement evaluation|
|US8065655 *||Jun 20, 2006||Nov 22, 2011||International Business Machines Corporation||System and method for the autogeneration of ontologies|
|US8065658 *||Aug 7, 2007||Nov 22, 2011||Network Appliance, Inc.||Tool for visualizing software architecture|
|US8140305 *||Oct 17, 2007||Mar 20, 2012||International Business Machines Corporation||Conversion of an application program|
|US8181151 *||Oct 26, 2007||May 15, 2012||Microsoft Corporation||Modeling and managing heterogeneous applications|
|US8209669 *||Apr 20, 2007||Jun 26, 2012||Sap Ag||System and method for supporting software|
|US8234633||Jan 9, 2008||Jul 31, 2012||Sap Ag||Incident simulation support environment and business objects associated with the incident|
|US8291378||Jul 29, 2008||Oct 16, 2012||International Business Machines Corporation||Simplified deployment modeling|
|US8302093||Aug 28, 2008||Oct 30, 2012||International Business Machines Corporation||Automated deployment of defined topology in distributed computing environment|
|US8352906 *||Dec 28, 2007||Jan 8, 2013||Cadence Design Systems, Inc.||Method, system, and computer program product for implementing external domain independent modeling framework in a system design|
|US8359304||Jul 18, 2011||Jan 22, 2013||The Mathworks, Inc.||Collaborative modeling environment|
|US8381145 *||Oct 26, 2010||Feb 19, 2013||Electronics And Telecommunications Research Institute||Method and apparatus for analyzing fault behavior of a software design model|
|US8387002 *||May 15, 2007||Feb 26, 2013||National Instruments Corporation||Statechart development environment with embedded graphical data flow code editor|
|US8397210||Jun 3, 2008||Mar 12, 2013||Microsoft Corporation||Evolving the architecture of a software application|
|US8402381||Sep 23, 2008||Mar 19, 2013||International Business Machines Corporation||Automatically arranging widgets of a model within a canvas using iterative region based widget relative adjustments|
|US8417658||Sep 12, 2008||Apr 9, 2013||International Business Machines Corporation||Deployment pattern realization with models of computing environments|
|US8429605||Dec 30, 2009||Apr 23, 2013||The United States Of America As Represented By The Secretary Of The Navy||Finite state machine architecture for software development|
|US8458663 *||Feb 16, 2009||Jun 4, 2013||International Business Machines Corporation||Static code analysis|
|US8479151 *||May 12, 2010||Jul 2, 2013||National Instruments Corporation||Converting a statechart from a first statechart format to a second statechart format|
|US8490067 *||May 22, 2008||Jul 16, 2013||National Instruments Corporation||Graphical program code coverage|
|US8600954||Jul 18, 2011||Dec 3, 2013||The Mathworks, Inc.||Collaborative modeling environment|
|US8671110||Jul 18, 2011||Mar 11, 2014||The Mathworks, Inc.||Collaborative modeling environment|
|US8676768||Jul 18, 2011||Mar 18, 2014||The Mathworks, Inc.||Collaborative modeling environment|
|US8677317||Mar 30, 2012||Mar 18, 2014||International Business Machines Corporation||Simplified deployment modeling|
|US8707252 *||Sep 3, 2008||Apr 22, 2014||Emc Corporation||Techniques for automatic generation of parsing code|
|US8726228 *||Jul 28, 2011||May 13, 2014||National Instruments Corporation||Developing programs in a graphical specification and constraint language|
|US8739124||Jun 27, 2012||May 27, 2014||Sap Ag||Configuring integration capabilities for system integration|
|US8745026 *||Jul 18, 2011||Jun 3, 2014||The Mathworks, Inc.||Collaborative modeling environment|
|US8745577 *||Sep 29, 2010||Jun 3, 2014||International Business Machines Corporation||End to end automation of application deployment|
|US8751199 *||Dec 27, 2006||Jun 10, 2014||The Mathworks, Inc.||Method of graphically linking multiple disjoint models|
|US8793652||Jun 7, 2012||Jul 29, 2014||International Business Machines Corporation||Designing and cross-configuring software|
|US8799203||Jul 16, 2009||Aug 5, 2014||International Business Machines Corporation||Method and system for encapsulation and re-use of models|
|US8849987||Jun 30, 2009||Sep 30, 2014||International Business Machines Corporation||Automated discovery of a topology of a distributed computing environment|
|US8863075 *||Aug 10, 2011||Oct 14, 2014||Sap Ag||Automated support for distributed platform development|
|US8924923 *||Feb 5, 2013||Dec 30, 2014||Sejong Industry-Academia Cooperation Foundation Hongik University||Apparatus and method of generating multi-level test case from unified modeling language sequence diagram based on multiple condition control flow graph|
|US8938381 *||Jul 15, 2013||Jan 20, 2015||The Mathworks, Inc.||Automatic numerical simulation of processor environment|
|US8943474 *||Oct 24, 2012||Jan 27, 2015||The Mathworks, Inc.||Code generation and execution for dynamic programming languages|
|US9003343 *||Apr 3, 2013||Apr 7, 2015||Harbin Institute Of Technology||Energy consumption simulation and evaluation system for embedded device|
|US9015593 *||Dec 1, 2008||Apr 21, 2015||International Business Machines Corporation||Managing advisories for complex model nodes in a graphical modeling application|
|US9020792 *||Sep 17, 2010||Apr 28, 2015||International Business Machines Corporation||Coupling architectural and implementation/behavioral models of a computer-based system|
|US9064065||Mar 15, 2013||Jun 23, 2015||International Business Machines Corporation||Coupling architectural and implementation/behavioral models of a computer-based system|
|US20040205507 *||Oct 25, 2001||Oct 14, 2004||Kai Tuschner||Linked code generation reports|
|US20080255997 *||Apr 16, 2007||Oct 16, 2008||Bluhm Thomas H||Enterprise integrated business process schema|
|US20080263512 *||May 15, 2007||Oct 23, 2008||Dellas Christina M||Statechart Development Environment with Embedded Graphical Data Flow Code Editor|
|US20090113379 *||Oct 26, 2007||Apr 30, 2009||Microsoft Corporation||Modeling and managing heterogeneous applications|
|US20090172632 *||Dec 28, 2007||Jul 2, 2009||Cadence Design Systems, Inc.||Method, System, and Computer Program Product for Implementing External Domain Independent Modeling Framework in a System Design|
|US20090210854 *||Feb 16, 2009||Aug 20, 2009||International Business Machines Corporation||Static Code Analysis|
|US20090293044 *||May 22, 2008||Nov 26, 2009||Boettcher Jeffrey R||Graphical Program Code Coverage|
|US20090323578 *||Jun 25, 2008||Dec 31, 2009||Robert Bosch Gmbh||Wireless Vehicle Communication Method Utilizing Wired Backbone|
|US20100138795 *||Dec 1, 2008||Jun 3, 2010||International Business Machines Corporation||Managing advisories for complex model nodes in a graphical modeling application|
|US20100162203 *||Aug 28, 2009||Jun 24, 2010||Electronics And Telecommunications Research Institute||Project management device and method for architecture modeling tool of application software on autosar and computer readable recording medium therefor|
|US20100192164 *||Jun 5, 2008||Jul 29, 2010||Michael Golm||Method for the transparent replication of a software component of a software system|
|US20110246954 *||Oct 6, 2011||Electronics And Telecommunications Research Institute||Method and apparatus for analyzing fault behavior|
|US20110252398 *||Oct 20, 2009||Oct 13, 2011||International Business Machines Corporation||Method and system for generating vocal user interface code from a data metal-model|
|US20110283254 *||Nov 17, 2011||Merriman David J||Converting a Statechart from a First Statechart Format to a Second Statechart Format|
|US20120030646 *||Feb 2, 2012||Kaushik Ravindran||Developing Programs in a Graphical Specification and Constraint Language|
|US20120072198 *||Sep 17, 2010||Mar 22, 2012||International Business Machines Corporation||Coupling architectural and implementation/behavioral models of a computer-based system|
|US20120079450 *||Mar 29, 2012||International Business Machines Corporation||End to end automation of application deployment|
|US20120291003 *||Nov 15, 2012||The Mathworks, Inc.||System and method for creating and using graphical object instances in a statechart environment|
|US20130042219 *||Aug 10, 2011||Feb 14, 2013||Sap Ag||Automated Support for Distributed Platform Development|
|US20130125088 *||Nov 16, 2011||May 16, 2013||Raytheon Company||System and method for developing an object-oriented system|
|US20140068548 *||Jun 27, 2013||Mar 6, 2014||Electronics And Telecommunications Research Institute||Parameter setting apparatus and method for automotive open system architecture-based software|
|US20140130006 *||Feb 5, 2013||May 8, 2014||Daegu National University Of Education Industry- Academic Cooperation Foundation||Apparatus and method of generating multi-level test case from unified modeling language sequence diagram based on multiple condition control flow graph|
|US20140208287 *||Apr 3, 2013||Jul 24, 2014||Harbin Institute Of Technology||Energy Consumption Simulation and Evaluation System for Embedded Device|
|US20140282366 *||Mar 15, 2013||Sep 18, 2014||Oracle International Corporation||Flexible microinstruction system for constructing microprograms which execute tasks, gateways, and events of bpmn models|
|WO2011148385A2 *||May 18, 2011||Dec 1, 2011||Tata Consultancy Services Limited||Method and system for disintegrating an xml document for high degree of parallelism|
|WO2011148385A3 *||May 18, 2011||Jan 26, 2012||Tata Consultancy Services Limited||Method and system for disintegrating an xml document for high degree of parallelism|
|WO2013040043A1 *||Sep 12, 2012||Mar 21, 2013||Rolls-Royce Corporation||Development tool|
|Jul 26, 2006||AS||Assignment|
Owner name: MATHWORKS, INC., THE, MASSACHUSETTS
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:BRUNEL, JEAN-YVES;BREWTON, NATHAN E.;MESTCHIAN, MEHRAN;AND OTHERS;REEL/FRAME:018018/0863;SIGNING DATES FROM 20060713 TO 20060720