/
IAP/MQ Data Schema
IAP/MQ Data Schema
- Nina Cardillo
Owned by Nina Cardillo
This page shows the IAP/MQ Data Schema. You can download the schema file by clicking this link: iap-data-schema.js.
/*
* A schema for IAP Data Types.
* (http://json-schema.org)
*
* This file implements the IAP Data Type schema in Javascript for direct
* consumption by JavaScript or Node.JS tools and JSON schema validators.
*
* The schemata defined herein govern meta data for datapoint or property
* types and profiles. Schemata which govern the value for datapoints or
* properties are not defined here but may be derived from meta data that
* implements the schemata defined in this module.
*
* Copyright (c) Echelon Corporation 2018
*/
"use strict";
/*
* Note (A):
*
* Many definitions share the same set of properties, such as a required name
* or optional comment or unit strings for base types. These common properties
* are not declared as inherited properties, because JSON schema cannot inherit
* the "required" designation.
*/
/*
* Note (B):
*
* Comments in the following definitions refer to the presentation and the
* implementation of data. The presentation describes how data is presented
* to a tool or a human, the implementation describes how the same data is
* encoded for communication within the edge protocol. Data implementation is
* sometimes also called "raw data" and data presentation is sometimes known
* as "scaled" or "formatted data."
*/
/*
* Note (C):
*
* Note JSON schema allows all additional properties (those which are not
* governed by the schema) unless explicitly forbidden. Many types described
* with the IAP Data Type language defined here will report additional
* properties not governed by this schema; this IAP Data Type schema defines
* the common denominator of all IAP Data Type languages.
*/
/*
* Note (D):
*
* Several definitions include "name", "id" and "comment" values. In some
* definitions, such as "profile", some keys also define names. These behave
* as follows:
*
* The member name as defined with a key, for example within a profile's
* datapoints and properties listing, is typically but not necessarily the
* same as the "id" value reported within the same member.
* The "id" field is the programmatic name; a C language "typedef struct"
* would include fields named after the "id". The member name can be longer,
* use more human- and documentation-friendly capitalization and spelling.
*
* The "name" key refers to a value which is often the same or similar to
* the member name or "id" value. The "name" value can be more human-friendly
* and documentation-friendly however, and it can be localized for different
* natural (human) languages. The "name" value is a name however, and does not
* include punctuation.
*
* The optional "comment" is a terse human-readable description of the purpose
* of the item to which the comment applies. The comment can be localized into
* different languages.
* The comment consists or one or more complete sentences including correct
* capitalization and punctuation.
*/
/*
* Base types are defined in this section. An application cannot directly
* implement a base type, but datapoint and property types implement a base
* type.
*/
const localizableString = {
/*
* Many definitions support localizable strings, often used to implement
* comments and descriptions, or human-friendly names.
*
* Such a string can be a constant string such as "this is a comment",
* or it an be a reference to a string resource using a string resource
* identifier. The string resource identifier can then be used to locate
* a translation, thus localizing the string.
*
* The localizableString schema describes such a string type.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/localizableString",
title: "localizableString",
description: "A constant string or reference to a localizable string",
oneOf: [{
"type": "string"
},
{
"type": "object",
properties: {
id: {
type: "string"
}
},
required: [
"id"
]
}
]
}; // localizableString
const baseScalar = {
/*
* A base type for integer items.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseScalar",
title: "baseScalar",
description: "An integer data type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "scalar"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* Scalar properties.
*/
min: {
/*
* The numerically smallest valid value for this type.
* This may be greater than the native minimum of the base
* type. The invalid value, if declared, may be numerically
* less than the minimum value.
* The minimum is expressed as implementation data.
*/
type: "number"
},
max: {
/*
* The numerically largest valid value for this type.
* This may be less than the native maximum of the base
* type. The invalid value, if declared, may be numerically
* greater than the maximum value.
* The maximum is expressed as implementation data.
*/
type: "number"
},
invalid: {
/*
* The optional invalid value can be within or outside the
* range defined by min, max so long as it can be stored
* in the base type.
* When an item's value matches the invalid value, the item
* indicates that it does not currently hold a valid value.
* The invalid value is expressed as implementation data.
*/
type: "number"
},
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
base: {
/*
* The base type indicates how the data is implemented in the
* edge protocol. Also see byte-order.
*/
enum: [
"uint8", "int8",
"uint16", "int16",
"uint32", "int32",
"uint64", "int64"
]
},
"byte-order": {
/*
* This describes the implementation byte order. The property
* is optional and defaults to a big endian network byte order.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
},
encoding: {
/*
* A presentation guide.
*/
enum: [
"binary", // present as number to base 2
"decimal", // display as number to base 10
"hex", // display as number to base 16
"base-36", // display as number to base 36 (0-9A-Z)
"base-62", // display as number to base 62 (0-9A-Za-z)
"ascii", // display as character, ASCII encoding
"utf-8", // display as UTF-8 character
"utf-16" // display as UTF-16 character
],
default: "decimal"
},
scaling: {
/*
* The scaling object guides the transformation between
* implementation and presentation.
*/
"$ref": "#/definitions/scaling"
},
values: {
/*
* When present, values enumerates a discrete list of acceptable
* values for this scalar. For example, one property type could
* implement a scalar to represent the number of stop bits in an
* asynchronous serial communications port. This could be described
* as a scalar based on uint8 with scaling factors a, b, c of
* +1, -1, 0 and a discrete value list of [ 1, 1.5, 2 ]
*/
type: "array",
items: {
type: "number"
},
uniqueItems: true
}
}, // properties
required: [
"type", "base"
],
definitions: {
scaling: {
/*
* The scaling object guides the transformation between integer data
* implementation value ("raw value") I and presentation value P using
* scaling factors A, B and C. This is used to implement fixed-point
* arithmetic for precise arithmetic with finite resolution.
*
* P := A * 10^B * (C + I)
* I := P / (A * 10^B) - C
*
* The resolution value s (for "step") equals P(A, B, C, I) for I = 1.
*
* For example, scaling factors A, B, C of +1, -1, 0 support a
* fixed-point presentation value with a resolution of 0.1.
*/
type: "object",
properties: {
a: {
type: "integer",
minimum: -32768,
maximum: 32767,
default: 1
},
b: {
type: "integer",
minimum: -32768,
maximum: 32767,
default: 0
},
c: {
type: "integer",
minimum: -32768,
maximum: 32767,
default: 0
},
s: {
type: "number"
}
}, // scaling properties
required: [
"a", "b", "c"
]
} // scaling
} // definitions
}; // scalar
const baseFloat = {
/*
* A base type for floating point items.
*
* Float types do not support an explicit "invalid value" due to the
* intrinsic difficulty of comparing two floating point values for
* equality. Use NaN (not a number) instead.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseFloat",
title: "baseFloat",
description: "A floating point data type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "float"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* Float properties.
*/
min: {
/*
* The numerically smallest valid value for this type.
* This may be greater than the native minimum of the base
* type.
*/
type: "number"
},
max: {
/*
* The numerically largest valid value for this type.
* This may be less than the native maximum of the base
* type.
*/
type: "number"
},
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
base: {
/*
* The base type indicates how the data is implemented in the
* edge protocol. Also see byte-order.
*/
enum: [
"half", // IEEE 754 half precision
"float", // IEEE 754 single precision
"double", // IEEE 754 double precision
"double double" // IEEE 754 quadruple precision
],
default: "float"
},
"byte-order": {
/*
* This describes the implementation byte order. The property
* is optional and defaults to a big endian network byte order.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
}
}, // properties
required: [
"type", "base"
]
}; // float
const baseEnum = {
/*
* A base type for enumerations. An enumeration is understood as a
* set of literals, each mapping to a numerical value. All enumerations
* map to signed integers.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseEnum",
title: "baseEnum",
description: "An enumeration data type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "enum"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* Enum properties.
*/
min: {
/*
* The numerically smallest valid value for this type.
* This may be greater than the native minimum of the base
* type.
*/
type: "number"
},
max: {
/*
* The numerically largest valid value for this type.
* This may be less than the native maximum of the base
* type.
*/
type: "number"
},
invalid: {
/*
* The optional invalid value can be within or outside the
* range defined by min, max so long as it can be stored
* in the base type.
* When an item's value matches the invalid value, the item
* indicates that it does not currently hold a valid value.
* The invalid value is expressed as implementation data.
*/
type: "number"
},
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
base: {
/*
* The base type indicates how the data is implemented in the
* edge protocol. Also see byte-order.
*/
enum: [
"int8",
"int16",
"int32",
"int64"
],
default: "int8"
},
enum: {
/*
* A type reference to enumeration type.
*/
type: "string",
minLength: 1
},
"byte-order": {
/*
* This describes the implementation byte order. The property
* is optional and defaults to a big endian network byte order.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
}
}, // properties
required: [
"type", "enum"
]
}; // enum
const baseReference = {
/*
* A base type for type references, how one type can be defined to derive from
* another. Such a type can impose further restrictions, for example by
* specifying a minimum value larger than that of the referenced type.
* A referring type should not allow data in violation of the referred type.
*
* A reference may refer to any applicable datapoint type.
*
* Applicable are all datapoint types which are available from the profile's
* definition standpoint of view, subject to protocol-specific visibility rules.
* Data types derived from LonMark Resource Files, for example, define their
* visibility rules through program Id mask and scope selector values.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseReference",
title: "baseReference",
description: "A data type reference",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "reference"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* Reference properties:
*
* min, max and invalid are allowed but have no restrictions
* or data type, because the referenced data type could implement
* a numerical or a non-numerical minimum value, for example.
*/
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
reference: {
/*
* A type reference to the referenced type.
*/
type: "string",
minLength: 1
}
}, // properties
required: [
"type", "reference"
]
}; // reference
const baseBitfield = {
/*
* A base type for bitfields similar to C bitfields.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseBitfield",
title: "baseBitfield",
description: "A bitfield type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "bitfield"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* Bitfield properties:
*/
size: {
/*
* The size of this bit field in bits. A bitfield size of zero
* skips to the next container.
*/
type: "integer",
minimum: 0,
maximum: 64,
default: 1
},
signed: {
/*
* Whether the field implements a signed value.
*/
type: "boolean",
default: false
},
min: {
/*
* Numerically smallest valid value, expressed in implementation
* data.
*/
type: "number"
},
max: {
/*
* Numerically largest valid value, expressed in implementation
* data.
*/
type: "number"
},
invalid: {
/*
* A designated "invalid" value, expressed in implementation data.
* May be outside the min, max range but is subject to size and signed
* constraints.
*/
type: "number"
},
base: {
/*
* The container within which the bitfield is implemented.
*/
enum: [
"uint8",
"uint16",
"uint32",
"uint64"
],
default: "uint8"
},
offset: {
/*
* The bitfield position within the container. Offset 0
* aligns the most significant bitfield bit with the most
* significant container bit for big-endian byte orientation.
* For little-endian orientation, offset 0 aligns the least
* significant bitfield bit with the least significant
* containiner bit.
*/
type: "integer",
minimum: 0,
maximum: 63
},
"byte-order": {
/*
* This describes the implementation byte order. The property
* is optional and defaults to a big endian network byte order.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
},
scaling: {
/*
* The scaling object guides the transformation between
* implementation and presentation.
*/
"$ref": "#/definitions/scaling"
}
}, // properties
required: [
"type", "offset"
],
definitions: {
scaling: {
/*
* The scaling object guides the transformation between integer data
* implementation value I and presentation value P using scaling
* factors A, B and C:
*
* P := A * 10^B + (C + I)
*
* The resolution value s (for "step") equals P(A, B, C, I) for I == 1.
*/
type: "object",
properties: {
a: {
type: "integer",
minimum: -32768,
maximum: 32767,
default: 0
},
b: {
type: "integer",
minimum: -32768,
maximum: 32767,
default: 0
},
c: {
type: "integer",
minimum: -32768,
maximum: 32767,
default: 0
},
s: {
type: "number"
}
}, // scaling properties
required: [
"a", "b", "c"
]
} // scaling
} // definitions
}; // bitfield
const baseBoolean = {
/*
* A base type for simple booleans.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseBoolean",
title: "baseBoolean",
description: "A Boolean type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "boolean"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* Boolean properties:
*/
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
base: {
/*
* The container within which the Boolean is implemented.
*/
enum: [
"int8",
"int16",
"int32",
"int64"
],
default: "int8"
},
"byte-order": {
/*
* This describes the implementation byte order. The property
* is optional and defaults to a big endian network byte order.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
}
}, // properties
required: [
"type"
]
}; // boolean
const baseBCD = {
/*
* A base type for binary encoded decimal numbers (BCD).
* Negative numbers are not supported.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseBCD",
title: "baseBCD",
description: "A BCD type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "bcd"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* BCD properties:
*/
min: {
type: "integer",
default: 0
},
max: {
type: "integer"
},
invalid: {
type: "integer"
},
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
base: {
/*
* The container within which the data is implemented.
*/
enum: [
"uint8",
"uint16",
"uint32",
"uint64"
],
default: "uint16"
},
"byte-order": {
/*
* This describes the implementation byte order. The property
* is optional and defaults to a big endian network byte order.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
},
"nibble-order": {
/*
* In big endian nibble order the most significant BCD digit
* aligns with the most significant nibble in a byte.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
},
packed: {
/*
* Packed BCD uses one nibble per digit, unpacked BCD uses
* a byte per digit.
*/
type: "boolean",
default: true
}
}, // properties
required: [
"type"
]
}; // bcd
const baseString = {
/*
* A base type for strings.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseString",
title: "baseString",
description: "A string type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "string"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* String properties:
*/
min: {
/*
* The minimum string length in characters.
*/
type: "integer",
default: 0
},
max: {
/*
* The maximum string length in characters.
*/
type: "integer"
},
invalid: {
type: "null"
},
regex: {
/*
* A regular expression. The string value must match
* this regular expression.
* The regular expression must conform to the Perl
* programming language, release 5.8.8.
*/
type: "string"
},
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
encoding: {
enum: [
"ascii",
"utf-8",
"utf-16"
],
default: "utf-8"
},
"runtime-encoding": {
/*
* "runtime-encoding" is true if the string encoding may change from
* the default at runtime. The "encoding" property provides the default
* encoding.
* Strings which support different encoding types at runtime require
* comprehension in context with another data field, typically an
* enumeration, which reports the current encoding.
*/
type: "boolean",
default: false
},
termination: {
enum: [
"padded", // string is right-filled with 0x00 to max length
"truncated" // variable length string terminated with 0x00
],
default: "padded"
}
}, // properties
required: [
"type"
]
}; // string
const baseAggregate = {
/*
* A base type for structures and unions.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseAggregate",
title: "baseAggregate",
description: "A structure or union data type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "aggregate"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
/*
* Aggregate properties:
*/
cat: {
enum: [
"oneOf",
"allOf"
]
},
"array-size": {
type: "integer",
minimum: 0, // 0, 1: not an array, 2...max: array
default: 0
},
members: {
type: "array",
items: {
anyOf: [{
"$ref": "http://glp-data-types.echelon.com/schema/baseScalar"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseFloat"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseEnum"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseReference"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBitfield"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBoolean"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBCD"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseString"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseAggregate"
}
]
}
},
packing: {
/*
* Packing controls whether a gap must be inserted between one member A and the
* next member B. The packing value indicates by which value the offset
* address of member B must be divisible without remainder:
*
* Packing of one indicates byte frames, allowing B to appear at any offset.
* Packing of two indicates a 16 bit frame, allowing B only to appear at even
* addresses. A filler of 0x00 bytes may be inserted between A and B.
* Packing of 3 or 4 indicates 32 or 64 byte frames, requiring that B must be
* at an offset address divisible by 4 or 8 without remainder, respectively.
*/
enum: [
1,
2,
4,
8
],
default: 1
},
padding: {
/*
* Padding controls how two adjacent structures A and B within an array are addressed.
* Padding of one indicates byte frames, allowing B to start at any offset address.
* A padding of two indicates a 16-bit word frame, requiring B to start at an offset
* address divisible by 2, and so on.
*/
enum: [
1,
2,
4,
8
],
default: 1
},
alignment : {
/*
* This describes the implementation alignment. The property
* is optional and defaults to a big endian network byte order.
*/
enum: [
"big-endian", "little-endian"
],
default: "big-endian"
},
}, // properties
required: [
"type", "cat", "members"
]
}; // aggregate
const baseInheriting = {
/*
* An inheriting base type for use with property types.
*
* A property defined with an inheriting type has no data type on its
* onw but inherits the data type from the datapoint the property
* applies to. This is useful to define generic semantics such as
* properties for value overrides once for all datapoint types the
* property may apply to.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/baseInheriting",
title: "baseInheriting",
description: "An inheriting property type",
type: "object",
properties: {
/*
* Common properties
*/
type: {
const: "inheriting"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* An optional programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
}
}, // properties
required: [
"type"
]
}; // inheriting
/*
* Enumerations are maps between literals and their numerical value.
* Profiles cannot implement enumerations directly but may implement
* datapoint and property types which in turn may reference or include
* an enumeration.
*/
const enumeration = {
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/enumeration",
title: "enumeration",
description: "An enumeration type",
type: "object",
properties: {
"class": {
const: "enumeration"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
id: {
/*
* A programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
members: {
type: "array",
items: {
"$ref": "#/definitions/member"
}
}
}, // properties
required: [
"id", "members"
],
definitions: {
member: {
type: "object",
properties: {
id: {
type: "string"
},
value: {
type: "integer"
},
comment: {
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
name: {
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
}
}, // properties
required: [
"id", "value"
]
} // member
} // definitions
}; // enumeration
/*
* Datapoint and property types are defined in this section.
*
* Applications implement datapoints and properties through the
* implementation of a profile. Datapoint and property types provide
* semantics and additional detail to the base type they implement,
* profiles group datapoint and properties into units of functionality.
*/
const datapoint = {
/*
* A datapoint type. Datapoints can generally be read and written.
* Because datapoint values can change as an application output or
* due to peer-to-peer datapoint connections, they can be monitored
* for change. Datapoints are typically volatile and do not preserve
* their most recent value over a reset or power cycle.
*
* Datapoint values and fields within datapoints which implement
* an aggregate type can be assigned and may report a value that
* meets the type described with the schema indicated by the "type"
* property.
* Implementations also support the assignment of the keyword "invalid"
* and might present the value with the keyword "invalid" to indicate
* that the item has no valid value. Edge processors translate the
* "invalid" keyword to the designated numeric value where available.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/datapoint",
title: "datapoint",
description: "A datapoint type",
type: "object",
properties: {
/*
* Common properties
*/
"class": {
const: "datapoint"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* A programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
key: {
/*
* A numeric identifier for this type, unique within its type class,
* program ID and scope. For example, a set of type definitions grouped
* under program ID and scope 8001020304050607-4 has a set of datapoint,
* property and profile types. Each datapoint, property and profile
* has a unique key within its class.
* The "key" acts as a key and its numeric value has no other significance.
*
* Some applications require a type key, primarily those which support
* interface changes at runtime (dynamic interfaces or changeable-type
* interfaces) and those which support development of applications or
* related artifacts based on IAP/MQ data types. Those applications
* may be prevented from using a data type unless a "key" is provided.
*/
type: "integer",
minimum: 0
},
type: {
anyOf: [
{
"$ref": "http://glp-data-types.echelon.com/schema/baseScalar"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseFloat"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseEnum"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseReference"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBitfield"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBoolean"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBCD"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseString"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseAggregate"
}
]
},
default: {
/*
* An optional default value, must match type.
* A default value define here overrides a default defined
* with the base type, but must still meet the base type's
* requirements.
*/
},
alarms: {
"$ref": "http://glp-data-types.echelon.com/schema/applicationAlarms"
}
}, // properties
required: [
"class", "id", "type"
]
}; // datapoint
const property = {
/*
* A property is an expansion on a datapoint through the addition of
* semantics. For example, a datapoint might decribe a temperature value.
* A property might implement the same temperature value, typically using
* a reference to the datapoint type, but define the property as the lower
* temperature threshold for a cooler device. Another property might have
* a similar definition, controlling the higher setpoint of a cooler device.
*
* Most properties do not support unsolicited value changes as typically
* is the case for datapoints, but some applications may update certain
* properties.
* Property values are typically changing very infrequently and are preserved
* over a reset or power cycle.
*
* Property values and fields within properties which implement
* an aggregate type can be assigned and may report a value that
* meets the type described with the schema indicated by the "type"
* property.
* Implementations also support the assignment of the keyword "invalid"
* and might present the value with the keyword "invalid" to indicate
* that the item has no valid value. Edge processors translate the
* "invalid" keyword to the designated numeric value where available.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/property",
title: "property",
description: "A property type",
type: "object",
properties: {
/*
* Common properties
*/
"class": {
const: "property"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
unit: {
/*
* An optional unit of measurement.
* Where applicable, the unit should be a non-localizable unit of
* measurement expressed in a SI or derived SI unit such as kg, s
* or m for kilogram, seconds and meters. Non-SI units such as F
* (Fahrenheit) or mph (miles per hour) are acceptable where
* appropriate.
*/
type: "string"
},
id: {
/*
* A programmatic name, a type name for use with software
* code or machine readers. This may differ from the type name, for
* example by using underscore characters where the type name may
* include a space.
*/
type: "string"
},
key: {
/*
* A numeric identifier for this type, unique within its type class,
* program ID and scope. For example, a set of type definitions grouped
* under program ID and scope 8001020304050607-4 has a set of datapoint,
* property and profile types. Each datapoint, property and profile
* has a unique key within its class.
* The "key" acts as a key and its numeric value has no other significance.
*
* Some applications require a type key, primarily those which support
* interface changes at runtime (dynamic interfaces or changeable-type
* interfaces) and those which support development of applications or
* related artifacts based on IAP/MQ data types. Those applications
* may be prevented from using a data type unless a "key" is provided.
*/
type: "integer",
minimum: 0
},
type: {
anyOf: [
// {
// "$ref": "http://glp-data-types.echelon.com/schema/baseFloat"
// },
{
"$ref": "http://glp-data-types.echelon.com/schema/baseScalar"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseFloat"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseEnum"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseReference"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBitfield"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBoolean"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseBCD"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseString"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseAggregate"
},
{
"$ref": "http://glp-data-types.echelon.com/schema/baseInheriting"
}
]
},
default: {
/*
* An optional default value, must match type.
* A default value define here overrides a default defined
* with the base type, but must still meet the base type's
* requirements.
*/
},
min: {
/*
* An optional minimum value override.
* A minimum value overrides the minimum value defined with the
* base type, but must meet the base type's requirements.
* The minimum value override can further restrict but must not
* expand the base type's range.
*/
},
max: {
/*
* An optional maximum value override.
* A maximum value overrides the maximum value defined with the
* base type, but must meet the base type's requirements.
* The maximum value override can further restrict but must not
* expand the base type's range.
*/
},
invalid: {
/*
* An optional invalid value override.
* An invalid value override overrides the invalid value defined
* with the base type, but must meet the base type's requirements.
*/
}
}, // properties
required: [
"class", "id", "type"
]
}; // property
const applicationAlarms = {
/*
* The alarms property lists properties within the object
* described by this schema which indicate simple application-
* specific alarm conditions. Examples include a "day burner"
* alarm from an outdoor lighting device, or a "door
* open" alarm from a cabinet in an application's status object,
* or an alarm condition flag in an output datapoint.
* Tools consider the alarm to be active when the
* property value evaluates to a logical True, and the alarm
* to be inactive when the the property value evaluates to
* a logical False. Simple application-specific alarm
* conditions are generally implemented as Booleans, strings
* or numbers.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/applicationAlarms",
title: "ApplicationAlarms",
description: "Simple application-specific alarm conditions",
type: "array",
items: {
type: "string"
}
}; // applicationAlarms
/*
* Profiles refine datapoints and properties for a specific application as a
* profile datapoint type or profile property type and combine these into a
* profile with well-defined behavior and either a specific application such
* as a indoor electric water heater control unit, or into a generic application
* with well-defined behavior such as a general-purpose PID-T2 digital controller.
*
* Applications implement profiles as blocks. Each block is an implementation of
* a profile including all mandatory profile property and datapoint members and
* any of the optional profile property and datapoint members.
* Implementations of property datapoint and property members are governed by the
* rules defined with the profile.
*/
const memberDatapoint = {
/*
* A profile datapoint member may applicable datapoint types, or may implement
* a wildcard datapoint type.
*
* Applicable are all datapoint types which are available from the profile's
* definition standpoint of view, subject to protocol-specific visibility rules.
* Data types derived from LonMark Resource Files, for example, define their
* visibility rules through program Id mask and scope selector values.
*
* Wildcard types are known as "SNVT_xxx" in LonMark Resource Files. These
* are placeholders within a profile, to be replaced with an actual datapoint
* type when the profile is implemented as a block. Wildcards allow for generic
* profile definitions such as a generic PID controller whose setpoint, process
* value and control value datapoints could implement a temperature datapoint
* type in one block, and a velocity datapoint type in another.
*
* Profiles may declare more than one datapoint member to use the wildcard type,
* but implementations of the profile must use the same datapoint type to
* instantiate all wildcard types within the block.
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/memberDatapoint",
title: "MemberDatapoint",
description: "Profile member datapoint",
type: "object",
properties: {
/*
* Common properties
*/
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
id: {
/*
* A programmatic name, a member name for use with software
* code or machine readers. This may differ from the name, for
* example by using underscore characters where the name may
* include a space.
*/
type: "string"
},
type: {
/*
* The type for a member that is not a wildcard is a simple type reference,
* such as "SNVT_volt".
*
* Member types can also declare wildcard types. Any compatible type
* may be used to implement such a wildcard member.
* Wildcard members report their type with a Perl 5 regular expression,
* embedded within a pair of forward slash characters, such as
* "/SNVT.+/".
*
* The pair of forward slash characters is not part of the regular
* expression, but everything within that character pair is.
*
* The regular expression is case-sensitive. Any type matching the
* regular expression may be used to implement the wildcard
* member.
*/
type: "string",
format: "regex"
},
dir: {
/*
* direction is network-centric: an input datapoint is an input
* from the network into the profile or block, often corresponding
* to a physical output such as a lamp dimmer. An output datapoint
* is an output from the block, often corresponding to a computed
* value or one obtained from a physical input such as a temperature
* sensor.
* A bidirectional datapoint can act as both input and output.
*/
enum: [
"input",
"output",
"inout"
]
},
mandatory: {
/*
* A block implementing a profile must implement all mandatory profile
* members, and may implement any of the optional members. Optional
* members are those reported as not mandatory.
*/
type: "boolean"
},
min: {
/*
* An optional minimum value override.
* A minimum value overrides the minimum value defined with the
* base type, but must meet the base type's requirements.
* The minimum value override can further restrict but must not
* expand the base type's range.
*/
},
max: {
/*
* An optional maximum value override.
* A maximum value overrides the maximum value defined with the
* base type, but must meet the base type's requirements.
* The maximum value override can further restrict but must not
* expand the base type's range.
*/
},
invalid: {
/*
* An optional invalid value override.
* An invalid value override overrides the invalid value defined
* with the base type, but must meet the base type's requirements.
*/
},
descriptor :{
type: "string",
pattern: "^[#|][0-9]+$"
},
unit: {
type: "string"
}
}, // properties
required: [
"id", "type", "mandatory", "dir"
]
}; // memberDatapoint
const memberProperty = {
/*
* A profile property member may implement applicable property types.
* Because properties convey semantics, a wildcard property type cannot
* exist, but inheriting property types automatically derive their type from
* the datapoint they apply to.
*
* Applicable are property types which are available from the profile's
* definition standpoint of view, subject to protocol-specific visibility rules.
* Data types derived from LonMark Resource Files, for example, define their
* visibility rules through program Id mask and scope selector values.
*
*/
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/memberProperty",
title: "MemberProperty",
description: "Profile member property",
type: "object",
properties: {
/*
* Common properties
*/
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
id: {
/*
* A programmatic name, a member name for use with software
* code or machine readers. This may differ from the name, for
* example by using underscore characters where the name may
* include a space.
*/
type: "string"
},
type: {
/*
* The member type is defined as a Perl 5 regular expression, with an implied
* ^ at the start and $ at the end, matching the type for use with this member.
* For example, a value of "SCPTlocation" matches that type exactly.
* The standard resource set identifier is 0000000000000000-0, and is never
* included.
* However, some profile members may not be limited to a specific type.
* ".*" allows for any type to implement the member, but other expressions
* could restrict the choice to a well-defined set of allowed types, or to a
* range of types.
*/
type: "string",
format: "regex"
},
mandatory: {
/*
* A block implementing a profile must implement all mandatory profile
* members, and may implement any of the optional members. Optional
* members are those reported as not mandatory.
*/
type: "boolean"
},
min: {
/*
* An optional minimum value override.
* A minimum value overrides the minimum value defined with the
* base type, but must meet the base type's requirements.
* The minimum value override can further restrict but must not
* expand the base type's range.
*/
},
max: {
/*
* An optional maximum value override.
* A maximum value overrides the maximum value defined with the
* base type, but must meet the base type's requirements.
* The maximum value override can further restrict but must not
* expand the base type's range.
*/
},
invalid: {
/*
* An optional invalid value override.
* An invalid value override overrides the invalid value defined
* with the base type, but must meet the base type's requirements.
*/
},
default: {
/*
* An optional default value override.
* A default value overrides the default value defined with the
* base type, but must meet the base type's requirements.
* The default value override can further restrict but must not
* expand the base type's range.
*/
},
applies: {
/*
* A property applies to the block or to a specific datapoint member
* implemented in the same block. The item to which the property applies
* is also known as the property's application set. The application set
* is defined with this attribute, which lists the profile name
* for properties applying to the block, or the datapoint member name for
* those applying to a datapoint member.
*
* A given property implementation may apply to multiple blocks or to
* multiple datapoints, known as a shared property. Within a profile,
* the property is never explicitly shared but always applies to a single
* item. However, properties which explicitly apply to the block often
* implicitly govern one or more of its members as evident from the
* property's semantics.
*/
type: "string",
minLength: 1
},
array: {
/*
* Member properties are often singletons, but some profiles also
* allow or even require the implementation as a property array.
* Profiles can require a specific size for that array, or can
* define a minimum and maximum array size.
*
* When the array property is not present or null, the property
* may not be implemented as an array. Otherwise the array object
* details the array implementation requirements.
*/
"$ref": "#/definitions/array",
default: null
},
restrictions: {
/*
* Properties may carry flags which restrict their use.
* These are optional; properties not reporting restrictions
* or reporting these as null are unrestricted.
*/
"$ref": "#/definitions/restrictions",
default: null
},
presentation: {
/*
* Simple properties can be presented as plain block members. For
* example a digital output block may include an "invert" option,
* which it might present as a plain Boolean property of the block.
*
* More complex properties might include definitions of default values
* or override values and similar detail. These complex properties would
* be presented with a IAP Datapoint object.
*
* The 'presentation' attribute reports how the property is implemented,
* allowing the generic tool to recognize its implementation within the
* block.
*
* Because a "plain" property does not include a type declaration, tools
* must deduce the type of plain property from the profile.
*/
enum: [
"plain",
"datapoint"
],
default: "datapoint"
},
descriptor :{
type: "string",
pattern: "^[#|][0-9]+$"
},
unit: {
type: "string"
}
}, // properties
required: [
"id", "type", "mandatory"
],
definitions: {
array: {
/*
* The array object details a property member's implementation
* as an array.
*/
type: "object",
properties: {
is: {
enum: [
"prohibited",
"permitted",
"required"
],
default: "prohibited"
},
min: {
/*
* The minimum array size.
*/
type: "integer",
minimum: 2,
default: 2
},
max: {
/*
* The maximum array size. When equal to the minimum size,
* the array must be implemented with this exact number of
* elements. When greater than the minimum size, the array
* may be implemented with any number of elements from min
* to max, both inclusive.
* When a maximum is not defined, the maximum size is infinite.
*/
type: "integer",
minimum: 2
}
},
required: [
"is"
]
}, // array
restrictions: {
type: "object",
properties: {
"device-specific": {
/*
* The application on the device that implements a device-specific
* property may change this property value without notice, for
* example to report calibration data.
* A network tool must not rely upon cached values for this property.
*/
type: "boolean"
},
"manufacturing-only": {
/*
* A manufacturing only property may only be changed during manufacture.
* Network tools do not modify this property during normal operation.
*/
type: "boolean"
},
"reset-required": {
/*
* A property can request that the device or application that implements
* it is reset after a change to the property value and before the new
* value takes effect.
*/
type: "boolean"
},
"offline-required": {
/*
* A property can request that the device or application be put in offline
* mode while the property is modified.
*
* The new property value may not take effect until the device is in online
* mode again. Note that resetting the device also clears offline mode.
*/
type: "boolean"
},
"disable-required": {
/*
* A property can request that the device, application or block that implements
* the property be disabled before the property is changed, and be enabled
* again before the new property value takes effect.
*/
type: "boolean"
},
"const": {
/*
* A constant property cannot be changed and is used to report constant
* properties such as an application version number.
*/
type: "boolean"
}
} // properties
} // restrictions
} // definitions
}; // memberProperty
const profile = {
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/profile",
title: "profile",
description: "Profile",
type: "object",
properties: {
/*
* Common properties
*/
"class": {
const: "profile"
},
name: {
/*
* A type name fit for human consumption and display in a user interface.
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
comment: {
/*
* An optional comment
*/
"$ref": "http://glp-data-types.echelon.com/schema/localizableString"
},
id: {
/*
* A programmatic name, a member name for use with software
* code or machine readers. This may differ from the name, for
* example by using underscore characters where the name may
* include a space.
*/
type: "string"
},
key: {
/*
* A numeric identifier for this type, unique within its type class,
* program ID and scope. For example, a set of type definitions grouped
* under program ID and scope 8001020304050607-4 has a set of datapoint,
* property and profile types. Each datapoint, property and profile
* has a unique key within its class.
* The "key" acts as a key and its numeric value has no other significance.
*
* Some applications require a type key, primarily those which support
* interface changes at runtime (dynamic interfaces or changeable-type
* interfaces) and those which support development of applications or
* related artifacts based on IAP/MQ data types. Those applications
* may be prevented from using a data type unless a "key" is provided.
*/
type: "integer",
minimum: 0
},
inheriting: {
/*
* A profile may inherit from another applicable profile.
* Applicable are profiles which are available from this profile's
* definition standpoint of view, subject to protocol-specific
* visibility rules.
* Data types derived from LonMark Resource Files, for example,
* define their visibility rules through program Id mask and
* scope selector values.
*/
type: "string"
},
principal: {
/*
* A profile may nominate one of its member datapoints as the
* principal datapoint through the member id value.
*
* A principal datapoint nomination can guide generic user
* interfaces and defines the application set for some properties
* which are explicitly applied to the block but semantically
* apply to a datapoint, such as a default value or override
* control property.
*/
type: "string"
},
datapoints: {
type: "object",
additionalProperties: {
"$ref": "http://glp-data-types.echelon.com/schema/memberDatapoint"
}
},
properties: {
type: "object",
additionalProperties: {
"$ref": "http://glp-data-types.echelon.com/schema/memberProperty"
}
}
}, // properties
required: [
"class", "id"
]
}; // profile
/*
* The Application schema describes capabilities of the application, keyed by the
* device type. One application declaration may be shared among different versions
* of the same application, provided that none of the aspects reported for the
* application changes. To facilitate this, the type key is evaluated not as an
* exact match but as a match for the start of the key.
*
* Consider for example a device which reports its type within the feedback channel's
* status object as "type": "80000112345604". This device might be described with a
* type of "8000011234560", matching only the first 15 characters.
*
* Tools prefer a longer type match over a shorter match.
*/
const application = {
"$schema": "http://json-schema.org/draft-06/schema#",
"$id": "http://glp-data-types.echelon.com/schema/application",
title: "application",
description: "Application",
type: "object",
properties: {
"class": {
const: "application"
},
classification: {
/*
* Classification classifies the application as one of several groups.
* This information is optional.
*
* Tools with interfaces to human users might chose this information to
* guide selective display of items according to their classification.
*
*/
enum: [
"infrastructure", // For routers, network adapters, and so on.
"configuration", // For applications to help configure and manage services.
"diagnostics", // For tools for diagnostics and servicing.
"application" // For all other application types.
],
default: "application"
},
description: {
/*
* A short description
*/
type: "string"
},
documentation: {
/*
* A reference to comprehensive documentation in form of a website URL.
*/
type: "string",
format: "uri"
},
interface: {
/*
* An alphanumeric identifier of the application type aimed at a human
* user, often including the device's product name and manufacturer name.
*/
type: "string",
minLength: 1
},
manufacturer: {
type: "string",
minLength: 1
},
multiplicity: {
enum: [
"singleton",
"unlimited"
],
default: "unlimited"
},
product: {
type: "string",
minLength: 1
},
protocol: {
type: "string",
minLength: 1
},
status: {
/*
* The status property reports non-standard items
* which appear in the device's status object.
* Tools accept (and typically ignore) all non-standard
* properties not declared with this property.
*/
"$ref": "#/definitions/status"
},
actions: {
/*
* The actions property reports actions available
* with the "do" request channel endpoint for this
* device type.
* When no actions are defined here, the tools
* assume that the device supports all standard IAP
* actions.
* Actions listed here are in addition to standard
* actions. Standard actions may also be overridden
* by adding additional arguments, but removing or
* re-defining standard actions is not supported.
*/
"$ref": "#/definitions/actions"
}
}, // properties
required: [
"class", "interface", "manufacturer", "product"
],
definitions: {
status: {
type: "object",
properties: {
alarms: {
"$ref": "http://glp-data-types.echelon.com/schema/applicationAlarms"
},
}
}, // status
actions: {
/*
* actions is a list of action objects supported by this device.
* Devices which declare actions are expected only to support
* the actions declared here. Devices which do not declare actions
* are expected to support all standard IAP actions, however,
* devices may still fail an action with an error event if the
* action may not be performed for any reason.
*/
type: "array",
items: {
"$ref": "#/definitions/action"
}
}, // actions
action: {
/*
* Each action is defined with the action name and its arguments.
* Standard actions must support the arguments defined with the
* action in the IAP specification. Implementations of standard
* actions may not remove any of the standard arguments, but
* specific implementations may add additional arguments if
* declared here. When declared, all action arguments including
* the standard action arguments must be declared.
*/
type: "object",
properties: {
id: {
/*
* The action name such as "load", "test", "wink".
*/
type: "string"
},
description: {
/*
* A brief description for human consumption.
*/
type: "string"
},
args: {
/*
* A JSON schema for the action's arguments.
*/
type: "object"
}
}, // properties
required: [
"id"
]
} // action
} // definitions
}; // application
exports.base = {
aggregate: baseAggregate,
bcd: baseBCD,
bitfield: baseBitfield,
boolean: baseBoolean,
enumeration: baseEnum,
float: baseFloat,
reference: baseReference,
scalar: baseScalar,
string: baseString
};
exports.application = application;
exports.datapoint = datapoint;
exports.enum = enumeration;
exports.profile = profile;
exports.property = property;
exports.all = [
localizableString,
baseScalar,
baseFloat,
baseEnum,
baseReference,
baseBitfield,
baseBoolean,
baseBCD,
baseString,
baseAggregate,
baseInheriting,
applicationAlarms,
memberDatapoint,
memberProperty
];
, multiple selections available,
Related content
IAP/MQ API Index
IAP/MQ API Index
More like this
Datapoint Type
Datapoint Type
More like this
Managing Datapoint Types
Managing Datapoint Types
More like this
Implementation Detail Object
Implementation Detail Object
More like this
Type Translation
Type Translation
More like this