// copyright 2013-2020 BAE Systems, Thales Group, Object Management Group Inc; 2013 Selex ES, DSTO, Atlas Elektronik, EADS Deutschland GmbH
#ifndef ORGOMGC4IDOMAIN_MODELSUBSYSTEM_DOMAINSUBSYSTEM_CONTROLDEFVAR
#define ORGOMGC4IDOMAIN_MODELSUBSYSTEM_DOMAINSUBSYSTEM_CONTROLDEFVAR
#include "Common_Types.idl"
module org
{
module omg
{
module c4i
{
module Domain_Model
{
module Subsystem_Domain
{
// Contains Structs used within the Subsystem Control service and a state diagram
// corresponding with the Manage Technical State interface.
module Subsystem_Control
{
// Categorization of equipment. Values correspond to items in an externally defined
// list.
struct equipment_category_type
{
// Prefix for the schema from which the value is drawn
string schemaPrefix;
// Value from the schema denoted by the prefix
string value;
};
// Unique identifier for a function within a subsystem.
typedef unsigned short function_id_type;
// struct holding keys for class function_type.
struct function_key_type
{
// The functions unique idenitifier
function_id_type function_id;
// Indicates which subsystem published the data or is intended to read it as a
// subscriber
org::omg::c4i::Domain_Model::Common_Types::subsystem_id_type subsystem_id;
};
// Categorization of platforms (i.e. structures such as ships and planes) that host
// CMS, sensors and other subsystems. Values correspond to items in an externally
// defined list.
struct platform_category_type
{
// Prefix for the schema from which the value is drawn
string schemaPrefix;
// Value from the schema denoted by the prefix
string value;
};
// Categorization of a product. Values correspond to items in an externally defined
// list.
struct product_category_type
{
// Prefix for the schema from which the value is drawn
string schemaPrefix;
// Value from the schema denoted by the prefix
string value;
};
// Enumeration of possible service names. Where a service may be offered at
// different compliance levels, multiple names are introduced with _LEVEL_x postfix
// to indicate different parts.
enum service_name_type
{
// air engagement support service
AIR_ENGAGEMENT_SUPPORT,
// clutter reporting service
CLUTTER_REPORTING,
// encyclopaedic support service
ENCYCLOPAEDIC_SUPPORT,
// engagement support service
ENGAGEMENT_SUPPORT,
// C2INav service support as per compliance level 3F
NAVIGATION_INFORMATION_LEVEL_3F,
// Meteorological and Oceanographic support service as per compliance level 3G
METOC_LEVEL_3G,
// Extensions to the subsystem control service
EXTENDED_SUBSYSTEM_CONTROL,
// jammer reporting service
JAMMER_REPORTING,
// missile guidance service
MISSILE_GUIDANCE,
// plot reporting service to compliance level 1
PLOT_REPORTING_LEVEL_1,
// plot reporting service to compliance level 3C
PLOT_REPORTING_LEVEL_3C,
// plot reporting service to compliance level 3E
PLOT_REPORTING_LEVEL_3E,
// recording and replay service
RECORDING_AND_REPLAY,
// search service
SEARCH,
// sensor control service to compliance level 2
SENSOR_CONTROL_LEVEL_2,
// sensor performance service
SENSOR_PERFORMANCE,
// simulation support service
SIMULATION_SUPPORT,
// subsystem control service to compliance level 1
SUBSYSTEM_CONTROL_LEVEL_1,
// subsystem control service to compliance level 2
SUBSYSTEM_CONTROL_LEVEL_2,
// surface engagement support service
SURFACE_ENGAGEMENT_SUPPORT,
// track reporting service to compliance level 1
TRACK_REPORTING_LEVEL_1,
// track reporting service to compliance level 3C
TRACK_REPORTING_LEVEL_3C,
// track reporting service to compliance level 3E
TRACK_REPORTING_LEVEL_3E,
// tracking control service to compliance level 2
TRACKING_CONTROL_LEVEL_2,
// tracking control service to compliance level 3C
TRACKING_CONTROL_LEVEL_3C,
// sensor control service to compliance level 3A
SENSOR_CONTROL_LEVEL_3A,
// contact reporting service
CONTACT_REPORTING,
// parametric reporting
PARAMETRIC_REPORTING,
// track assessment service
TRACK_ASSESSMENT,
// media streaming service
MEDIA_STREAMING
};
// If the boolean is true the battle override is applied.
struct battle_override_state_type
{
// Indicates if the battle override is applied or not.
boolean battle_override_applied;
};
// A string type
// Name of an entry in the device identification.
typedef string<64> device_name_type;
// A string type
// The valid range of the information parameter.
typedef string<32> parameter_range_type;
// A string type
// The quality of service being requested of the information service.
typedef string<32> quality_of_service_type;
// A string type
// Identification of the recipient of the information service.
typedef string<32> recipient_type;
// A string type
// A typical value of the information parameter so as to assist in providing a
// suitable value.
typedef string<32> typical_value_type;
// Type of event
enum event_type
{
// The event corresponds to the occurrence of some phenomena
OCCURRENCE,
// The event corresponds to the disappearance of some phenomena
DISAPPEARANCE
};
// Reason for the health state
struct health_state_reason_type
{
// The health state has been caused by a fault
boolean caused_by_fault;
// The health state is due to the subsystem being in a particular technical state
boolean caused_by_technical_state;
// The health state is due to the subsystem being in a particular simulation mode
boolean caused_by_simulation_mode;
// The health state is due to the subsystem being in a particular operational mode
boolean caused_by_operational_mode;
};
// Encapsulation of health state
enum health_state_type
{
// Service: Indicates that the service is available with specified performance.
// Subsystem: Indicates that all implemented services of the subsystem have health
// state AVAILABLE.
AVAILABLE,
// Service: Indicates that the service may perform its operational task, but
// possibly with less than specified performance.
// Subsystem: Indicates that at least one of the implemented services of the
// subsystem have health state other than AVAILABLE.
DEGRADED,
// Service: Indicates that the service is not available.
// Subsystem: Indicates that all implemented services of the subsystem have health
// state NOT_AVAILABLE.
NOT_AVAILABLE,
// Indicates that the subsystem may not determine the health state of the service or
// subsystem (e.g. because BIT is not running).
UNKNOWN_HEALTH
};
// Name of information
enum information_name_type
{
// Air plots information service
AIR_PLOTS,
// Surface plots information service
SURFACE_PLOTS,
// Land plots information service
LAND_PLOTS,
// Space plots information service
SPACE_PLOTS,
// Subsurface plots information service
SUBSURFACE_PLOTS,
// Air tracks information service
SENSOR_AIR_TRACKS,
// Surface tracks information service
SENSOR_SURFACE_TRACKS,
// Land tracks information service
SENSOR_LAND_TRACKS,
// Space tracks information service
SENSOR_SPACE_TRACKS,
// Subsurface tracks information service
SENSOR_SUBSURFACE_TRACKS,
// Jammer strobes information service
JAMMER_STROBES,
// jammer tracks information service
JAMMER_TRACKS,
// jammer effect assessments information service
JAMMING_EFFECT_ASSESSMENTS,
// interference reports information service
INTERFERENCE_REPORTS
};
// This enumeration represents the state of the mastership.
// The subsystem Mastership may be either “free”, that is assigned to none and then
// available to anybody asks for it, or assigned to somebody: CMS or not.
enum mastership_state_type
{
// Mastership state is “free”, the first received Mastership request shall be
// satisfied.
MASTERSHIP_FREE,
// The Mastership is assigned to somebody other than CMS.
MASTERSHIP_OTHER,
// The Mastership is assigned to CMS.
MASTERSHIP_TO_CMS
};
// The value should be mapped to the corresponding operational mode. This mapping is
// retrieved through the service 'Manage Subsystem Parameters'.
typedef unsigned short operational_mode_type;
// Response type for retrieving and modifying sequences of parameters.
struct parameter_value_response_type
{
// The identifier for the request.
long request_id;
};
// Type of registration
enum registration_type
{
// Registering for a service
REGISTER,
// Deregistering for a service
DEREGISTER
};
// Type of service
struct service_type
{
// Only registrable services are allowed
service_name_type service_name;
};
// Type which is used to indicate a technical state.
enum technical_state_type
{
// Subsystem is running Built-In-Test procedure. CMS may communicate with
// subsystem, but subsystem shall only respond affirmatively to a limited set of
// commands. From this state the subsystem may transition to READY,
// FAILED, CALIBRATE, STANDBY (transition may be ordered before
// completion of BIT if Battle Override is enabled), or OFFLINE.
BIT,
// Subsystem is running calibration procedure. Subsystem shall only respond to a
// limited set of commands from CMS. From this state the subsystem may transition
// to READY, FAILED, BIT, STANDBY (transition may be ordered before
// completion of calibration if Battle Override is enabled), or OFFLINE.
CALIBRATE,
// Interface between CMS and subsystem may or may not exist. Some power is applied
// to the subsystem and temperature control (e.g. cooling) is active. From this
// state, the sub-system may transition to FAILED, STANDBY, or OFFLINE.
DORMANT,
// Subsystem is non-operational due to a critical fault such as a primary power
// supply failure. CMS is able to communicate with subsystem to perform diagnostics.
// In the FAILED state, the health state of the sub-system and nearly all associated
// services is NOT AVAILABLE or UNKNOWN (provided via Health State). If the health
// state of the sub-system or some services is DEGRADED, the sub-system is not
// required to enter into this state. From this state the sub-system may transition
// to BIT, STANDBY, READY, CALIBRATE, DORMANT or
// OFFLINE.
FAILED,
// No connection between CMS and Subsystem is open. Main power is usually not
// applied to subsystem. From OFFLINE, subsystem transitions to FAILED, DORMANT,
// BIT, or STANDBY.
OFFLINE,
// Subsystem is operational and may respond to all requests from CMS. Simulation and
// diagnostics may be allowed in this state. Radiation is allowed in this state but
// must be commanded on via Control Emissions. From this state the subsystem may
// transition to BIT, CALIBRATE, READY, STANDBY, FAILED, or OFFLINE.
ONLINE,
// Subsystem is ready for CMS to command full operation. Simulation may be allowed
// in this state. Ready to transition to ONLINE, self-tests and calibration
// has been performed as necessary. Radiation is not allowed in the READY state.
// From this state the subsystem may transition to STANDBY, ONLINE, FAILED,
// BIT, CALIBRATE, or OFFLINE.
READY,
// Interface between CMS and subsystem is established. Subsystem may not operate
// fully. Maintenance may be performed in this state. From this state the sub-system
// may transition to READY, CALIBRATE, BIT, FAILED, DORMANT, or OFFLINE.
STANDBY
};
// Version of the equipment
struct version_type
{
// Major version number
unsigned short major_version;
// Minor version number
unsigned short minor_version;
};
// A sequence type, to represent multiple values.
typedef sequence function_applicable_mode_id_type;
// Indication of a service provided by the subsystem.
struct service_indication_type
{
// Name of the service.
service_name_type service_name;
// Indication whether the service is registered.
boolean registration_indicator;
};
// A sequence type, to represent multiple values.
typedef sequence descriptor_related_parameter_id_type;
// A string type
// Typdef for bounded string type for attribute function_name of class function_type.
typedef string<32> function_function_name_type;
// A string type
// Typdef for bounded string type for attribute parameter_name of class descriptor_type.
typedef string<128> descriptor_parameter_name_type;
// A string type
// Typdef for bounded string type for attribute parameter_type of class descriptor_type.
typedef string<32> descriptor_parameter_type_type;
// A string type
// Typdef for bounded string type for attribute parameter_unit of class descriptor_type.
typedef string<32> descriptor_parameter_unit_type;
// A string type
// Typdef for bounded string type for attribute fault_name of class fault_type.
typedef string<32> fault_fault_name_type;
// A string type
// Typdef for bounded string type for attribute fault_isolation_data of class fault_type.
typedef string<32> fault_fault_isolation_data_type;
// A string type
// Typdef for bounded string type for attribute parameter_name of class parameter_name_type.
typedef string<128> parameter_name_parameter_name_type;
// A string type
// Typdef for bounded string type for attribute parameter_name of class name_error_pair_type.
typedef string<128> name_error_pair_parameter_name_type;
// A string type
// Typdef for bounded string type for attribute error_indication of class name_error_pair_type.
typedef string<32> name_error_pair_error_indication_type;
// A string type
// Typdef for bounded string type for attribute parameter_name of class name_value_pair_type.
typedef string<128> name_value_pair_parameter_name_type;
// A string type
// Typdef for bounded string type for attribute value of class name_value_pair_type.
typedef string<32> name_value_pair_value_type;
// A sequence type, to represent multiple values.
typedef sequence service_list_service_indication_type;
// a simple union type, to represent an optional value
union descriptor_parameter_range_type switch (boolean)
{
// the value when present
case TRUE : parameter_range_type value;
};
// A sequence type, to represent multiple values.
typedef sequence device_identification_serial_number_type;
// a simple union type, to represent an optional value
union descriptor_typical_value_type switch (boolean)
{
// the value when present
case TRUE : typical_value_type value;
};
// a simple union type, to represent an optional value
union interest_quality_of_service_type switch (boolean)
{
// the value when present
case TRUE : quality_of_service_type value;
};
// a simple union type, to represent an optional value
union interest_recipient_type switch (boolean)
{
// the value when present
case TRUE : recipient_type value;
};
// Information about a service
struct service_information_type
{
// The name of the information in the service.
information_name_type information_name;
};
// Typedef for strings representing names of parameters.
struct parameter_name_type
{
// parameter_name values are unique within the scope of a subsystem.
parameter_name_parameter_name_type parameter_name;
};
// A sequence type, to represent multiple values.
typedef sequence descriptor_applicable_operational_mode_type;
// Health of service
struct service_health_type
{
// The name of the service being reported on
service_name_type service_name;
// The state of health of the service
health_state_type health_state;
// The reason for the health state
health_state_reason_type health_state_reason;
// The absolute time at which the information was known to be valid
org::omg::c4i::Domain_Model::Common_Types::time_type time_of_information;
};
// A sequence type, to represent multiple values.
typedef sequence descriptor_technical_state_type;
// A sequence type, to represent multiple values.
typedef sequence service_indication_list_service_indication_type;
// A list of service names as used by Provide_Subsystem_Services.
struct service_list_type
{
service_list_service_indication_type service_indication;
};
// A function operated by the subsystem
// Subsystems provide several operational modes like long-range-detection,
// missile-detection, surface surveillance etc. in case of surveillance radar,
// normal tracking, slaved, joystick controlled in case of fire control radar etc.
// Operational modes summarise a set of subsystem parameters optimising the
// subsystem with respect to an operational purpose.
// The names of modes of a specific type of subsystem (e.g. or a radar) differ from
// supplier to supplier. Consequently, they shall be handled as configuration
// parameters. They shall be offered to the operator to enable him for a selection
// and shall be transferred to the subsystem to achieve the intended reaction.
// The definition of names of operational modes is not within the scope of this
// standard.
// It is the CMS's responsibility to initiate the determination of initial state by
// making a request for information to the subsystem.
// In the case where the CMS does not have mastership of the subsystem, a change of
// the operational mode shall be indicated by informing the CMS about the new
// operational mode (see service "Provide health state").
// Configuration data like the set of available operational modes may be received at
// runtime but may also be inserted by means of an automatic or manual setup
// process. Although automatic runtime transfer of such information may be achieved
// through ‘Manage Subsystem Parameters’ it is not a mandatory requirement of this
// standard for that mechanism to be used.
// One of the functions of a subsystem
struct function_type
{
// The functions unique idenitifier
#ifdef DDS_XTYPES
@key function_id_type function_id;
#else
function_id_type function_id;
#endif
// The name of function as understood by an operator
function_function_name_type function_name;
// The operational modes in which the function is available
function_applicable_mode_id_type applicable_mode_id;
// Indicates which subsystem published the data or is intended to read it as a
// subscriber
#ifdef DDS_XTYPES
@key org::omg::c4i::Domain_Model::Common_Types::subsystem_id_type subsystem_id;
#else
org::omg::c4i::Domain_Model::Common_Types::subsystem_id_type subsystem_id;
#endif
};
#ifndef DDS_XTYPES
#pragma keylist function_type function_id subsystem_id
#endif
// A sequence type, to represent multiple values.
typedef sequence parameter_name_sequence_element_type;
// Combination of name of parameter (for which a request could not be processed) and
// an indication of the error.
struct name_error_pair_type
{
// parameter_name values are unique within the scope of a subsystem.
name_error_pair_parameter_name_type parameter_name;
// A description of or reference for the error condition.
name_error_pair_error_indication_type error_indication;
};
// A list of service indications as used by Provide_Subsystem_Services.
struct service_indication_list_type
{
service_indication_list_service_indication_type service_indication;
};
// Report a fault to CMS
// The service allows the CMS to monitor and evaluate the health state of the
// subsystem. The health state information describes functional availability of the
// subsystem and the services it provides.
// The service may be triggered by several possible situations:
//
// - Periodic event, for example by internal clock,
// - Actor (CMS) request,
// - Health state change,
// - Initialization (start-up),
// - Recovery of the subsystem after a failure.
//
// In addition to the health state being provided, additional information may be
// provided to the CMS. In case of a service, the information may include a list of
// detected faults. In case of a subsystem, the information may include the list of
// services together with their health state, and for every service which has health
// state other than AVAILABLE, a list of detected faults. This two dimensional
// structure is called the service availability matrix.
// The state NOT AVAILABLE may also describe the situation in which the service is
// not implemented. In this case the list of faults shall be empty. In the state
// UNKNOWN, the subsystem may provide the reason for not being able to evaluate
// health state (e.g. BIT process not running).
// The service ends with success when the health state (possibly accompanied by
// additional information) is provided to the actor.
// Relationship to technical state.
// The reported health state of the services is dependent on the technical state.
// In the technical state ONLINE, the health state of the services is determined
// based on the detected faults (if any).
// In all technical states other than ONLINE (except OFFLINE), the health state of
// all services, except the service Subsystem_Control, is NOT AVAILABLE.
// The health state of the service Subsystem_Control shall then be DEGRADED, since
// some functions (e.g. Control Battle Override) are not available in those
// technical states, and some functions are (e.g. Manage Technical State).
// In the technical state OFFLINE no communication at all is possible with the CMS
// so the health state is not reported.
// Relationship to battle override.
// When Battle Override is set (see service Control Battle Override), certain faults
// are not taken into account when determining the health state. These overridable
// faults generally refer to circumstances that may cause damage to own equipments,
// but do not prohibit executing the requested task.
// Relationship to simulation mode.
// If the subsystem is in Simulation mode (technical state is ONLINE), only the
// faults for parts needed for the simulated execution of the service are taken into
// account when determining the health state of a service.
// For instance, if the transmitter is defective, the service Track_Reporting is
// reported AVAILABLE when in Simulation mode, but is reported NOT AVAILABLE when
// not in Simulation mode.
// Faults may also be simulated for training purposes (see service Define Fault
// Script). Therefore, irrespective of the Simulation mode, all faults (real and
// simulated) are included in the reported list of detected faults, each with an
// indication whether the fault is real or simulated.
// If a real system part is simulated, faults of the simulated part should have a
// different identification.
// For instance (see previous example) in Simulation mode, a simulated transmitter
// could be used, for which the trainer has inserted a simulated fault.
// Any faults in the real transmitter would be reported (real fault) as well as the
// injected fault in the simulated transmitter (simulated fault). However, the
// health state of the service Track_Reporting would be based only on the status of
// the simulated transmitter.
// Reason for health state
// Each reported health state other than AVAILABLE is accompanied by the reason(s)
// for that health. In this way the CMS may for instance derive that although the
// technical state of the subsystem is STANDBY (and NOT AVAILABLE for that reason),
// there are also faults that would prevent the service to become AVAILABLE when the
// technical state would be switched to ONLINE.
// Class to represent a subsystem fault
struct fault_type
{
// The name of the fault. Distinct instances of the same fault condition have the
// same name.
fault_fault_name_type fault_name;
// The categorization of the fault as an event; whether it is an occurrence or the
// disappearance of some phenomenon
event_type event;
// Indicates whether this fault is real or simulated/inserted.
boolean simulated;
// Indicates whether this fault is overridden by Battle Override when determining
// the health state.
boolean overridden;
// For instance cabinet id and rack id.
fault_fault_isolation_data_type fault_isolation_data;
// Indicates which subsystem published the data or is intended to read it as a
// subscriber
#ifdef DDS_XTYPES
@key org::omg::c4i::Domain_Model::Common_Types::subsystem_id_type subsystem_id;
#else
org::omg::c4i::Domain_Model::Common_Types::subsystem_id_type subsystem_id;
#endif
};
#ifndef DDS_XTYPES
#pragma keylist fault_type subsystem_id
#endif
// A generic struct for (name, value) pairs. Used in multiple situations.
struct name_value_pair_type
{
// parameter_name values are unique within the scope of a subsystem.
name_value_pair_parameter_name_type parameter_name;
// The value of the parameter
name_value_pair_value_type value;
};
// A sequence of strings (names). Used in request for parameters and parameter
// descriptors. If the sequence is empty, the request is for all parameters.
struct parameter_name_sequence_type
{
parameter_name_sequence_element_type element;
};
// Identification data of the equipment.
struct device_identification_type
{
// Name of the product. Example TRS3D
device_name_type product;
// Serial number identifying the individual device.
device_identification_serial_number_type serial_number;
// This describes the general type of the equipment. Example: Air Surveillance Radar
device_name_type equipment_type;
// Version of the device.
version_type version;
// Categorization of the product implementing the interface. This is the unique
// identification of the product given a particular external schema.
product_category_type product_category;
// Categorization of the kind of equipment implementing the interface. This is the
// specific identification of the product's equipment category given a particular
// external schema.
equipment_category_type equipment_category;
// The name of the platform hosting the interface participant.
device_name_type platform_name;
// Categorization of platform hosting the product implementing the interface. This
// is the unique identification of the platform given a particular external schema.
platform_category_type platform_category;
};
// A sequence type, to represent multiple values.
typedef sequence name_error_sequence_element_type;
// Encapsulation of interest in service
struct interest_type
{
// Whether adding or removing interest in an information service.
registration_type registration;
// The quality of service being requested of the information service.
interest_quality_of_service_type quality_of_service;
// Identification of the recipient of the information service.
interest_recipient_type recipient;
};
// A sequence type, to represent multiple values.
typedef sequence fault_list_element_type;
// A sequence type, to represent multiple values.
typedef sequence name_value_sequence_element_type;
// A list of faults
struct fault_list_type
{
fault_list_element_type element;
};
// sequence of error reports identifying the parameter names for which the request
// could not be processed, including an indication of the error (e.g. unknown
// parameter, illegal value).
struct name_error_sequence_type
{
name_error_sequence_element_type element;
};
// Sequence of (name, value) pairs used in retrieving and modifying parameters.
struct name_value_sequence_type
{
name_value_sequence_element_type element;
};
// A sequence type, to represent multiple values.
typedef sequence interest_list_element_type;
// Report health of subsystem (on subsystem initiative)
// The service allows the CMS to monitor and evaluate the health state of the
// subsystem. The health state information describes functional availability of the
// subsystem and the services it provides.
// The service may be triggered by several possible situations:
//
// - Periodic event, for example by internal clock,
// - Actor (CMS) request,
// - Health state change,
// - Initialization (start-up),
// - Recovery of the subsystem after a failure.
//
// In addition to the health state being provided, additional information may be
// provided to the CMS. In case of a service, the information may include a list of
// detected faults. In case of a subsystem, the information may include the list of
// services together with their health state, and for every service which has health
// state other than AVAILABLE, a list of detected faults. This two dimensional
// structure is called the service availability matrix.
// The state NOT AVAILABLE may also describe the situation in which the service is
// not implemented. In this case the list of faults shall be empty. In the state
// UNKNOWN, the subsystem may provide the reason for not being able to evaluate
// health state (e.g. BIT process not running).
// The service ends with success when the health state (possibly accompanied by
// additional information) is provided to the actor.
// Relationship to technical state.
// The reported health state of the services is dependent on the technical state.
// In the technical state ONLINE, the health state of the services is determined
// based on the detected faults (if any).
// In all technical states other than ONLINE (except OFFLINE), the health state of
// all services, except the service Subsystem_Control, is NOT AVAILABLE.
// The health state of the service Subsystem_Control shall then be DEGRADED, since
// some functions (e.g. Control Battle Override) are not available in those
// technical states, and some functions are (e.g. Manage Technical State).
// In the technical state OFFLINE no communication at all is possible with the CMS
// so the health state is not reported.
// Relationship to battle override.
// When Battle Override is set (see service Control Battle Override), certain faults
// are not taken into account when determining the health state. These overridable
// faults generally refer to circumstances that may cause damage to own equipments,
// but do not prohibit executing the requested task.
// Relationship to simulation mode.
// If the subsystem is in Simulation mode (technical state is ONLINE), only the
// faults for parts needed for the simulated execution of the service are taken into
// account when determining the health state of a service.
// For instance, if the transmitter is defective, the service Track_Reporting is
// reported AVAILABLE when in Simulation mode, but is reported NOT AVAILABLE when
// not in Simulation mode.
// Faults may also be simulated for training purposes (see service Define Fault
// Script). Therefore, irrespective of the Simulation mode, all faults (real and
// simulated) are included in the reported list of detected faults, each with an
// indication whether the fault is real or simulated.
// If a real system part is simulated, faults of the simulated part should have a
// different identification.
// For instance (see previous example) in Simulation mode, a simulated transmitter
// could be used, for which the trainer has inserted a simulated fault.
// Any faults in the real transmitter would be reported (real fault) as well as the
// injected fault in the simulated transmitter (simulated fault). However, the
// health state of the service Track_Reporting would be based only on the status of
// the simulated transmitter.
// Reason for health state
// Each reported health state other than AVAILABLE is accompanied by the reason(s)
// for that health. In this way the CMS may for instance derive that although the
// technical state of the subsystem is STANDBY (and NOT AVAILABLE for that reason),
// there are also faults that would prevent the service to become AVAILABLE when the
// technical state would be switched to ONLINE.
// Type describing the health state of a subsystem
struct subsystem_health_type
{
// Current health state
health_state_type health_state;
// Reason for last change of health state
health_state_reason_type health_state_reason;
// The subsystem being reported upon
device_identification_type subsystem_identification;
// The absolute time at which the information provided in the report was known to be
// valid
org::omg::c4i::Domain_Model::Common_Types::time_type time_of_information;
// Indicates which subsystem published the data or is intended to read it as a
// subscriber
#ifdef DDS_XTYPES
@key org::omg::c4i::Domain_Model::Common_Types::subsystem_id_type subsystem_id;
#else
org::omg::c4i::Domain_Model::Common_Types::subsystem_id_type subsystem_id;
#endif
};
#ifndef DDS_XTYPES
#pragma keylist subsystem_health_type subsystem_id
#endif
// A list of interest
struct interest_list_type
{
interest_list_element_type element;
};
// Type for parameter descriptors.
struct descriptor_type
{
// parameter_name values are unique within the scope of a subsystem.
descriptor_parameter_name_type parameter_name;
// The type of the information parameter
descriptor_parameter_type_type parameter_type;
// The units in which the value of the parameter is expressed.
descriptor_parameter_unit_type parameter_unit;
// A typical value of the information parameter so as to assist in providing a
// suitable value.
descriptor_typical_value_type typical_value;
// The valid range of the information parameter.
descriptor_parameter_range_type parameter_range;
// Technical state(s) in which this parameter may be modified.
descriptor_technical_state_type technical_state;
// Operational modes to which the information value applies.
descriptor_applicable_operational_mode_type applicable_operational_mode;
// Refers (by index) into the descriptor_sequence instance of which this instance of
// the descriptor class is a part.
descriptor_related_parameter_id_type related_parameter_id;
};
// A sequence type, to represent multiple values.
typedef sequence descriptor_sequence_element_type;
// Sequence of parameter descriptors, used in retrieving parameter descriptors.
struct descriptor_sequence_type
{
descriptor_sequence_element_type element;
};
};
};
};
};
};
};
#endif