Awesome

smartobject

A Smart Object Class that helps you with creating IPSO Smart Objects in your JavaScript applications

Overview
Installation
Usage
Resources Planning
APIs
Code Templates

1. Overview

smartobject is a Smart Object Class that helps you with creating IPSO Smart Objects in your JavaScript applications. If you like to use the IPSO data model in your projects or products, you can use smartobject as the base class to abstract your hardware, sensor modules, or gadgets into plugins (node.js packages) for users convenience. Here is an example of hardware abstraction with mraa on Linkit Smart 7688 in our wiki. In addition, this module is isomorphic and you can use it at server-side as well to generate the smart objects.

IPSO defines a hierarchical data model to describe real-world gadgets, such as temperature sensors and light controllers.

IPSO uses Object to tell what kind of a gadget is, and uses Object Instance to tell which one a gadget is.
An Object is like a class or a boilerplate, and each kind of Object has an unique Object Id (oid) defined by IPSO, e.g., 3303 for the Temperature Sensor Object. Here is the list of oids.
An Object Instance is the entity of an Object. Each Object Instance has an unique Object Instance Id to identify itself from other gadgets of the same class. Simply speaking, oid is like a namespace to manage all the same kind of IPSO Object Instances.
The Resources are used to describe what attributes may a gadget have, for example, a temperature sensor may have attributes such as sensorValue, unit, minMeaValue, .etc. Resource Values will be filled after instantiated. Here is the list of templates to show you what attributes may a gadget have.

ISPO Model

[Note]

The italics, such Object, Object Id, Object Instance, and Object Instance Id, are used to distinguish the IPSO Objects from the JavaScript objects.

2. Installation

$ npm install smartobject --save

3. Usage

Here is a quick example to show you how to create your Smart Object with only few steps:

Step 1: Import the SmartObject Class and create an instance from it

var SmartObject = require('smartobject');
var so = new SmartObject(); // so can hold many Object Instances in it

Step 2: Initialize a temperature sensor in your smart object so (ref: code templates)

so.init(
    'temperature',          // 'temperature' is the IPSO-defined Object Identifier (oid, 3303).
    0,                      // 0 is the unique Object Instance Id (iid) assigned by you.
    {                       // This object contains all Resources (attributes) this sensor has.
        sensorValue: 31,    // 'sensorValue' is the IPSO-defined Resource Id (rid, 5700)
        units : 'C'         // 'units' is the IPSO-defined Resource Id (rid, 5701)
    }
);

Step 3: Initialize more Object Instances. Finally, we have 3 temperature sensors, 1 magnetometer, and 4 digital inputs in our so

// Init more temperature sensors (each with an unique iid)
so.init('temperature', 1, {
    sensorValue: 28,
    units : 'C'
});

so.init('temperature', 2, {
    sensorValue: 72.6,
    units : 'F'
});

// Init other gadgets
so.init('magnetometer', 0, {
    xValue: 18,
    yValue: 21,
    zValue: 231
});

so.init('dIn', 0, { dInState: 1 });
so.init('dIn', 1, { dInState: 0 });
so.init('dIn', 6, { dInState: 0 });
so.init('dIn', 7, {
    // if dInState should be read from by certain operation
    dInState: {
        read: function (cb) {
            var hal = this.parent.hal;  // see SmartObject constructor
            hal.digitalPin0.read(function (err, val) {
                cb(null, val);
            });
        }
    }
});

4. Resources Planning

The great benefit of using smartobject in your application is that you almost need not to tackle the allocation of Resources by yourself. It provides a scheme to help you with management of reading/writing your hardware or executing a procedure on the machine. All you have to do is to plan and define your Resources well, and then use smartobject methods to do your jobs. You can use smartobject to abstract your hardware, sensor modules, or gadgets into plugins (node.js packages).

Imagine that you have to read the temperature value from a sensor with one-wire interface:

How to export this sensor to an IPSO smart object?
How do you read the temperature value from your smart object?
How do you do with the access control? Your Resource is readable? writable? or remotely executable?

Please refer to Resources Planning Tutorial for more details. It will show you how to initialize your Resources and how to abstract your hardware with IPSO Resources as well. In addition, here are some code templates for your convenience to create smart objects.

