RFID.js

+(function (global, factory) {
    if (typeof exports === 'undefined') {
      factory(global.webduino || {});
    } else {
      module.exports = factory;
    }
  }(this, function (scope) {
    'use strict';
  
    var Module = scope.Module,
      BoardEvent = scope.BoardEvent,
      proto;
  
    var RFIDEvent = {
  
      /**
       * Fires when the RFID entered.
       *
       * @event RFIDEvent.ENTER
       */
      ENTER: 'enter',
  
      /**
       * Fires when the RFID leaved.
       *
       * @event RFIDEvent.LEAVE
       */
      LEAVE: 'leave'
    };
  
    /**
     * The RFID class.
     *
     * RFID reader is used to track nearby tags by wirelessly reading a tag's unique ID.
     *
     * @namespace webduino.module
     * @class RFID
     * @constructor
     * @param {webduino.Board} board Board that the RFID is attached to.
     * @extends webduino.Module
     */
    function RFID(board) {
      Module.call(this);
  
      this._board = board;
      this._isReading = false;
      this._enterHandlers = [];
      this._leaveHandlers = [];
  
      this._messageHandler = onMessage.bind(this);
      this._board.on(BoardEvent.BEFOREDISCONNECT, this.destroy.bind(this));
      this._board.on(BoardEvent.ERROR, this.destroy.bind(this));
      this._board.send([0xf0, 0x04, 0x0f, 0x00, 0xf7]);
    }
  
    function onMessage(event) {
      var _this = this;
      var msg = event.message;
      var val;
      if (!msg.length || msg[0] == 0x4) {
        return false;
      }
  
      if (msg.length === 1) {
        _this._leaveHandlers.forEach(function (fn) {
          fn.call(_this, val);
        });
        _this.emit(RFIDEvent.LEAVE, val);
        val = null;
      } else {
        val = String.fromCharCode.apply(null, msg);
        _this._enterHandlers.forEach(function (fn) {
          fn.call(_this, val);
        });
        _this.emit(RFIDEvent.ENTER, val);
      }
    }
  
    RFID.prototype = proto = Object.create(Module.prototype, {
      constructor: {
        value: RFID
      },
  
      /**
       * The state indicating whether the module is reading.
       *
       * @attribute isReading
       * @type {Boolean} isReading
       * @readOnly
       */
      isReading: {
        get: function () {
          return this._isReading;
        }
      }
    });
  
    /**
     * Start reading RFID.
     *
     * @method read
     * @param {Function} [enterHandler] Callback when RFID entered.
     * @param {Function} [leaveHandler] Callback when RFID leaved.
     */
    proto.read = function (enterHandler, leaveHandler) {
      if (!this._isReading) {
        this._board.send([0xf0, 0x04, 0x0f, 0x01, 0xf7]);
        this._board.on(BoardEvent.SYSEX_MESSAGE, this._messageHandler);
        this._isReading = true;
      }
  
      if (typeof enterHandler === 'function') {
        this._enterHandlers.push(enterHandler);
      }
  
      if (typeof leaveHandler === 'function') {
        this._leaveHandlers.push(leaveHandler);
      }
    };
  
    /**
     * Stop reading RFID.
     *
     * @method stopRead
     */
    proto.stopRead = function () {
      if (this._isReading) {
        this._board.send([0xf0, 0x04, 0x0f, 0x02, 0xf7]);
        this._board.removeListener(BoardEvent.SYSEX_MESSAGE, this._messageHandler);
        this._isReading = false;
        this._enterHandlers = [];
        this._leaveHandlers = [];
      }
    };
  
    /**
     * Remove listener.
     *
     * @method off
     * @param {String} evtType Type of event.
     * @param {Function} handler Callback function.
     */
    proto.off = function (evtType, handler) {
      this.removeListener(evtType, handler);
    };
  
    /**
     * Stop reading RFID and remove all listeners.
     *
     * @method destroy
     */
    proto.destroy = function () {
      this.stopRead();
      this.removeAllListeners(RFIDEvent.ENTER);
      this.removeAllListeners(RFIDEvent.LEAVE);
    };
  
    scope.module.RFIDEvent = RFIDEvent;
    scope.module.RFID = RFID;
  }));