| namespace | http://opcfoundation.org/UA/ |
| nodeClass | VariableType |
| typedDefinition | DiscreteItemType i=2372 |
| dataType | Null |
| dataType Name | VariantOptions i=0 |
| isAbstract | true |
Optional$extensionThe AccessLevel Attribute is used to indicate how the Value of a Variable can be accessed (read/write) and if it contains current and/or historic data.
The AccessLevel does not take any user access rights into account, i.e. although the Variable is writable this may be restricted to a certain user / user group.
The {{link:AccessLevelType}}
This Attribute specifies the length of each dimension for an array value.
valueRank Attribute.valueRank <=0.example
For example, if a Variable is defined by the following javascript array with 346 Int32 elements:
const myArray = new Array(346).fill(0);
then:
DataType would point to an Int32valueRank has the value 1 and,arrayDimensions is an array with one entry having the value 346.{
dataType: "Int32",
valueRank: 1,
arrayDimensions: [346]
}
Note: the maximum length of an array transferred on the wire is 2147483647 (max Int32) and a multidimensional array is encoded as a one dimensional array.
ReadonlybrowseReadonlydataOptionaldefinitionThe historizing attribute indicates whether the server is actively collecting data for the
history of the variable.
This differs from the accessLevel Attribute which identifies if the variable has any historical data.
A value of true indicates that the server is actively collecting data.
A value of false indicates the server is not actively collecting data.
Default value is false.
The MinimumSamplingInterval Attribute indicates how 'current' the Value of the Variable will be kept.
It specifies (in milliseconds) how fast the Server can reasonably sample the value for changes (see Part 4 for a detailed description of sampling interval).
A MinimumSamplingInterval of 0 indicates that the Server is to monitor the item continuously.
A MinimumSamplingInterval of -1 means indeterminate.
ReadonlynodeReadonlynodeOptionalnodeNodeVersion (Optional) String The NodeVersion Property is used to indicate the version of a Node. The NodeVersion Property is updated each time a Reference is added or deleted to the Node the Property belongs to. Attribute value changes do not cause the NodeVersion to change. Clients may read the NodeVersion Property or subscribe to it to determine when the structure of a Node has changed.
OptionalonReadonlyparentOptionaluserThe UserAccessLevel Attribute is used to indicate how the Value of a Variable can be accessed (read/write) and if it contains current or historic data taking user access rights into account.
The AccessLevelType is defined in 8.57.
OptionalvalueThis Attribute indicates whether the Value Attribute of the Variable is an array and how many dimensions the array has. It may have the following values:
NOTE:
Optional[captureRest...args: AnyRestAlias for emitter.on(eventName, listener).
Rest...args: any[]OptionaloptionalExtensionObject: ExtensionObject | ExtensionObject[]Optionaloptions: BindExtensionObjectOptionsOptionaloptionalExtensionObjectArray: ExtensionObject[]Optionaloptions: BindExtensionObjectOptionsOptionaloptionalExtensionObject: ExtensionObjectOptionaloptions: BindExtensionObjectOptionsOptionaloptions: BindVariableOptionsOptionaloverwrite: booleanbrowse the node to extract information requested in browseDescription
Optionalsession: ISessionContextOptionalnewValue: VariantOptionsOptionaloptionalFilter: CloneFilterOptionalextraInfo: CloneExtraInfoSynchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments
to each.
Returns true if the event had listeners, false otherwise.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
Rest...args: AnyRestReturns an array listing the events for which the emitter has registered
listeners. The values in the array are strings or Symbols.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
find the the references that are strictly of type reference.
The isForward boolean flag specifies the direction of the references to be looked for.
Forward direction is implied if omitted.
OptionalisForward: booleanfind all the references that are strictly of type reference.
The isForward boolean flag specifies the direction of the references to be looked for.
Forward direction is implied if omitted.
OptionalisForward: booleanfind all the nodes that are referenced by references strictly of type reference.
The isForward boolean flag specifies the direction of the references to be looked for.
Forward direction is implied if omitted.
OptionalisForward: booleanfind all the references that are of type reference or a sub type of reference, in the
direction specified by browseDirection
OptionalbrowseDirection: BrowseDirectionfind all the nodes that are referenced by references of type reference or a sub type of reference, in the
direction specified by browseDirection
OptionalbrowseDirection: BrowseDirectionget effective accessRestrictions if (inherited is true) and node has no accessRestrictions, then default accessRestriction from namespace is returned if (inherited is false) and node has no accessRestrictions, then AccessRestrictionsFlag.None is returned
OptionalnamespaceIndex: numberOptionalnamespaceIndex: numberOptionalnamespaceIndex: numberEnumValues is an array of EnumValueType. Each entry of the array represents one enumeration value with its integer notation, a human-readable representation, and help information. This represents enumerations with integers that are not zero-based or have gaps (e.g. 1, 2, 4, 8, 16). See OPC 10000-3 for the definition of this type. MultiStateValueDiscrete Variables expose the current integer notation in their Value Attribute. Clients will often read the EnumValues Property in advance and cache it to lookup a name or help whenever they receive the numeric representation.
returns true if the accessLevel flag allows the variable to be readable in the specified context.
returns true if the userAccessLevel flag allows the variable to be readable in the specified context.
returns true if the userAccessLevel flag allows the variable to be writeable in the specified context.
returns true if the accessLevel flag allows the variable to be writeable in the specified context.
Returns the number of listeners listening for the event named eventName.
If listener is provided, it will return how many times the listener is found
in the list of the listeners of the event.
The name of the event being listened for
Optionallistener: FunctionThe event handler function
Returns a copy of the array of listeners for the event named eventName.
server.on('connection', (stream) => {
console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
Alias for emitter.removeListener().
Rest...args: any[]Adds the listener function to the end of the listeners array for the event
named eventName. No checks are made to see if the listener has already
been added. Multiple calls passing the same combination of eventName and
listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
The name of the event.
Adds the listener function to the end of the listeners array for the event
named eventName. No checks are made to see if the listener has already
been added. Multiple calls passing the same combination of eventName and
listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
Adds a one-time listener function for the event named eventName. The
next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
The name of the event.
Adds a one-time listener function for the event named eventName. The
next time eventName is triggered, this listener is removed and then invoked.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
Adds the listener function to the beginning of the listeners array for the
event named eventName. No checks are made to see if the listener has
already been added. Multiple calls passing the same combination of eventName
and listener will result in the listener being added, and called, multiple times.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
The callback function
Rest...args: any[]Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this
listener is removed, and then invoked.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
The name of the event.
The callback function
Rest...args: any[]Returns a copy of the array of listeners for the event named eventName,
including any wrappers (such as those created by .once()).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
OptionalindexRange: NumericRangeOptionaldataEncoding: null | QualifiedNameLikefrom OPC.UA.Spec 1.02 part 4 5.10.2.4 StatusCodes Table 51 defines values for the operation level statusCode contained in the DataValue structure of each values element. Common StatusCodes are defined in Table 166.
Read Operation Level Result Codes
| Symbolic Id | Description |
|---|---|
| BadNodeIdInvalid | The syntax of the node id is not valid. |
| BadNodeIdUnknown | The node id refers to a node that does not exist in the server address space. |
| BadAttributeIdInvalid | BadAttributeIdInvalid The attribute is not supported for the specified node. |
| BadIndexRangeInvalid | The syntax of the index range parameter is invalid. |
| BadIndexRangeNoData | No data exists within the range of indexes specified. |
| BadDataEncodingInvalid | The data encoding is invalid. This result is used if no dataEncoding can be applied because an Attribute other than Value was requested or the DataType of the Value Attribute is not a subtype of the Structure DataType. |
| BadDataEncodingUnsupported | The server does not support the requested data encoding for the node. This result is used if a dataEncoding can be applied but the passed data encoding is not known to the Server. |
| BadNotReadable | The access level does not allow reading or subscribing to the Node. |
| BadUserAccessDenied | User does not have permission to perform the requested operation. (table 165) |
| BadSecurityModeInsufficient | The operation is not permitted over the current secure channel. |
| BadInsufficientPrivileges | The user does not have enough privileges to perform the requested operation. |
Optionalcontext: null | ISessionContextOptionalindexRange: NumericRangeOptionaldataEncoding: null | QualifiedNameLikeRemoves all listeners, or those of the specified eventName.
It is bad practice to remove listeners added elsewhere in the code,
particularly when the EventEmitter instance was created by some other
component or module (e.g. sockets or file streams).
Returns a reference to the EventEmitter, so that calls can be chained.
OptionaleventName: string | symbolRemoves the specified listener from the listener array for the event named eventName.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener() will remove, at most, one instance of a listener from the
listener array. If any single listener has been added multiple times to the
listener array for the specified eventName, then removeListener() must be
called multiple times to remove each instance.
Once an event is emitted, all listeners attached to it at the
time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution
will not remove them fromemit() in progress. Subsequent events behave as expected.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
Because listeners are managed using an internal array, calling this will
change the position indices of any listener registered after the listener
being removed. This will not impact the order in which listeners are called,
but it means that any copies of the listener array as returned by
the emitter.listeners() method will need to be recreated.
When a single function has been added as a handler multiple times for a single
event (as in the example below), removeListener() will remove the most
recently added instance. In the example the once('ping') listener is removed:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
Returns a reference to the EventEmitter, so that calls can be chained.
Rest...args: any[]setAccessRestriction
By default EventEmitters will print a warning if more than 10 listeners are
added for a particular event. This is a useful default that helps finding
memory leaks. The emitter.setMaxListeners() method allows the limit to be
modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
Returns a reference to the EventEmitter, so that calls can be chained.
Optionaloptions: ISetStateOptionsOptionalstatusCode: StatusCodeOptionalsourceTimestamp: DateOptionalupdateNow: PreciseClockwrite a variable attribute (callback version)
example
const writeValue = {
attributeId: AttributeIds.Value,
dataValue: new DataValue({
statusCode: StatusCodes.Good,
sourceTimestamp: new Date(),
value: new Variant({ dataType: DataType.Double, value: 3.14 })
}),
nodeId
};
myVariable.writeAttribute(context,writeValue,(err, statusCode) => {
if (err) { console.log("Write has failed"); return; }
console.log("write statusCode = ",statusCode.toString());
});
write a variable attribute (async/await version)
example
try {
const writeValue = {
attributeId: AttributeIds.Value,
dataValue: new DataValue({
statusCode: StatusCodes.Good,
sourceTimestamp: new Date(),
value: new Variant({ dataType: DataType.Double, value: 3.14 })
}),
nodeId
};
const statusCode = await myVariable.writeAttribute(context,writeValue);
} catch(err) {
console.log("Write has failed");
return;
}
console.log("write statusCode = ", statusCode.toString());
OptionalindexRange: null | NumericRange