5. APIs

new SmartObject()
init(), remove()
objectList()
has(), get(), set()
read(), write(), exec()
dump(), dumpSync()
isReadable(), isWritable(), isExecutable()

[Note]

In general, the most often used APIs are new SmartObject(), init(), read(), and write(). It's not that complicated as it looks like.

SmartObject Class

Exposed by require('smartobject').

new SmartObject([hal][, setup])

Create an instance of SmartObject class. This document will use so to indicate this kind of instance.

A so can hold many IPSO Object Instances in it. The so itself has an accessible but un-enumerable boolean property 'ipsoOnly' to define if this so only accepts IPSO-defined oid and rid. Default value for so.ipsoOnly is false. You can set it to true in the setup function.

If so.ipsoOnly == true, then the given oid must be an IPSO-defined Object Id, iid must be a number, and all keys within resrcs object must be IPSO-defined Resource Ids, or so.init() will throw Errors.

Arguments:

hal (Object): Optional. A component or controller of the hardware abstraction layer. It will be assigned to this.hal at creation of a so. Noted that so.hal is accessible but un-enumerable.
setup (Function): Optional. A setup function allows you to do some initializing work, for example, setting gpio direction. In the setup function, this will be bound to the so itself, thus you can use this.hal to access your hardware.

Returns:

(Object): so

Examples:

A very simple case. There is no hardware with the smart object. For example, at server-side we only need the data of a smart object, thus we don't have the hal.

var SmartObject = require('smartobject');

var so = new SmartObject();

No hardware, and you like to make so accept only IPSO-defined identifiers.

var SmartObject = require('smartobject');

var so = new SmartObject(function () {
    this.ipsoOnly = true;
});

We have 2 LEDs and 1 Switch controlled via mraa. This is a typical example at client-side (machine).

var m = require('mraa');
var SmartObject = require('smartobject');

var myHardware = {
    led1: new m.Gpio(44),
    led2: new m.Gpio(44),
    onOffSwitch: new m.Gpio(45),
    foo: 'bar'
};

var so = new SmartObject(myHardware, function () {
    var hal = this.hal;

    // hardware initialization
    hal.led1.dir(m.DIR_OUT);
    hal.led2.dir(m.DIR_OUT);
    hal.onOffSwitch.dir(m.DIR_IN);

    hal.foo = 'initialized';
    this.ipsoOnly = true;
});

init(oid, iid, resrcs[, setup])

Create and initialize an Object Instance in so, where oid is the IPSO Object Id to indicate what kind of your gadget is, iid is the Object Instance Id, and resrcs is an object that wraps up all the Resources.

Be careful, invoking init() against an existing Object Instance will firstly wipe out all its Resources and inner _state and then put the new Resources into it. Thus, it is better to initialize your Instance only once throughout your code.
Property _state is a special Resource that is an accesible but un-enumerable protected member in the Object Instance. It is an object where you can maintain some private information or inner state within the Object Instance. We will talk about it more later.

Arguments:

oid (String | Number): IPSO Object Id, for example, 'temperature' or 3303. so will internally turn the id into its string version, say 'temperature', as the key if given with a numeric id.
iid (String | Number): Object Instance Id. It would be nice to use numbers, i.e., 0, 1, 2 to strictly meet the IPSO definition. But strings are also accepted, e.g., 'sen01', 'sen02', 'sen03', it is just like a handle to help you distinguish different Instances that share the same Object class.
resrcs (Object): IPSO Resources, which is an object with rid-value pairs to describe the Resources. Each key in resrcs is a Resource Id that can be a string or a number. And each value can be a primitive, an data object, or an object with specific methods, i.e. read(), write(), exec(). The Resources Planning Tutorial will give you some hints. You can have your private information or inner states within an object assigned to the resrc._state property, for example resrc = { _state: { foo: 'bar' } }.
setup (Function): Optional. A setup function allows you to set some things up, for example, setting some flags or states for inner use. In this function, this will be bound to the Object Instance itself, thus you can use this._state to access your inner state. Further more, you can use this.parent to get the so that owns this Object Instance, and use this.parent.hal to access your hardware.

Returns:

(Object): objInst, the initialized Object Instance.

