1. module onoff
   1. function onoff.Gpio (gpio, direction, edge, options)
   2. object onoff.Gpio.prototype
   3. string onoff.version
2. module onoff.Gpio
   1. function onoff.Gpio (gpio, direction, edge, options)
3. module onoff.Gpio.prototype
   1. function onoff.Gpio.prototype.activeLow ()
   2. function onoff.Gpio.prototype.direction ()
   3. function onoff.Gpio.prototype.edge ()
   4. function onoff.Gpio.prototype.options ()
   5. function onoff.Gpio.prototype.read (callback)
   6. function onoff.Gpio.prototype.readSync ()
   7. function onoff.Gpio.prototype.setActiveLow (invert)
   8. function onoff.Gpio.prototype.setDirection (direction)
   9. function onoff.Gpio.prototype.setEdge (edge)
   10. function onoff.Gpio.prototype.unexport ()
   11. function onoff.Gpio.prototype.unwatch (callback)
   12. function onoff.Gpio.prototype.unwatchAll ()
   13. function onoff.Gpio.prototype.watch (callback)
   14. function onoff.Gpio.prototype.write (value, callback)
   15. function onoff.Gpio.prototype.writeSync (value)

module onoff

function onoff.Gpio (gpio, direction, edge, options)

• description and source-code

  function Gpio(gpio, direction, edge, options) {
    var valuePath,
      directionSet = false,
      tries = 0;
  
    if (!(this instanceof Gpio)) {
      return new Gpio(gpio, direction, edge, options);
    }
  
    if (typeof edge === 'object' && !options) {
      options = edge;
      edge = undefined;
    }
  
    options = options || {};
  
    this.gpio = gpio;
    this.gpioPath = GPIO_ROOT_PATH + 'gpio' + this.gpio + '/';
    this.opts = {};
    this.opts.debounceTimeout = options.debounceTimeout || 0;
    this.readBuffer = new Buffer(16);
    this.listeners = [];
  
    valuePath = this.gpioPath + 'value';
  
    if (!fs.existsSync(this.gpioPath)) {
      // The pin hasn't been exported yet so export it.
      fs.writeFileSync(GPIO_ROOT_PATH + 'export', this.gpio);
  
      // A hack to avoid the issue described here:
      // https://github.com/raspberrypi/linux/issues/553
      // I don't like this solution, but it enables compatibility with older
      // versions of onoff, i.e., the Gpio constructor was and still is
      // synchronous.
      directionSet = false;
      while (!directionSet) {
        try {
          tries += 1;
          fs.writeFileSync(this.gpioPath + 'direction', direction);
          directionSet = true;
        } catch (e) {
          if (tries === 10000) {
            throw e;
          }
        }
      }
  
      if (edge) {
        fs.writeFileSync(this.gpioPath + 'edge', edge);
      }
  
      if (!!options.activeLow) {
        fs.writeFileSync(this.gpioPath + 'active_low', ONE);
      }
    } else {
      // The pin has already been exported, perhaps by onoff itself, perhaps
      // by quick2wire gpio-admin on the Pi, perhaps by the WiringPi gpio
      // utility on the Pi, or perhaps by something else. In any case, an
      // attempt is made to set the direction and edge to the requested
      // values here. If quick2wire gpio-admin was used for the export, the
      // user should have access to both direction and edge files. This is
      // important as gpio-admin sets niether direction nor edge. If the
      // WiringPi gpio utility was used, the user should have access to edge
      // file, but not the direction file. This is also ok as the WiringPi
      // gpio utility can set both direction and edge. If there are any
      // errors while attempting to perform the modifications, just keep on
      // truckin'.
      try {
        fs.writeFileSync(this.gpioPath + 'direction', direction);
      } catch (ignore) {
      }
      try {
        if (edge) {
          fs.writeFileSync(this.gpioPath + 'edge', edge);
        }
        try {
          fs.writeFileSync(this.gpioPath + 'active_low',
            !!options.activeLow ? ONE : ZERO
          );
        } catch (ignore) {
        }
      } catch (ignore) {
      }
    }
  
    this.valueFd = fs.openSync(valuePath, 'r+'); // Cache fd for performance.
  
    // Read current value before polling to prevent unauthentic interrupts.
    this.readSync();
  
    this.poller = new Epoll(pollerEventHandler.bind(this));
  }

