TASTE Semantics

From TASTE
Revision as of 15:54, 29 January 2021 by Mperrotin (talk | contribs) (Function)
Jump to: navigation, search

Introduction

This page gives a comprehensive description of the semantics behind the TASTE meta-model.

THIS PAGE IS WORK IN PROGRESS

Interface View

The interface view in TASTE captures the model of the system logical architecture, independently from a software implementation.

In the most abstract way, a system modeled with TASTE contains functions that exchange messages with other functions through interfaces.

The semantics of the interface view is largely inspired by the Specification and Description Language (SDL). There are a few differences that are explained below.

Function

There are several forms of functions in TASTE :

  • functions that represent an active component of the system (e.g. a state machine or a control law), something that can communicate with surrounding functions.
  • nesting functions, that allow to structure the system in a hierarchical way (grouping by context, or for better readability). Nesting is recursive with no limit.
  • function types, which contain a generic behavior and that can be instantiated
  • function instances

Graphically, terminal functions have this simple shape including the name of the function:


ClipCapIt-210128-204613.PNG

While nesting function generally appear like this (depending on the tool) - showing a mini-view of the function content.

ClipCapIt-210128-205423.PNG

Function types have a slightly different shape:

ClipCapIt-210128-210214.PNG


Semantics

A normal function in TASTE is a terminal level entity. It has a behavior that can be triggered through a set of provided interfaces.

All provided interfaces of a function have visibility and control access on the function's internal data (or state).

With one exception, the interfaces of a function are mutually exclusive, and run to completion: it is not possible to execute concurrently two interfaces of a function, as they share the function state.

The exception to this rule is the unprotected interface, which is executed immediately, possibly concurrently with other interfaces.

The attributes (or properties) of the functions are defined in the taste metamodel - https://gitrepos.estec.esa.int/taste/taste-setup/-/blob/feature_buster/misc/space-creator/default_attributes.xml

The main attributes are:

  • the function name
  • the function *implementation language*
  • optionally, if the function is an instance, the corresponding type
  • a flag to indicate if the function is a type

In TASTE editors, the list of attributes is obtained by double-clicking on a function.

ClipCapIt-210129-164829.PNG

The list of supported languages is defined in the metamodel.

A function can have optional context parameters. There are two kinds of such parameters:

  • timers
  • typed parameters with a value

Context parameters are linked to the inmplementation language of the functions and are available only for a subset of these supported languages. For example if a function is implemented in Matlab Simulink, it won't be possible to add timers to it. Typed parameters, on the other hand will be mapped to Simulink tuneable parameters.

When a function type has context parameters, the value can be overwritten in instances of this type. This allows the function type to define a behavior that is parameterized by some values, and to have instance that give the actual values.