Examples:

A very simple case. There is no hardware with the smart object.

var so = new SmartObject();

so.init('temperature', 0, {
    sensorValue: 31,
    units : 'C'
});

so.init('temperature', 1, {
    _state: {           // inner state
        foo: 'bar'
    },
    sensorValue: 75,
    units : 'F'
});

so.init(3303, 18, {
    sensorValue: 301,
    units : 'K'
}, function () {
    // this._state is an empty object by default
    // you can attach things to it
    this._state.foo = 'bar';
});

// Dumped data of the so will look like:
// (inner _state will not be dumped)
/*
{
    temperature: {
        '0': {
            sensorValue: 31,
            units : 'C'
        },
        '1': {
            sensorValue: 75,
            units : 'F'
        },
        '18': {
            sensorValue: 301,
            units : 'K'
        }
    }
}
*/

We have 1 LED and 1 On/Off Switch controlled via mraa.

var m = require('mraa');
var SmartObject = require('smartobject');

var so = new SmartObject({
    led: new m.Gpio(44),
    onOffSwitch: new m.Gpio(45)
}, function () {
    var hal = this.hal;

    // hardware initialization
    hal.led.dir(m.DIR_OUT);
    hal.onOffSwitch.dir(m.DIR_IN);

    this.ipsoOnly = true;
});

// led
so.init('lightCtrl', 0 , {
    _state: {   // protected resource to maintain inner states
        readCounts: 0,  // to record times of read
        writeCounts: 0  // to record times of written
    },
    onOff: {
        read: function (cb) {
            // 'this' is bound to Object Instance itself
            // this.parent === so
            var hal = this.parent.hal;
            var ledState = hal.led.read();

            this._state.readCounts += 1;    // inner record
            cb(null, ledState);
        },
        write: function (val, cb) {
            var hal = this.parent.hal;
            hal.led.write(val);

            this._state.writeCounts += 1;   // inner record
            cb(null, hal.led.read());
        }
    }
});

remove(oid, iid)

Remove an Object Instance in so, where oid is the IPSO Object Id to indicate what kind of your gadget is, iid is the Object Instance Id.

Arguments:

oid (String | Number): IPSO Object Id, for example, 'temperature' or 3303. so will internally turn the id into its string version, say 'temperature', as the key if given with a numeric id.
iid (String | Number): Object Instance Id. It would be nice to use numbers, i.e., 0, 1, 2 to strictly meet the IPSO definition. But strings are also accepted, e.g., 'sen01', 'sen02', 'sen03', it is just like a handle to help you distinguish different Instances that share the same Object class.

Returns:

(Boolean): Returns true if remove successfully, else returns false if the Object Instance does not exist.

Examples:

so.remove('temperature', 0)

objectList()

Returns the list of Objects and Object Instances with their identifiers. If an Id is an IPSO-defined one, it will be returned as a number. If you're using LWM2M interface, you may need this method to generate the Object List when registering to a server.

Arguments:

none

Returns:

(Array): Returns an array that contains all the identifiers, each element is in the form of { oid: 3301, iid: [ 0, 1, 2, 3 ] }.

Examples:

var so = new SmartObject();

so.init('temperature', 0, {
    sensorValue: 31,
    units : 'C'
});

so.init('temperature', 18, {
    sensorValue: 301,
    units : 'K'
});

so.init('illuminance', 0, {
    sensorValue: 128.6
});

so.initResrc('presence', 6, {
    dInState: 0
});

so.initResrc('myGadget', 'gad72', {
    myResource: 'hello_world'
});

so.objectList();
/*
[
    { oid: 3303, iid: [ 0, 18 ] },
    { oid: 3301, iid: [ 0 ] },
    { oid: 3302, iid: [ 6 ] },
    { oid: 'myGadget', iid: [ 'gad72' ] }    // not IPSO-defined
]
*/

has(oid[, iid[, rid]])

To see if so has the specified Object, Object Instance, or Resource.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.

Returns:

(Boolean): Returns true if target exists, otherwise false.

Examples:

// Checks if so has the 'humidity' Object
so.has('humidity');                       // true

// Checks if so has the 'foo' Object Instance with iid = 0
so.has('foo', 0);                         // false