• example usage

  n/a

module onoff.Gpio

function onoff.Gpio (gpio, direction, edge, options)

• description and source-code

  function Gpio(gpio, direction, edge, options) {
    var valuePath,
      directionSet = false,
      tries = 0;
  
    if (!(this instanceof Gpio)) {
      return new Gpio(gpio, direction, edge, options);
    }
  
    if (typeof edge === 'object' && !options) {
      options = edge;
      edge = undefined;
    }
  
    options = options || {};
  
    this.gpio = gpio;
    this.gpioPath = GPIO_ROOT_PATH + 'gpio' + this.gpio + '/';
    this.opts = {};
    this.opts.debounceTimeout = options.debounceTimeout || 0;
    this.readBuffer = new Buffer(16);
    this.listeners = [];
  
    valuePath = this.gpioPath + 'value';
  
    if (!fs.existsSync(this.gpioPath)) {
      // The pin hasn't been exported yet so export it.
      fs.writeFileSync(GPIO_ROOT_PATH + 'export', this.gpio);
  
      // A hack to avoid the issue described here:
      // https://github.com/raspberrypi/linux/issues/553
      // I don't like this solution, but it enables compatibility with older
      // versions of onoff, i.e., the Gpio constructor was and still is
      // synchronous.
      directionSet = false;
      while (!directionSet) {
        try {
          tries += 1;
          fs.writeFileSync(this.gpioPath + 'direction', direction);
          directionSet = true;
        } catch (e) {
          if (tries === 10000) {
            throw e;
          }
        }
      }
  
      if (edge) {
        fs.writeFileSync(this.gpioPath + 'edge', edge);
      }
  
      if (!!options.activeLow) {
        fs.writeFileSync(this.gpioPath + 'active_low', ONE);
      }
    } else {
      // The pin has already been exported, perhaps by onoff itself, perhaps
      // by quick2wire gpio-admin on the Pi, perhaps by the WiringPi gpio
      // utility on the Pi, or perhaps by something else. In any case, an
      // attempt is made to set the direction and edge to the requested
      // values here. If quick2wire gpio-admin was used for the export, the
      // user should have access to both direction and edge files. This is
      // important as gpio-admin sets niether direction nor edge. If the
      // WiringPi gpio utility was used, the user should have access to edge
      // file, but not the direction file. This is also ok as the WiringPi
      // gpio utility can set both direction and edge. If there are any
      // errors while attempting to perform the modifications, just keep on
      // truckin'.
      try {
        fs.writeFileSync(this.gpioPath + 'direction', direction);
      } catch (ignore) {
      }
      try {
        if (edge) {
          fs.writeFileSync(this.gpioPath + 'edge', edge);
        }
        try {
          fs.writeFileSync(this.gpioPath + 'active_low',
            !!options.activeLow ? ONE : ZERO
          );
        } catch (ignore) {
        }
      } catch (ignore) {
      }
    }
  
    this.valueFd = fs.openSync(valuePath, 'r+'); // Cache fd for performance.
  
    // Read current value before polling to prevent unauthentic interrupts.
    this.readSync();
  
    this.poller = new Epoll(pollerEventHandler.bind(this));
  }

• example usage

  n/a

module onoff.Gpio.prototype

function onoff.Gpio.prototype.activeLow ()

• description and source-code

  activeLow = function () {
    return fs.readFileSync(
      this.gpioPath + 'active_low')[0] === ONE[0] ? true : false;
  }

• example usage

  ...
   * resistor and GPIO #8 is wired to the other end of the resistor.
   */
  var Gpio = require('../onoff').Gpio,
    assert = require('assert'),
    input = new Gpio(7, 'in'),
    output = new Gpio(8, 'out', {activeLow: true});
  
  assert(input.activeLow() === false);
  assert(output.activeLow() === true);
  output.writeSync(0);
  assert(input.readSync() === 1);
  output.writeSync(1);
  assert(input.readSync() === 0);
  
  output.setActiveLow(false);
  ...

function onoff.Gpio.prototype.direction ()

• description and source-code

  direction = function () {
    return fs.readFileSync(this.gpioPath + 'direction').toString().trim();
  }

• example usage

  ...
  
  "use strict";
  
  var Gpio = require('../onoff').Gpio,
    assert = require('assert'),
    input = new Gpio(4, 'in', 'rising');
  
  assert(input.direction() === 'in');
  assert(input.edge() === 'rising');
  
  input.unexport();
  
  console.log('ok - ' + __filename);
  ...

