@concord-consortium/sensor-connector-interface
v0.2.0
Published
JavaScript interface to the Sensor Connector
Downloads
7
Maintainers
Keywords
Readme
Sensor Connector Interface
JavaScript interface for Concord Consortium's SensorConnector software http://sensorconnector.concord.org/
Installation and Usage
npm install @concord-consortium/sensor-connector-interface --save
or if using yarn
yarn add @concord-consortium/sensor-connector-interface
Then in your JavaScript code:
import SensorConnectorInterface from "@concord-consortium/sensor-connector-interface";
const sensorConnector = new SensorConnectorInterface();
or
var SensorConnectorInterface = require("@concord-consortium/sensor-connector-interface");
var sensorConnector = new SensorConnectorInterface();
Development
Install local dependencies:
npm install
Build for distribution:
npm run build
Test locally:
npm run start
This launches a local page which supports connecting to the SensorConnector application and logging communication with it.
Publication
sensor-connector-interface
is published as an npm module under the name @concord-consortium/sensor-connector-interface
. Updates should be published to npm using a new version number that follows semver. To publish, simply configure your npm account (you must have authorization to publish for the @concord-consortium organization) and then:
npm publish
Methods
startPolling(addresses, clientId, clientName)
Initiates the connection to the SensorConnector application. addresses
can be a single address or an array of addresses which are used to communicate with the SensorConnector. The SensorConnector application currently supports http://127.0.0.1:11180
and https://127.0.0.1:11181
.
stopPolling()
Closes the connection to the SensorConnector.
requestStart(measurementPeriod?:number)
Starts data collection.
requestStop()
Stops data collection.
on(event, listener)
Adds a listener to be fired when the specified event is emitted. The listener is a function whose arguments are the arguments emitted along with the event.
off(event, listener)
Removes a listener from the set of listeners for an event. Accepts '*'
for event
, which allows removal of a listener function from all events for which it is registered as a listener.
Accessors
Internally, the SensorConnectorInterface is implemented as a finite state machine, so many of the accessors refer to properties of the underlying state machine, such as the current state.
clientId/clientId(clientId)
Retrieve/set the client ID.
clientName/clientName(clientName)
Retrieve/set the client name.
hasAttachedInterface
True if there is a data collection interface attached.
datasets
The currently collected datasets.
isConnected
True if a data collection interface is attached, control of the data collection interface is enabled, and the data collection interface is not currently collecting data. (Note: it's not clear why collecting data is considered not connected, but that's the way it's coded.)
isCollecting
True if the data collection interface is currently collecting data.
inControl/canControl
True if control of the data collection interface is not currently disabled.
launchTimedOut
True if the initial launch of the SensorConnectorInterface failed due to a connection timeout.
Events
The SensorConnectorInterface uses the EventEmitter2 library to emit events for client consumption.
interfaceConnected: handler() [1]
Sent when a connected data collection interface (e.g. Vernier LabQuest, Go!Link, etc.) is detected. See [1] below for the current means of accessing the sensor configuration.
interfaceRemoved: handler()
Sent when a connected data collection interface (e.g. Vernier LabQuest, Go!Link, etc.) is no longer detected.
sessionChanged: handler() [1]
A change in session ID was detected internally. Client should probably stop/start polling. See [1] below for the current means of accessing the sensor configuration.
collectionStarted: handler()
Sent when data collection has begun.
collectionStopped: handler()
Sent when data collection has been stopped.
datasetAdded: handler(datasetID) [1]
Denotes the addition of a new dataset. Not emitted until the second collection because the first dataset always exists. See [1] below for the current means of accessing the sensor configuration.
data: handler(columnID) [2]
Sent when a column of data is available. See [2] below for the current means of accessing the data.
columnAdded: handler(columnID) [1]
Sent when a new column of data is received. See [1] below for the current means of accessing the sensor configuration.
columnMoved: handler(columnID) [1]
Sent when a column of data has changed its position. See [1] below for the current means of accessing the sensor configuration.
columnRemoved: handler(columnID) [1]
Sent when a column of data is removed. See [1] below for the current means of accessing the sensor configuration.
columnTypeChanged: handler(columnID) [1]
Sent when a change in the units of a column of data has been detected. See [1] below for the current means of accessing the sensor configuration.
controlEnabled: handler()
Indicates that the data collection interface still exists and is communicating, and that the Sensor Connector Interface is able to control it at the moment.
controlDisabled: handler()
Indicates that the data collection interface still exists and is communicating, but that the Sensor Connector Interface is not able to control it at the moment.
launchTimedOut: handler()
Sent when a communication timeout occurs during launch.
statusReceived: handler() [1]
Sent when a status update from the connected interface has been successfully processed. See [1] below for the current means of accessing the sensor configuration.
statusErrored: handler()
Sent when an error occurs.
[1] currentActionArgs:IStatusReceivedTuple
As an implementation detail, the events marked with a [1] are called from the status response handler of the SensorConnectorInterface. Currently, the contents of the status response can be retrieved with sensorConnector.stateMachine.currentActionArgs
, i.e. by reaching into the internal state of the finite state machine directly. A better API should be provided for accessing this information and this method should be deprecated. In the meantime, the currentActionArgs
is a two-element array in which the sensor configuration is in currentActionArgs[1]
. The currentActionArgs
have this form as a TypeScript definition:
interface ISensorConfigColumnInfo {
id:string;
setID:string;
position:number;
name:string;
units:string;
liveValue:string;
liveValueTimeStamp:Date;
valueCount:number;
valuesTimeStamp:Date;
data?:number[];
}
interface ISensorConfigSet {
name:string;
colIDs:number[];
}
interface ISensorConfig {
collection:{ canControl:boolean; isCollecting:boolean; };
columnListTimeStamp:Date;
columns:{ [key:string]: ISensorConfigColumnInfo; };
currentInterface:string;
currentState:string;
os:{ name:string; version:string; };
requestTimeStamp:Date;
server:{ arch:string; version:string; };
sessionDesc:string;
sessionID:string;
sets:{ [key:string]: ISensorConfigSet; };
setID?:string;
}
interface IMachinaAction {
inputType:string;
delegated:boolean;
ticket:any;
}
interface IStatusReceivedTuple
extends Array<IMachinaAction|ISensorConfig>
{0:IMachinaAction, 1:ISensorConfig}
[2] currentActionArgs:IColumnDataTuple
As an implementation detail, the events marked with a [2] are called from the 'columnData' response handler of the SensorConnectorInterface. Currently, the contents of the response can be retrieved with sensorConnector.stateMachine.currentActionArgs
, i.e. by reaching into the internal state of the finite state machine directly. A better API should be provided for accessing this information and this method should be deprecated. In the meantime, currentActionArgs
is a four-element array in which:
currentActionArgs[1]
: the column IDcurrentActionArgs[2]
: the column data valuescurrentActionArgs[3]
: the timestamp of the data values
The column data values in currentActionArgs[2]
are time values for dataset IDs that end in '0', and sensor data values for all other dataset IDs. The currentActionArgs
have this form as a TypeScript definition:
interface IMachinaAction {
inputType:string;
delegated:boolean;
ticket:any;
}
interface IColumnDataTuple
extends Array<IMachinaAction|string|number[]|Date>
{0:IMachinaAction, 1:string, 2:number[], 3:Date}
License
Released under the MIT License.