// Checks if so has the 'sensorValue' Resource in temperature sensor 8
so.has('temperature', 8, 'sensorValue');  // true

get(oid, iid, rid)

Synchronously get the specified Resource.

At client-side (machine), the get() method is usually used to get the raw Resource which may be an object with read/write/exec callbacks. If you like to read the exact value of a Resource, you should use the asynchronous read() method. Since reading something from somewhere may require some special and asynchronous operations, such as reading data from a wire, and reading from a database.
At server-side (data center), the Resource values are simple data pieces requested from machines. Thus, using get() to get the stored value of a Resource on the server is no problem.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.

Returns:

(Depends): Returns the Resource value, or undefined if Resource does not exist.

Examples:

so.get('temperature', 2, 'sensorValue');  // 26.4

// If the Resource is an object with read/write/exec method(s)
so.get('temperature', 1, 'sensorValue');
/*
{
    read: function (cb) { ... }
}
*/

// If you do like to read the exact value from the temperature sensor, please use read()
so.read('temperature', 1, 'sensorValue', function (err, data) {
    if (!err)
        console.log(data);  // 18.4
});

set(oid, iid, rid, value)

Synchronously set a value to the specified Resource.

At client-side (machine), the set() method is usually used to initialize a Resource, but not to write a value to a Resource. You should use the asynchronous write() method if you like to write a value to the Resource. Since writing something to somewhere may require some special and asynchronous operations, such as writing data to a wire, and writing data to a database.
At server-side (data center), use set() to store the value of a Resource on the server is no problem. For example, when your request of reading a Resource from a remote machine has responded back, you can use set() to store that Resource value on the server.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.
value (Primitives | Object): Resource data or an object with read/write/exec method(s). This method will throw if value is given with a function.

Returns:

(Boolean): Returns true if set successfully, else returns false if the Object Instance does not exist (Resource cannot be set).

Examples:

so.set('dIn', 0, 'dInState', 1);    // true
so.set('dOut', 1, 'dOutState', 0);  // true

so.set('dOut', 2, 'dOutState', {
    read: function (cb) {
        gpioA3.read(function (state) {  // assume gpioA3 is a handle to your hardware
            cb(null, state);
        });
    }
});  // true

so.set('dOut', 2, 'dOutState', function (cb) {
    gpioA3.read(function (state) {
        cb(null, state);
    });
});  // throw Error, value cannot be a function

read(oid, iid, rid[, opt], callback)

Asynchronously read the specified Resource value.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.
opt (Object): An option used to read Resources in restrict mode, default is { restrict: false }. If it is given with { restrict: true }, this method will follow the access control specification defined by IPSO. This option may be set to true to respond to a remote read request (access from outside world should be under control).
callback (Function): function (err, data) { ... }. Will be called when reading is done or any error occurs, where data is the Resource value. (When an error occurs, so will pass you a string like '_notfound_' with data, you can use it as a hint to choose a status code to respond back to the requester.)

This table show you what results may the callback receive:

err	data	Description
Error object	`'_notfound_'`	Resource not found.
Error object	`'_unreadable_'`	Resource is unreadable.
Error object	`'_exec_'`	Resource is unreadable (Because it is an executable Resource).
`null`	Depends	Resource is successfully read.

Returns:

(none)

Examples:

so.read('temperature', 1, 'sensorValue', function (err, data) {
    if (!err)
        console.log(data);  // 18.4
});

so.read('actuation', 0, 'dimmer', function (err, data) {
    if (!err)
        console.log(data);  // 62
});

so.read('illuminance', 1, 'maxMeaValue', function (err, data) {
    if (err) {
        console.log(err);   //  Error: 'Resource is unreadable.'
        console.log(data);  // '_unreadable_'
    }
});

so.read('accelerometer', 2, 'minRangeValue', function (err, data) {
    if (err) {
        console.log(err);   //  Error: 'Resource not found.'
        console.log(data);  // '_notfound_'
    }
});

so.read('barometer', 6, 'resetMinMaxMeaValues', function (err, data) {
    if (err) {
        console.log(err);   //  Error: 'Resource is unreadable.'
        console.log(data);  // '_exec_'
    }
});

write(oid, iid, rid, value[, opt], callback)