function onoff.Gpio.prototype.edge ()

• description and source-code

  edge = function () {
    return fs.readFileSync(this.gpioPath + 'edge').toString().trim();
  }

• example usage

  ...
  "use strict";
  
  var Gpio = require('../onoff').Gpio,
    assert = require('assert'),
    input = new Gpio(4, 'in', 'rising');
  
  assert(input.direction() === 'in');
  assert(input.edge() === 'rising');
  
  input.unexport();
  
  console.log('ok - ' + __filename);
  ...

function onoff.Gpio.prototype.options ()

• description and source-code

  options = function () {
    return this.opts;
  }

• example usage

  ...
  button = new Gpio(4, 'in', 'rising', {
    debounceTimeout : 250
  }),
  count = 0;
  
  assert(button.direction() === 'in');
  assert(button.edge() === 'rising');
  assert(button.options().debounceTimeout === 250);
  
  console.info('Please press button attached to GPIO #4 5 times...');
  
  button.watch(function (err, value) {
  if (err) {
    throw err;
  }
  ...

function onoff.Gpio.prototype.read (callback)

• description and source-code

  read = function (callback) {
    fs.read(this.valueFd, this.readBuffer, 0, 1, 0, function (err, bytes, buf) {
      if (typeof callback === 'function') {
        if (err) {
          return callback(err);
        }
  
        callback(null, buf[0] === ONE[0] ? 1 : 0);
      }
    });
  }

• example usage

  ...
  
  /**
   * Read GPIO value asynchronously.
   *
   * [callback: (err: error, value: number) => {}] // Optional callback
   */
  Gpio.prototype.read = function (callback) {
    fs.read(this.valueFd, this.readBuffer, 0, 1, 0, function (err, bytes, buf) {
  if (typeof callback === 'function') {
    if (err) {
      return callback(err);
    }
  
    callback(null, buf[0] === ONE[0] ? 1 : 0);
  }
  ...

function onoff.Gpio.prototype.readSync ()

• description and source-code

  readSync = function () {
    fs.readSync(this.valueFd, this.readBuffer, 0, 1, 0);
    return this.readBuffer[0] === ONE[0] ? 1 : 0;
  }

• example usage

  ...
  var GPIO_ROOT_PATH = '/sys/class/gpio/',
  ZERO = new Buffer('0'),
  ONE = new Buffer('1');
  
  exports.version = '1.1.1';
  
  function pollerEventHandler(err, fd, events) {
  var value = this.readSync(),
    callbacks = this.listeners.slice(0);
  
  if (this.opts.debounceTimeout > 0) {
    setTimeout(function () {
      if (this.listeners.length > 0) {
        // Read current value before polling to prevent unauthentic interrupts.
        this.readSync();
  ...

function onoff.Gpio.prototype.setActiveLow (invert)

• description and source-code

  setActiveLow = function (invert) {
    fs.writeFileSync(this.gpioPath + 'active_low', !!invert ? ONE : ZERO);
  }

• example usage

  ...
  assert(input.activeLow() === false);
  assert(output.activeLow() === true);
  output.writeSync(0);
  assert(input.readSync() === 1);
  output.writeSync(1);
  assert(input.readSync() === 0);
  
  output.setActiveLow(false);
  assert(input.activeLow() === false);
  assert(output.activeLow() === false);
  output.writeSync(0);
  assert(input.readSync() === 0);
  output.writeSync(1);
  assert(input.readSync() === 1);
  ...

function onoff.Gpio.prototype.setDirection (direction)

• description and source-code

  setDirection = function (direction) {
    fs.writeFileSync(this.gpioPath + 'direction', direction);
  }

• example usage

  n/a

function onoff.Gpio.prototype.setEdge (edge)

• description and source-code

  setEdge = function (edge) {
    fs.writeFileSync(this.gpioPath + 'edge', edge);
  }

• example usage

  n/a

function onoff.Gpio.prototype.unexport ()

• description and source-code

  unexport = function () {
    this.unwatchAll();
    fs.closeSync(this.valueFd);
    try {
      fs.writeFileSync(GPIO_ROOT_PATH + 'unexport', this.gpio);
    } catch (ignore) {
      // Flow of control always arrives here when cape_universal is enabled on
      // the bbb.
    }
  }

• example usage

  ...
      throw err;
    }
  
    led.writeSync(value);
  });
  
  process.on('SIGINT', function () {
    led.unexport();
    button.unexport();
  });
  ```
  
  ## How does it work?
  
  Internally onoff uses sysfs files located at /sys/class/gpio to access GPIOs
  ...

function onoff.Gpio.prototype.unwatch (callback)

• description and source-code

  unwatch = function (callback) {
    if (this.listeners.length > 0) {
      if (typeof callback !== 'function') {
        this.listeners = [];
      } else {
        this.listeners = this.listeners.filter(function (listener) {
          return callback !== listener;
        });
      }
  
      if (this.listeners.length === 0) {
        this.poller.remove(this.valueFd);
      }
    }
  }

• example usage

  ...
   }
  };
  
  /**
  * Remove all watchers for the GPIO.
  */
  Gpio.prototype.unwatchAll = function () {
   this.unwatch();
  };
  
  /**
  * Get GPIO direction.
  *
  * Returns - string // 'in', or 'out'
  */
  ...

function onoff.Gpio.prototype.unwatchAll ()

• description and source-code

  unwatchAll = function () {
    this.unwatch();
  }

• example usage

  ...
  };
  
  /**
   * Reverse the effect of exporting the GPIO to userspace. The Gpio object
   * should not be used after calling this method.
   */
  Gpio.prototype.unexport = function () {
  this.unwatchAll();
  fs.closeSync(this.valueFd);
  try {
    fs.writeFileSync(GPIO_ROOT_PATH + 'unexport', this.gpio);
  } catch (ignore) {
    // Flow of control always arrives here when cape_universal is enabled on
    // the bbb.
  }
  ...

function onoff.Gpio.prototype.watch (callback)

• description and source-code

  watch = function (callback) {
    var events;
  
    this.listeners.push(callback);
  
    if (this.listeners.length === 1) {
      events = Epoll.EPOLLPRI;
      if (this.opts.debounceTimeout > 0) {
        events |= Epoll.EPOLLONESHOT;
      }
      this.poller.add(this.valueFd, events);
    }
  }

• example usage

  ...
  should turn off. This can be achieved with the following code:
  
  ```js
  var Gpio = require('onoff').Gpio,
    led = new Gpio(14, 'out'),
    button = new Gpio(4, 'in', 'both');
  
  button.watch(function(err, value) {
    led.writeSync(value);
  });
  ```
  
  Here two Gpio objects are being created. One called led for the LED on GPIO #14
  which is an output, and one called button for the momentary push button on
  GPIO #4 which is an input. In addition to specifying that the button is an
  ...

function onoff.Gpio.prototype.write (value, callback)

• description and source-code

  write = function (value, callback) {
    var writeBuffer = value === 1 ? ONE : ZERO;
    fs.write(this.valueFd, writeBuffer, 0, writeBuffer.length, 0, callback);
  }

• example usage

  ...
  * Write GPIO value asynchronously.
  *
  * value: number                  // 0 or 1
  * [callback: (err: error) => {}] // Optional callback
  */
  Gpio.prototype.write = function (value, callback) {
   var writeBuffer = value === 1 ? ONE : ZERO;
   fs.write(this.valueFd, writeBuffer, 0, writeBuffer.length, 0, callback);
  };
  
  /**
  * Write GPIO value synchronously.
  *
  * value: number // 0 or 1
  */
  ...

function onoff.Gpio.prototype.writeSync (value)

• description and source-code

  writeSync = function (value) {
    var writeBuffer = value === 1 ? ONE : ZERO;
    fs.writeSync(this.valueFd, writeBuffer, 0, writeBuffer.length, 0);
  }

• example usage

  ...
  /**
  * Write GPIO value synchronously.
  *
  * value: number // 0 or 1
  */
  Gpio.prototype.writeSync = function (value) {
   var writeBuffer = value === 1 ? ONE : ZERO;
   fs.writeSync(this.valueFd, writeBuffer, 0, writeBuffer.length, 0);
  };
  
  /**
  * Watch for hardware interrupts on the GPIO. Inputs and outputs can be
  * watched. The edge argument that was passed to the constructor determines
  * which hardware interrupts are watcher for.
  *
  ...