devicestack
Advanced tools
eeeee eeeee eeeee eeee e eeeee 8 8 8 88 8 8 8 8 8 " 8e 8 8 8 8e 8 8eee 8e 8eeee 88 8 8 8 88 8 88 e 88 88 88 8 8eee8 88ee8 88ee 88 8ee88 8ee88 eeeee eeee e e e eeee eeee eeeee eeeee eeeee eeee e ee 8 8 8 8 8 8 8e 8 8 " 8 8 8 8e 8 8 8e 8 8eee e e 8e 8 8eee 8eeee 8e 8eee8 8 8eee 88 8 88 8 8 88 8e 88 88 88 88 8 8e 88 8e 88ee8 88ee 8 88 eeee 88ee 8ee88 88 88 8 eeee 88 8
This module helps you to represent a device and its protocol.
___________________________________________________ | | | | | | tasks | | |________________ deviceguider |__________| | | | | | | deviceloader | | commands | |________________|__________________|_______________| | | ___________________| | | connection | | | device |______________| framehandler(s) | | |___________________| | | |___________________________________________________|
Each of the following software components can be used separately if you want...
Device -> SerialDevice -> FtdiSerialDevice
Device -> FtdiDevice -> FtdiSerialDevice
DeviceLoader -> SerialDeviceLoader -> EventedSerialDeviceLoader
DeviceLoader -> FtdiDeviceLoader -> EventedFtdiDeviceLoader
DeviceGuider -> SerialDeviceGuider
Device represents your physical device.
Implement the open mechanism to your device. Call with optional callback. On opened emit 'open' and call the callback.
require('devicestack').SerialDevice this mechanism is already defined!require('devicestack').FtdiDevice this mechanism is already defined!require('devicestack').FtdiSerialDevice this mechanism is already defined!Implement the close mechanism to your device. Call with optional callback. On closed emit 'close' and call the callback.
require('devicestack').SerialDevice this mechanism is already defined!require('devicestack').FtdiDevice this mechanism is already defined!require('devicestack').FtdiSerialDevice this mechanism is already defined!Implement the send mechanism to your device by subscribing the 'send' event. Call send or emit 'send' on the device with a byte array.
require('devicestack').Device the send function is already defined!Implement the receive mechanism from your device by emitting the 'receive' event. When you receive data from your device emit 'receive' with a byte array.
require('devicestack').SerialDevice this mechanism is already defined!require('devicestack').FtdiDevice this mechanism is already defined!require('devicestack').FtdiSerialDevice this mechanism is already defined!Implement the connect mechanism to your device. Call with optional callback. On connecting emit 'opening', create a new connection instance and call open by passing the callback.
require('devicestack').Device this mechanism is already defined!Implement the disconnect mechanism to your device. Call with optional callback. On disconnecting emit 'closing' and call close by passing the callback.
require('devicestack').Device this mechanism is already defined!Sets attributes for the device.
require('devicestack').Device this mechanism is already defined!example:
device.set('firmwareVersion', '0.0.1');
// or
device.set({
firmwareVersion: '0.0.1',
bootloaderVersion: '0.0.1'
});
Gets an attribute of the device.
require('devicestack').Device this mechanism is already defined!example:
device.get('firmwareVersion'); // returns '0.0.1'
Returns true if the attribute contains a value that is not null or undefined.
require('devicestack').Device this mechanism is already defined!example:
device.has('firmwareVersion'); // returns true or false
Connection will be created from connect of device.
onConnecting function if exists and emits 'connecting' and 'connect' and emits 'connecting' on deviceIn extended constuctor create the framehandler(s) and subscribe to receive on the last framehandler.
Implement the close mechanism.
Call with optional callback. On closing emit 'disconnecting', call onDisconnecting function if exists, on disconnected emit 'disconnect' and call close on device by passing the callback. Emits 'disconnecting' on device.
require('devicestack').Connection this mechanism is already defined!Define onConnecting function if you need to send some commands before definitely connected?
Define onDisconnecting function if you need to send some commands before definitely disconnected?
Sets attributes for the connection.
require('devicestack').Connection this mechanism is already defined!example:
connection.set('firmwareVersion', '0.0.1');
// or
connection.set({
firmwareVersion: '0.0.1',
bootloaderVersion: '0.0.1'
});
Gets an attribute of the connection.
require('devicestack').Connection this mechanism is already defined!example:
connection.get('firmwareVersion'); // returns '0.0.1'
Returns true if the attribute contains a value that is not null or undefined.
require('devicestack').Connection this mechanism is already defined!example:
connection.has('firmwareVersion'); // returns true or false
Executes the passing command. If the initialize function is present it will validate the arguments of the command. If necessary for validation reason the initialize function can throw errors. Pushes the command in a queue and calls the sendCommand function.
Sends the passing command. Implement the executeCommand mechanism.
Executes the passing task. If the initialize function is present it will validate the arguments of the task. If necessary for validation reason the initialize function can throw errors.
require('devicestack').Connection this mechanism is already defined!Runs the passing task.
require('devicestack').Connection this mechanism is already defined!Runs the passing task.
require('devicestack').Connection this mechanism is already defined!Checks if there is a task in the queue and runs it.
require('devicestack').Connection this mechanism is already defined!Checks if there is something to execute and executes it. IMPORTANT!!! Call this function when a command answer is handled!
require('devicestack').Connection this mechanism is already defined!You can have one or multiple framehandlers. A framhandler receives data from the upper layer and sends it to the lower layer by wrapping some header or footer information. A framehandler receives data from lower layer and sends it to the upper layer by unwrapping some header or footer information. The lowest layer for a framehandler is the device and the topmost ist the connection.
wrapFrame function if exists and calls send function on lower layerunwrapFrame function if exists and emits receiveCalls analyzeNextFrame function in a loop.
require('devicestack').FrameHandler this mechanism is already defined!Triggers the analyze function.
require('devicestack').FrameHandler this mechanism is already defined!Call send or emit 'send' on the device with a byte array.
require('devicestack').FrameHandler this mechanism is already defined!Implement the analyzeNextFrame mechanism that returns a frame as byte array or null of no frame found. Call with current incomming buffer.
Define wrapFrame function if you need to wrap frames?
Define unwrapFrame function if you need to unwrap frames?
A deviceloader can check if there are available some devices.
Creates an interval that calls trigger function.
Call with optional interval in milliseconds and optional callback.
require('devicestack').DeviceLoader this mechanism is already defined!Stops the interval that calls trigger function.
require('devicestack').DeviceLoader this mechanism is already defined!Calls lookup function with optional callback and emits 'plug' for new attached devices and 'unplug' for removed devices.
require('devicestack').DeviceLoader this mechanism is already defined!Call with optional callback and call callback with an array of devices.
require('devicestack').SerialDeviceLoader this mechanism is already defined!require('devicestack').FtdiDeviceLoader this mechanism is already defined!A deviceguider emits 'plug' for new attached devices, 'unplug' for removed devices, emits 'connect' for connected devices and emits 'disconnect' for disconnected devices.
Call with callback and it calls the callback with the current state, containing the connectionMode, the list of plugged devices and the list of connected devices.
require('devicestack').DeviceGuider this mechanism is already defined!Call without arguments it emits 'connectionModeChanged'. When plugging a device it will now automatically connect it and emit 'connect'. Already plugged devices will connect immediately.
require('devicestack').DeviceGuider this mechanism is already defined!Call with optional callback it emits 'connectionModeChanged'. When plugging one device it will now automatically connect one and emit 'connect'. If there is already a plugged device, it will connect immediately and call the callback.
require('devicestack').DeviceGuider this mechanism is already defined!Call with optional holdConnections flag and optional callback it emits 'connectionModeChanged'. When plugging a device it will not connect it. Dependent on the holdConnections flag already connected devices will disconnect immediately and call the callback.
require('devicestack').DeviceGuider this mechanism is already defined!Call with the deviceId or the device and optional callback it will connect that device and call the callback.
require('devicestack').DeviceGuider this mechanism is already defined!Call with the deviceId or the device and optional callback it will disconnect that device and call the callback.
require('devicestack').DeviceGuider this mechanism is already defined!Call with the connectionId or the connection and optional callback it will close that connection and call the callback.
require('devicestack').DeviceGuider this mechanism is already defined!Call with a connectionMode value it checks if the connectionMode will change and returns true or false.
require('devicestack').DeviceGuider this mechanism is already defined!Call with a connectionMode value it checks if the connectionMode will change and emits 'connectionModeChanged'.
require('devicestack').DeviceGuider this mechanism is already defined!Call with the portname and optional callback it will connect that device and call the callback.
require('devicestack').SerialDeviceGuider this mechanism is already defined!Call with the portname and optional callback it will disconnect that device and call the callback.
require('devicestack').SerialDeviceGuider this mechanism is already defined!Build your own commands looking like this:
var Command = require('../../index').Command,
util = require('util');
function MyCommand(firstByte) {
// call super class
Command.call(this, arguments);
}
util.inherits(MyCommand, Command);
// if argumentsSchema is defined it will validates the passed constructor arguments
MyCommand.prototype.argumentsSchema = {
type: 'array',
items: [
{
anyOf: [
{
type: 'number'
},
{
type: 'undefined'
}
]
},
{
type: 'string'
}
]
};
MyCommand.prototype.initialize = function(connection, firstByte) {
firstByte = firstByte || 0x01;
if (firstByte < 0) {
throw new Error('wrong value');
}
this.data = [firstByte, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09];
};
MyCommand.prototype.execute = function(connection, callback) {
connection.executeCommand(this, callback);
};
module.exports = MyCommand;
Build your own tasks looking like this:
var Task = require('../../index').Task,
util = require('util'),
Command = require('./command');
function MyTask(identifier) {
// call super class
Task.call(this, arguments);
}
util.inherits(MyTask, Task);
// if argumentsSchema is defined it will validates the passed constructor arguments
MyTask.prototype.argumentsSchema = {
type: 'array',
minItems: 0,
items: [
{
},
{
type: 'string'
}
]
};
MyTask.prototype.initialize = function(connection, identifier) {
if (identifier === 111) {
throw new Error('wrong value in task');
}
this.command = new Command(identifier);
};
MyTask.prototype.perform = function(connection, callback) {
this.execute(this.command, connection, callback);
};
module.exports = MyTask;
Some utility functions are shipped with this module.
Converts a byte array to a buffer object. [0x01, 0x00].toBuffer()
Converts a byte array to a readable hex string. [0x01, 0x00].toHexDebug() // returns '01-00'
Converts a byte array to a hex string. [0x01, 0x00].toHexString() // returns '0100'
Converts a buffer object to a byte array. (new Buffer([0x01, 0x00])).toArray() // returns [0x01, 0x00]
Converts a buffer object to a readable hex string. (new Buffer([0x01, 0x00])).toHexDebug() // returns '01-00'
Converts a hex string to a byte array. '0100'.toArray() // returns [0x01, 0x00] '01-FA'.toArray() // returns [0x01, 0xFA]
Checks if the passed argument is an array that contains byte values. Array.isByteArray([0x01, 0x00]) // returns true
npm install devicestack
var Device = require('devicestack').Device
, util = require('util');
function MyDevice() {
// call super class
Device.call(this);
}
util.inherits(MyDevice, Device);
MyDevice.prototype.open = function(callback) {
var self = this;
setTimeout(function() {
self.emit('open', callback);
if (!self.connection && callback) callback();
}, 10);
this.on('send', function(data) {
setTimeout(function() {
self.emit('receive', data);
}, 5);
});
};
MyDevice.prototype.close = function(callback, fire) {
var self = this;
setTimeout(function() {
self.emit('close', callback);
self.removeAllListeners();
if (callback && (!self.connection || fire)) callback(null);
}, 10);
};
module.exports = MyDevice;
var SerialDevice = require('devicestack').SerialDevice
, util = require('util');
function MyDevice(port) {
// call super class
SerialDevice.call(this,
port,
{
baudrate: 38400,
databits: 8,
stopbits: 1,
parity: 'none'
}
);
}
util.inherits(MyDevice, SerialDevice);
module.exports = MyDevice;
var FtdiDevice = require('devicestack').FtdiDevice
, util = require('util');
function MyDevice(ftdiSettings) {
// call super class
FtdiDevice.call(this,
ftdiSettings,
{
baudrate: 38400,
databits: 8,
stopbits: 1,
parity: 'none'
}
);
}
util.inherits(MyDevice, SerialDevice);
module.exports = MyDevice;
var MyDevice = require('./myDevice');
var myDevice = new MyDevice({
locationId: 0x1234,
serialNumber: 's2345'
});
myDevice.open(function(err) {
myDevice.on('receive', function(data) {
console.log(data);
});
myDevice.send([0x01, 0x02, 0x03]);
});
var FrameHandler = require('devicestack').FrameHandler
, util = require('util');
function MyFrameHandler(device) {
// call super class
FrameHandler.call(this, device);
}
util.inherits(MyFrameHandler, FrameHandler);
MyFrameHandler.prototype.analyzeNextFrame = function(incomming) {
return incomming.splice(0);
};
MyFrameHandler.prototype.unwrapFrame = function(frame) {
return frame;
};
MyFrameHandler.prototype.wrapFrame = function(frame) {
return frame;
};
module.exports = MyFrameHandler;
var Connection = require('devicestack').Connection
, util = require('util')
, FrameHandler = require('./framehandler');
function MyConnection(device) {
// call super class
Connection.call(this, device);
this.frameHandler = new FrameHandler(this.device);
this.frameHandler.on('receive', function (frame) {
// forward to appropriate command...
});
}
util.inherits(MyConnection, Connection);
// define if needed
MyConnection.prototype.onConnecting = function(callback) {
// Need to send some commands before definitely connected?
if (callback) callback();
};
// define if needed
MyConnection.prototype.onDisconnecting = function(callback) {
// Need to send some commands before definitely closed?
if (callback) callback();
};
MyConnection.prototype.sendCommand = function(commandData, callback) {
this.frameHandler.send('send', commandData);
};
module.exports = MyConnection;
var Device = require('devicestack').Device
, util = require('util')
, Connection = require('./connection'); // this line...
function MyDevice() {
// call super class
Device.call(this, Connection); // ...and this line
}
util.inherits(MyDevice, Device);
MyDevice.prototype.open = function(callback) {
var self = this;
setTimeout(function() {
self.emit('open', callback);
if (!self.connection && callback) callback();
}, 10);
this.on('send', function(data) {
setTimeout(function() {
self.emit('receive', data);
}, 5);
});
};
MyDevice.prototype.close = function(callback, fire) {
var self = this;
setTimeout(function() {
self.emit('close', callback);
self.removeAllListeners();
if (callback && (!self.connection || fire)) callback(null);
}, 10);
};
module.exports = MyDevice;
var SerialDevice = require('devicestack').SerialDevice
, util = require('util')
, Connection = require('./connection'); // this line...;
function MyDevice(port) {
// call super class
SerialDevice.call(this,
port,
{
baudrate: 38400,
databits: 8,
stopbits: 1,
parity: 'none'
},
Connection // ...and this line
);
}
util.inherits(MyDevice, SerialDevice);
module.exports = MyDevice;
var FtdiDevice = require('devicestack').FtdiDevice
, util = require('util')
, Connection = require('./connection'); // this line...;
function MyDevice(ftdiSettings) {
// call super class
FtdiDevice.call(this,
ftdiSettings,
{
baudrate: 38400,
databits: 8,
stopbits: 1,
parity: 'none'
},
Connection // ...and this line
);
}
util.inherits(MyDevice, SerialDevice);
module.exports = MyDevice;
var MyDevice = require('./myDevice');
var myDevice = new MyDevice({
locationId: 0x1234,
serialNumber: 's2345'
});
myDevice.open(function(err) {
myDevice.on('receive', function(data) {
console.log(data);
});
myDevice.send([0x01, 0x02, 0x03]);
});
var DeviceLoader = require('devicestack').DeviceLoader
, util = require('util')
, Device = require('./device');
function MyDeviceLoader() {
// call super class
DeviceLoader.call(this);
}
util.inherits(MyDeviceLoader, DeviceLoader);
MyDeviceLoader.prototype.lookup = function(callback) {
var devices = = [
new Device(),
new Device()
];
try {
this.emit('lookup');
} catch(e) {
}
callback(null, devices);
};
module.exports = new MyDeviceLoader();
var SerialDeviceLoader = require('devicestack').SerialDeviceLoader
, _ = require('lodash')
, util = require('util')
, Device = require('./device');
function MyDeviceLoader() {
// call super class
MyDeviceLoader.call(this, Device);
}
util.inherits(MyDeviceLoader, SerialDeviceLoader);
MyDeviceLoader.prototype.filter = function(ports) {
var resPorts = _.filter(ports, function(item) {
if (process.platform == 'win32') {
return item.pnpId.indexOf('VID_1234+PID_5678') >= 0;
} else if (process.platform == 'darwin') {
return item.productId === '0x5678' && item.vendorId === '0x1234';
} else {
return item.pnpId.indexOf('MyDeviceIdentification') >= 0;
}
});
return resPorts;
};
module.exports = new MyDeviceLoader();
var DeviceGuider = require('devicestack').DeviceGuider
, util = require('util')
, deviceLoader = require('./deviceloader');
function MyDeviceGuider() {
// call super class
DeviceGuider.call(this, deviceLoader);
}
util.inherits(MyDeviceGuider, DeviceGuider);
module.exports = new MyDeviceGuider();
var myDeviceguider = require('./deviceguider');
myDeviceguider.on('err', function(err) {
if (err) { console.log(err); return process.exit(); }
});
myDeviceguider.on('plug', function(device) {
console.log('\n--->>> plugged a device\n');
});
myDeviceguider.on('unplug', function(device) {
console.log('\n--->>> unplugged a device\n');
});
myDeviceguider.on('connect', function(connection) {
console.log('\n--->>> connected a device\n');
connection.executeCommand(/* your stuff */, callback);
});
myDeviceguider.on('disconnect', function(connection) {
console.log('\n--->>> disconnected a device\n');
});
myDeviceguider.getCurrentState(function(err, currentState) {
if (currentState.plugged.length === 0) { console.log('No devices found!'); /*return process.exit();*/ }
});
myDeviceguider.on('connectionStateChanged', function(evt) {
// evt-> { state: 'connect', connection: /* connection */ }
// evt-> { state: 'disconnect', connection: /* connection */ }
// evt-> { state: 'connecting', device: /* device */ }
// evt-> { state: 'disconnecting', device: /* device */ }
});
// V1: autoconnect first device...
myDeviceguider.on('connect', function(device, connection) {
// when first device connected...
});
myDeviceguider.autoconnectOne([function(err, device, connection) {}]);
myDeviceguider.stopautoconnecting(); // will stop autoconnecting and will disconnect connected device
// V2: autoconnect all devices...
myDeviceguider.on('connect', function(device, connection) {
// when a device connected...
});
myDeviceguider.autoconnect();
myDeviceguider.stopautoconnecting(); // will stop autoconnecting and will disconnect all connected devices
// V3: manualconnect devices...
myDeviceguider.on('plug', function(device) {
// when a device ready to be connected...
device.connect(function(err, connection) {
// device connected...
});
});
// V4: manualconnect a device with port...
myDeviceguider.on('connect', function(device, connection) {
// when first device connected...
});
myDeviceguider.connect(port[, function(err, device, connection) {}]);
Copyright (c) 2013 Adriano Raiano
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
FAQs
This module helps you to represent a device and its protocol.
The npm package devicestack receives a total of 4 weekly downloads. As such, devicestack popularity was classified as not popular.
We found that devicestack demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
Socket researchers have discovered malicious npm packages targeting crypto developers, stealing credentials and wallet data using spyware delivered through typosquats of popular cryptographic libraries.
Security News
Socket's package search now displays weekly downloads for npm packages, helping developers quickly assess popularity and make more informed decisions.
Security News
A Stanford study reveals 9.5% of engineers contribute almost nothing, costing tech $90B annually, with remote work fueling the rise of "ghost engineers."