Asynchronously write a value to the specified Resource.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.
value (Depends): The value to write to the specified Resource.
opt (Object): An option used to write Resources in restrict mode. Default is { restrict: false } if not given.
callback (Function): function (err, data) { ... }. Will be called when writing is done or any error occurs, where data is the Resource value written. (When an error occurs, so will pass you a string like '_notfound_' with data, you can use it as a hint to choose a status code to respond back to the requester.)

This table show you what results may the callback receive:

err	data	Description
Error object	`'_notfound_'`	Resource not found.
Error object	`'_unwritable_'`	Resource is unwritable.
Error object	`'_exec_'`	Resource is unwritable (Because it is an executable Resource).
`null`	Depends	Resource is successfully write.

Returns:

(none)

Examples:

so.write('actuation', 0, 'onOff', 1, function (err, data) {
    if (!err)
        console.log(data);  // 1
});

so.write('temperature', 1, 'sensorValue', 26, function (err, data) {
    if (err) {
        console.log(err);   // Error: 'Resource is unwritable.'
        console.log(data);  // _unwritable_
    }
});

so.write('presence', 3, 'busyToClearDelay', function (err, data) {
    if (err) {
        console.log(err);   //  Error: 'Resource not found.'
        console.log(data);  // '_notfound_'
    }
});

so.write('barometer', 6, 'resetMinMaxMeaValues', function (err, data) {
    if (err) {
        console.log(err);   //  Error: 'Resource is unwritable.'
        console.log(data);  // '_exec_'
    }
});

exec(oid, iid, rid, args, callback)

Execute the specified Resource. The executable Resource is a procedure you've defined, for example, blinking a led for N times when the Resource is invoked.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.
args (Array): The parameters required by the procedure.
callback (Function): function (err, data) { ... }. Will be called when execution is performed or any error occurs, where data is anything your procedure like to return back. For example, when a blinking led procedure starts, you may like to return an object { status: 'ok', led: 6, times: 10 } to the callback to tell something about this execution.

This table show you what results may the callback receive:

err	data	Description
Error object	`'_notfound_'`	Resource not found.
Error object	`'_unexecutable_'`	Resource is unexecutable.
Error object	`'_badarg_'`	Input arguments is not an array.
`null`	Depends	Resource is successfully executed, `data` depends on your will.

Returns:

(none)

Examples:

// Assume we have initialized an Object Instance like this:
so.init('foo_object', 0, {
    foo: 60,
    bar: 'hello',
    blink: {
        exec: function (args, cb) {
            var ledPin = args[0],
                times = args[1];

            myHardwareController.blinkLed(ledPin, times, function (err) {
                if (err)
                    cb(err);
                else
                    cb(null, { status: 'ok', led: ledPin, times: times });
            });
        }
    }
});

// Execute the blink Resource on it
so.exec('foo_object', 0, 'blink', [ 3, 10 ], function (err, data) {
    if (!err)
        console.log(data);  // { status: 'ok', led: 3, times: 10 }
});

// Execute a Resource that doesn't exist
so.exec('foo_object', 0, 'show', [], function (err, data) {
    if (err) {
        console.log(err);   // Error: 'Resource not found.'
        console.log(data);  // '_notfound_'
    }
});

dump([oid[, iid]][, opt], callback)

Asynchronously dump data from so. This method uses the asynchronous read() under the hood.

Given with oid, iid, and a callback to dump data of an Object Instance.
- dump(oid, iid, function (err, data) {})
- dump(oid, iid, { restrict: true }, function (err, data) {})
Given with oid and a callback to dump data of an Object.
- dump(oid, function (err, data) {})
- dump(oid, { restrict: true }, function (err, data) {})
Given with only a callback to dump data of whole smart object.
- dump(function (err, data) {})
- dump({ restrict: true }, function (err, data) {})

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
opt (Object): An option used to dump Resources in restrict mode. Default is { restrict: false } if not given.
callback (Function): function (err, data) { }.

Returns:

(none)

Examples:

// Dump Object Instance: 'temperature' sensor with iid = 18
so.dump('temperature', 18, function (err, data) {
    if (!err)
        console.log(data);
    /*
    {
        sensorValue: 301,
        units : 'K'
    }
    */
});

