The development process
of a typical simulation module is described below and
in the following figure:

The design process of simulation modules
with SimDeveloper starts with the definition
of the different simulation entities that make up the
simulator. The attributes to be published and who publishes
or subscribes them is defined. In the same way, these
attributes are defined for the application user interface
to be used. All of this information is contained in
the "Data Model" of the simulator. To define
this model, we use a piece of interactive data, which
lets you define the various modules, attribute types
and interactions, as well as frequency and type of data
transmission, and the various nodes that use the simulator.
Once defined the data model simulator,
an XML file is self generated for each module simulation
with all the information needed for communication within
the simulator.
.
The manufacturing of modules with SimDeveloper
is achieved through the implementation of Mathworks
and Simulink. The manufacturing process of modules uses
a collection of libraries of SimDeveloper,
loads the XML file data for each module, and builds
the structure of the module with data input and output
and the state machine simulator, which allows initialization,
stabilization, pause, normal execution and finalization
of the simulation.
The simulation modules are subdivided
into functional units called "models". These
models simulate specific functions and have a large
number of parameters that allow adaptation to different
modules. Already developed and tested models are, thus,
used in building new simulation modules. The re-use
of these models allows/improves the performance of the
design process and in the other hand provides a better
reliability to the system as those modules have been
already tested in similar simulators.
If there is not a model that allows
a faithful representation of the desired functionality,
then a new model is design and programmed using Simulink,
following parameterization criteria to adapt reliably
to the module. Once completed, will undergo a series
of unit tests to ensure the requirements are fulfil.
Following integration of all models
that have been unit tested, the final simulation module
is screened to the defined module testing under Simulink
environment.
Once all modules that will compose
the simulator have been built and have passed their
respective module testing, those are integrated in Simulink
and an integration tests is performed to ensure that
interact properly and represent faithfully the behaviour
of the real object of the simulation. In this phase
the parameters of the simulation models are fine adjusted
to achieve representation as real as possible.
The next step is the generation of
code which is an automated with the SimDeveloper
library that uses the XML file with the data model,
to generate static or dynamic libraries to be used in
the final execution environment. It is important to
highlight that the generated code is completely open
and independent of the development environment Simdeveloper,
so it means that can be deployed and maintained independently
of the development environment.
Based on the same data model used for
simulation modules, the XML files generated include
the attributes and interactions to be used by the application
user interface. This files are responsible for publishing
the initial conditions of the simulation exercise to
be undertaken, allowing the user to introduce such conditions
easily. The files will publish as well data affecting
the behaviour simulator during his execution in real
time and subscribes the data needed to present to the
user the simulation results.
|