// Dump Object: all 'temperature' sensors
so.dump('temperature', function (err, data) {
    if (!err)
        console.log(data);
    /*
    {
        '0': {
            sensorValue: 31,
            units : 'C'
        },
        '1': {
            sensorValue: 75,
            units : 'F'
        },
        '18': {
            sensorValue: 301,
            units : 'K'
        }
    }
    */
});

// Dump whole smart object
so.dump(function (err, data) {
    if (!err)
        console.log(data);
    /*
    {
        temperature: {
            '0': {
                sensorValue: 31,
                units : 'C'
            },
            '1': {
                sensorValue: 75,
                units : 'F'
            },
            '18': {
                sensorValue: 301,
                units : 'K'
            }
        }
    }
    */
});

dumpSync([oid[, iid]])

Synchronously dump data from so. This method uses the synchronous get() under the hood. This method should only be used at server-side (since at server-side, all stored Objects are simply data pieces).

Given with both oid and iid to dump data of an Object Instance.
Given with only oid to dump data of an Object.
Given with no ids to dump data of whole Smart Object.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.

Returns:

(Object): The dumped data, can be from an Object Instance, an Object, or whole smart object.

Examples:

Example at client-side

// Dump Object: all 'temperature' sensors
so.dumpSync('temperature');
/*
{
    '0': {
        sensorValue: 31,
        units : 'C'
    },
    '1': {
        sensorValue: {
            read: '_read_'  // a read method will be dumped to a string '_read_'
        },
        units : 'F'
    },
    '18': {
        sensorValue: 301,
        units : 'K'
    }
}
*/

Examples at server-side

// Assume we are at server-side.
var myDevice = myController.find('0x12AE3B4D77886644'); // find the device
var so = myDevice.getSmartObject();                     // get the smart object on the device

// Dump Object Instance: 'temperature' sensor with iid = 18
so.dumpSync('temperature', 18);
/*
{
    sensorValue: 301,
    units : 'K'
}
*/

// Dump Object: all 'temperature' sensors
so.dumpSync('temperature');
/*
{
    '0': {
        sensorValue: 31,
        units : 'C'
    },
    '1': {
        sensorValue: 75,
        units : 'F'
    },
    '18': {
        sensorValue: 301,
        units : 'K'
    }
}
*/

// Dump whole smart object
so.dumpSync();
/*
{
    temperature: {
        '0': {
            sensorValue: 31,
            units : 'C'
        },
        '1': {
            sensorValue: 75,
            units : 'F'
        },
        '18': {
            sensorValue: 301,
            units : 'K'
        }
    },
    ...
}
*/

isReadable(oid, iid, rid)

To see if a Resource is readable.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.

Returns:

(Boolean): Returns true if the Resource is readable, otherwise false.

Examples:

so.isReadable('temperature', 8, 'sensorValue');     // true

isWritable(oid, iid, rid)

To see if a Resource is writable.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.

Returns:

(Boolean): Returns true if the Resource is writable, otherwise false.

Examples:

so.isWritable('temperature', 8, 'sensorValue');     // false

isExecutable(oid, iid, rid)

To see if a Resource is executable.

Arguments:

oid (String | Number): Object Id of the target.
iid (String | Number): Object Instance Id of the target.
rid (String | Number): Resource Id of the target.

Returns:

(Boolean): Returns true if the Resource is executable, otherwise false.

Examples:

so.isExecutable('temperature', 8, 'sensorValue');   // false

Awesome

smartobject

Table of Contents

1. Overview

2. Installation

3. Usage

4. Resources Planning

5. APIs

SmartObject Class

new SmartObject([hal][, setup])

init(oid, iid, resrcs[, setup])

remove(oid, iid)

objectList()

has(oid[, iid[, rid]])

get(oid, iid, rid)

set(oid, iid, rid, value)

read(oid, iid, rid[, opt], callback)

write(oid, iid, rid, value[, opt], callback)

exec(oid, iid, rid, args, callback)

dump([oid[, iid]][, opt], callback)

dumpSync([oid[, iid]])

isReadable(oid, iid, rid)

isWritable(oid, iid, rid)

isExecutable(oid, iid, rid)