Texas Instruments’ Beagle boards, BeagleBone, BeagleBone Black, and BeagleBoard MX, based on TI’s ARM AM335x, AM35x, and AM37x processors, are embedded Linux boards designed for hobbyist projects. They’re compact, inexpensive, and the hardware designs are all available openly on the Web. They also come with a customized version of the Ångström Linux distribution for embedded development, but can run Ubuntu, Android, and other distributions as well. For the examples that follow, we recommend the BeagleBone Black.

The Raspberry Pi Foundation’s boards, model A and model B, are based on an ARM processor by Broadcom. Unlike the BeagleBone, the designs for the Pi are not open to the general public, but installation and purchase information can be found on the foundation’s website. The Pi models run a custom version of the Debian Linux distribution called Raspbian. For the examples in this book, we used Adafruit’s version of Raspbian called Occidentalis. Like the BeagleBoard boards, the Pi can run other embedded Linux distributions. The model A shipped after the model B and is the stripped-down version: one USB port, no Ethernet, half the memory. For best results, you want a model B.

Other than the sites listed previously, you can find material for getting started with the Raspberry Pi or the BeagleBone Black at Adafruit’s tutorials site. The books Getting Started with Raspberry Pi by Matt Richardson and Shawn Wallace, and Getting Started with BeagleBone by Matt Richardson, are also good introductions.

Since there are no embedded Linux boards on the market at the moment with built-in NFC, you’ll need a separate NFC controller. You could use the PN532 shields, but they’re not designed to interface with the BeagleBone or the Pi, so a USB-based module is easier to use. For this chapter, we chose the Identive SLC3711 Contactless USB Smart Card Reader. It works with many of the libraries we examined because it’s got a PN532 NFC controller as its heart.

There are a handful of NFC libraries available, in varying states of completeness. The best one as of this writing is libnfc, available from NFC Tools. Libnfc is a low-level library for NFC. It supports the control protocols ISO14443A and -B (used by most of the tag types), ISO-18092 (the protocol used for peer-to-peer) and JIS-X-6319-4 (used by FeliCa smart cards).

Libnfc’s roadmap for the project is quite helpful in understanding how it’s developed, and where it’s headed. It can be found on the libnfc Roadmap page. The layered abstraction model is based on NFC’s abstraction model, and leaves a lot of room for the project to increase in compatibility with other readers and in higher level functionality.

There are a few useful subprojects based on libnfc, including libfreefare, which adds an API for reading from and writing to Mifare tags. Libfreefare is available on the NFC Tools site. There is also an implementation of LLCP for libnfc. Libfreefare only offers limited support for NFC Forum tag types. It’s fully compatible with Mifare Classic tags, but as of this writing, it doesn’t offer support for all four NFC forum tag types. Its architecture could support them, however, when an enterprising programmer submits a patch to add that support.

Libnfc is cross-platform and will run on Windows, OS X, and other POSIX systems, including the various Linux distributions. You’ll see how it works on the Raspberry Pi and BeagleBone, but it should work fine on other embedded Linux boards as well.

We’ve built a Node.js library that uses libnfc and libfreefare to read to and write from Mifare Classic tags. At this point, like libfreefare, it does not offer support for the NFC Forum tag types (though patches are welcome). You’ll see this later on, but first, you need to install libnfc and libfreefare, and learn a little bit more about them.

Before you install any NFC-specific tools, there are some housekeeping tasks you should take care of first. These are necessary tasks that you might overlook if you do them midstream, but if you do them at the start, things will go much smoother.

$ sudo apt-get update

$ opkg update

$ ntpdate -b -s -u pool.ntp.org

$ cd ~
$ mkdir downloads
$ cd downloads

$ sudo apt-get install autoconf automake libtool libusb-1.0-0-dev

$ opkg install autoconf automake libtool libusb-1.0-dev

$ opkg install ca-certificates

$ git config --global http.sslCAinfo /etc/ssl/certs/ca-certificates.crt

$ for i in 192.168.1.{1..254}; do ping -c 1 -W 3 $i & > /dev/null; done
$ netstat -nr -f inet | grep -i "b8:27"

$ ssh pi@ip-address

$ cd ~/downloads
$ curl -O http://nodejs.org/dist/v0.10.12/node-v0.10.12-linux-arm-pi.tar.gz 
$ cd /usr/local
$ sudo tar xzf ~/downloads/node-v0.10.12-linux-arm-pi.tar.gz 
$ cd bin
$ sudo ln -s ../node-v0.10.12-linux-arm-pi/bin/node 
$ sudo ln -s ../node-v0.10.12-linux-arm-pi/bin/npm

To install the libraries for the projects in this chapter, you’ll need to make sure your board has Internet access. You’ll also need a few software libraries:

These libraries all depend on each other, so the order in which you install them is important, as you’ll see. Once they’re all installed, you’ll be able to read from and write to your NFC reader. The installation details are similar on the BeagleBone and the Raspberry Pi, and the differences are noted.

Since you know that the NFC adapter you’re using connects via USB, you might not be surprised to learn that libnfc and libfreefare depend on a USB library, libusb. Installing these libraries starts with libusb.

$ cd ~/downloads
$ wget http://sourceforge.net/projects/libusb/files/
   libusb-compat-0.1/libusb-compat-0.1.5/libusb-compat-0.1.5.tar.bz2
$ tar xjf libusb-compat-0.1.5.tar.bz2
$ cd libusb-compat-0.1.5
$ ./configure
$ make
$ make install 

$ cd ~/downloads
$ git clone https://code.google.com/p/libnfc/
$ cd libnfc
$ autoreconf -vis
$ export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig 
$ ./configure
$ make
$ make install 

$ sudo ldconfig

$ sudo nano /etc/modprobe.d/blacklist-libnfc.conf

    blacklist pn533
    blacklist nfc

$ sudo cp contrib/udev/42-pn53x.rules /lib/udev/rules.d/

$ nano /etc/modprobe.d/nfc.conf

install pn533 /bin/true
install nfc /bin/true

$ nfc-list

nfc-list uses libnfc libnfc-1.7.0-rc7-40-gbb5b712
NFC device: SCM Micro / SCL3711-NFC&RW opened

$ cd ~/downloads
$ git clone https://code.google.com/p/libfreefare/
$ cd libfreefare
$ autoreconf -vis
$ ./configure
$ make
$ make install 
$ sudo ldconfig 

Libnfc provides some command line tools which you can find in the utils/ directory. These give you the tools to do a lot of low-level NFC tasks:

The most interesting tool of the lot is nfc-mfclassic, which will read a tag and dump the contents to a file. It gives you the raw byte stream from the tag, not differentiating between what’s content and what’s metadata at all. Plug in NFC reader and place it close to a Mifare Classic tag. The command works like this, producing the following output:

$  nfc-mfclassic r b dump.mfd

NFC reader: SCM Micro / SCL3711-NFC&RW opened
Found MIFARE Classic card:
ISO/IEC 14443A (106 kbps) target:
    ATQA (SENS_RES): 00  04
       UID (NFCID1): 2d  10  18  07
      SAK (SEL_RES): 08
Guessing size: seems to be a 1024-byte card
Reading out 64 blocks |.......................................|
Done, 64 of 64 blocks read.
Writing data to file: dump.mfd ...Done.

The arguments for nfc-classic are:

This and all the libnfc utilities are relatively low-level tools. Libfreefare provides some slightly higher level tools. It can read, write, and format Mifare Classic, Ultralight, and DESFire tags. It can read and write NDEF messages to these tags as well. The examples for libfreefare, written in C, can be found in the examples/ subdirectory of the libfreefare directory:

As an example, here’s the mifare-classic-format command in action:

$ mifare-classic-format

Found Mifare Classic 1k with UID 6b57ee65. Format [yN] y
Formatting 16 sectors [...4...8...12...16] done.

One of the handy things you can do with libfreefare is to copy a tag. To do this, you read a tag, dump the results to a file on your board, and then write the file to another tag. Here’s how to write it to a file called ndef.bin:

$ mifare-classic-read-ndef -o ndef.bin

When the tag is written successfully, you can look at it with the xxd command. You may recognize the NDEF message from a previous chapter:

$ xxd ndef.bin

0000000: d101 3055 036d 2e66 6f75 7273 7175 6172  ..0U.m.foursquar
0000010: 652e 636f 6d2f 7665 6e75 652f 3461 3931  e.com/venue/4a91
0000020: 3735 3633 6639 3634 6135 3230 3430 3161  7563f964a520401a
0000030: 3230 6533                                20e3

Once you’ve got a file, you can write the message to another tag like so:

$ mifare-classic-write-ndef -i ndef.bin

Libfreefare provides the basis for the highest level tool in this chapter, the mifare-classic-js and ndef-js packages for Node.js.

In order to give you a high-level tool to read and write NDEF messages, we’ve built two packages for Node.js to do this, ndef and mifare-classic. Using these packages, you can write node web apps like the one you wrote in Chapter 7. If you’re using a BeagleBone, you can also use these packages in combination with BoneScript, the BeagleBone’s Arduino-like JavaScript framework for controlling the physical I/O of the BeagleBone.

You can find the full sources for these two packages on GitHub, where Don has repositories for NDEF messages and Mifare classic tags. They’re both available through the node package manager npm as well, which is how you’ll load them for the following examples.

The NDEF package enables you to read and write NDEF messages in Node. The main functions in this package are encodeMessage(), for encoding an NDEF message into a byte stream to write to a tag, and decodeMessage(), which converts an incoming byte stream into an array of NDEF records. It contains most of the functions you’re familiar with from the NDEF object in the PhoneGap-NFC plug-in as well, as you’ll see in the examples that follow.

The mifare-classic package gives you a JavaScript interface to libfreefare. As such, it will only work with Mifare Classic tags, since it relies on libfreefare to do the reading. It has three functions as of this writing, read() and write() for reading and writing tags, and format(), which formats a tag as an NDEF tag.

There are a few basic examples included with both packages, in the examples/ directory. The steps to install and run these examples should be the same on the BeagleBone, Raspberry Pi, and other Linux-based boards, as long as you’ve installed libnfc and libfreefare successfully. You’ll use npm to install them after you make your project files.

Reading, writing, and formatting an NDEF-formatted tag is fairly simple using these two packages. To start with, make a new directory for your app and create a package.json file inside it:

$ cd ~
$ mkdir NodeNdefBasics
$ cd NodeNdefBasics
$ nano package.json

When nano’s open and ready for editing, add this to your file:

{
   "name": "NodeNdefBasics",
   "author": "Your Name",
   "version": "0.0.1",
   "description": "Read, write, or format a tag",
   "main": "read.js",
   "keywords": [
      "NDEF",
      "NFC"
   ],
   "dependencies" : {
      "mifare-classic": "0.0.1",
      "ndef"   :  ">=0.0.4"
   },
      "engines": {
      "node": ">=0.8"
   }
}

Press Ctrl-X and then press Y to save this file. Then open a new file, read.js:

var ndef = require('ndef'),               // require ndef package
    mifare = require('mifare-classic');   // require mifare-classic package

mifare.read(function(error, buffer) {     // read tag
    if (error) {                          // if there's an error result
        console.log("Read failed ");      // let user know about the error
        console.log(error);
    } else {                              // you got an NDEF message
        // decode the message into a JSON object:
        var message = ndef.decodeMessage(buffer.toJSON());
        // print the message's records:
        console.log("Found NDEF message with " + message.length +
            // add "record" if there's only one, "records" if there's more:
            (message.length === 1 ? " record" : " records" ));
        // print the message:
        console.log(ndef.stringify(message));
    }
});

As you can see, the mifare.read() function from the mifare-classic package has a success callback as its parameter. When it’s read a tag successfully, you can use the ndef.decodeMessage() function to convert the buffer to an array of NDEF records.

To install the ndef and mifare-classic packages, make sure you’re connected to the Internet and type:

$ npm install

Once the packages have installed successfully, place your reader about a centimeter from a tag that you’ve already written NDEF messages to, then type:

$ node read.js

After a second or so, you should get a reply like this:

Found Mifare Classic 1k with UID bb60ee65.
NFC Forum application contains a "NDEF Message TLV".
Found NDEF message with 2 records
URI Record
http://nfc-tools.org

Text Record
Hello from nodejs

Formatting using the mifare-classic package is very similar to formatting with libfreefare, as you might expect. The package is just a light wrapper around that library. Create a new file, format.js:

var mifare = require('mifare-classic');    // require mifare-classic

mifare.format(function(error) {           // format tag
    if (error) {                          // if there's an error,
        console.log("Format failed ");    // report the error
        console.log(error);
    } else {                              // if the format works out OK
        console.log("Tag formatted OK");  // report that
    }
});

Once you’ve installed with npm, place your reader near a tag you want to format, and run. You should get the following:

Found Mifare Classic 1k with UID 52d55be4.
Formatting 16 sectors [...4...8...12...16] done.
Tag formatted OK

It will take a few seconds to format, and if you move the reader before the formatting’s done, you’ll get an error, so hold still. Once it’s done, you’ve got a tag that’s ready for writing, so create a new file, write.js:

var ndef = require('ndef'),                  // require ndef package
    mifare = require('mifare-classic'),      // require this package
    message,                                 // an NDEF message
    bytes;                                   // the bytes stream to write

message = [
    ndef.uriRecord("http://nfc-tools.org"),  // make a URI record
    ndef.textRecord("Hello from nodejs"),    // make a text record
    ndef.emptyRecord()                       // make an empty record
];

bytes = ndef.encodeMessage(message);          // encode record as a byte stream

mifare.write(bytes, function(error) {        // write function
    if (error) {                             // if there's an error,
        console.log("Write failed ");        // report the error
        console.log(error);
    } else {
        console.log("Tag written successfully");// report that tag was written
    }
});

The full source code for these last three examples can be found on GitHub.

The mifare.write() function takes a byte stream and a callback function as parameters, like read(). If it succeeds, the callback doesn’t return anything. If there is an error, the callback returns that. When you install and run this with a tag in range, you should get the following if the write is successful:

NDEF file is 45 bytes long.
Found Mifare Classic 1k with UID 52d55be4.
Tag written successfully

If the tag isn’t written successfully, you’ll get something like this:

NDEF file is 45 bytes long.
Found Mifare Classic 1k with UID 52d55be4.
Write failed
mifare-classic-write-ndef: No known authentication key for sector 0x0e

mifare-classic-write-ndef: No known authentication key for sector 0x0a

mad_write: Mifare Authentication Failed

As with reading and formatting, the key to success is holding the tag near the reader and keeping it still while the write is in progress. If you read this with the reader example, you’ll get this output:

Found Mifare Classic 1k with UID 52d55be4.
NFC Forum application contains a "NDEF Message TLV".
Found NDEF message with 3 records
URI Record
http://nfc-tools.org

Text Record
Hello from nodejs

Empty Record

Now that you understand the main functions of these two node packages, it’s time for a few examples of what you can do with them.

Node.js works easily as a web server, as you saw in Chapter 7, so it makes sense to create a web interface for a tag writer with the packages you’ve just learned (this is a variation on A Browser Interface for the Arduino NDEF Writer Device). In fact, you can use the same index.html page from that project.

Start off by making the directory and the package.json file as usual:

$ cd ~
$ mkdir NodeNdefWriterWeb
$ cd NodeNdefWriterWeb
$ nano package.json

The main difference between this package file and the one for the writer script is the addition of express.js as a dependency:

{
  "name": "NodeNdefWriterWeb",
  "author": "username",
  "version": "0.0.2",
  "description": "Write a tag from a browser",
  "main": "index.js",
  "keywords": [
    "NDEF",
    "NFC"
  ],
   "dependencies" : {
    "express": ">=3.0",
    "mifare-classic": "0.0.1",
    "ndef"   :  ">=0.0.4"
  },
  "engines": {
    "node": ">=0.8"
  }
}

The index.js file is very similar to the index.js from A Browser Interface for the Arduino NDEF Writer Device, but with a few changes, noted at the end of this script:

/*
   NodeNdefWriterWeb.js

*/

var ndef = require('ndef'),               // require ndef package 
    mifare = require('mifare-classic'),   // require this package
    express = require('express'),               // make an instance of express
    app = express(),                            // start Express framework
    server = require('http').createServer(app), // start an HTTP server
    record = {},                                // NDEF record to send
    deviceMessage = "";                         // messages from writer device

app.use(express.bodyParser());        // use bodyParser middleware for express
server.listen(8080);                  // listen for incoming requests on server
console.log("Listening for new clients on port 8080");

// respond to web GET requests with the index.html page:
app.get('/*', function (request, response) {
  response.sendfile(__dirname + '/index.html');
});

// take anything that begins with /submit:
app.post('/submit', function (request, response) {
  var days = request.body.days,         // get the number of days from the body
      today = new Date(request.body.checkin),     // get the time from the body
      // calculate the checkout timeStamp:
      departure = new Date(today.valueOf() + (days * 86400000)),
      nfcResponse,                      // the response from the NFC reader
      message,                          // the NFC message to write
      bytes;                            // byte stream to write it with

  record.name = request.body.name;      // get the name from the body
  record.room = request.body.room;      // get the room number from the body
  // convert to unix time in seconds:
  record.checkin = Math.round(today.valueOf()/1000);
  record.checkout = Math.round(departure.valueOf()/1000);

   message = [
       ndef.textRecord(JSON.stringify(record)), // make a text record 
   ];
   bytes = ndef.encodeMessage(message);  // encode record as a byte stream

   mifare.write(bytes, function(error) { // write function 
       if (error) {                      // if there's an error,
           nfcResponse = "Write failed"; // report it
           nfcResponse += error;
       } else {
           nfcResponse = "Tag written successfully" + JSON.stringify(record);
       }
       console.log(nfcResponse);// report that the tag was written
       // write the HTML head back to the browser:
       response.writeHead(200, {'Content-Type': 'text/html'});
       // send the data:
       response.write("Wrote the following to the card:<br>");
       response.write(nfcResponse + "<p>");
       // send the link back to the index and close the link:
       response.end("<a href="/">Return to form</a>");
   });         // end of mifare.write()
});            // end of app.post()

The full source code can be found on GitHub.

The user interaction for this is identical to the browser interface project we mentioned before. You enter the data in the form, press the submit button while holding the guest’s card over the reader, and the NFC reader writes to the tag. You should get the NDEF record as a JSON string in the browser if the write succeeds, and a failure message if it doesn’t.

One of the more interesting things you can do with an embedded Linux board like the BeagleBone or the Raspberry Pi is to use its general purpose I/O (GPIO) pins to sense and control the physical world. These are the physical input and output pins of the board. The hotel door lock in Chapter 7 is one possible application of this. Rather than reading the guest’s door key card on the Arduino and opening the lock, you could read it on a BeagleBone or Raspberry Pi.

The following example shows the bare minimum to connect the mifare-classic and ndef-js packages with the GPIO of your board. It turns on LEDs connected to the board’s GPIO to indicate how many records are in the NDEF message read from a tag.

On the BeagleBone, you’ll use the BoneScript package, which gives you control of the GPIO pins using an API that’s similar in style to the Arduino API. On the Raspberry Pi, you’ll use the onoff npm package.

$ cd ~
$ mkdir NodeTagToLed
$ cd NodeTagToLed
$ nano package.json

{
  "name": "NodeTagToLed",
  "author": "username",
  "version": "0.0.1",
  "description": "Read a tag, light LEDs",
  "main": "index.js",
  "keywords": [
    "NDEF",
    "NFC",
    "Bonescript"
  ],
   "dependencies" : {
    "mifare-classic": "0.0.1",
    "ndef"   :  ">=0.0.4"
    // note: Bonescript is built into the BB distribution.
    // if you include it in your package.json, it will cause errors
  },
  "engines": {
    "node": ">=0.8"
  }
}

var ndef = require('ndef'),               // require ndef package
    mifare = require('mifare-classic'),   // require this package
    io = require('bonescript');           // bonescript is built into the BB 

io.pinMode('USR0', 'out');                // set LED I/O pins as outputs 
io.pinMode('USR1', 'out');
io.pinMode('USR2', 'out');
io.pinMode('USR3', 'out');

setInterval(readTags, 2000);              // read every 2 seconds 

function readTags() {
   mifare.read(function(error, buffer) {  // read tag
      if (error) {                        // if there's an error result
        console.log("Read failed ");      // let user know about the error
        console.log(error);
      } else {                            // you got an NDEF message
         // decode the message into a JSON object:
         var message = ndef.decodeMessage(buffer.toJSON());
         // print the message's records:
         console.log("Found NDEF message with " + message.length +
            // "record" if there's only one, "records" if there's more:
            (message.length === 1 ? " record" : " records" ));
         // print the message:
         console.log(ndef.stringify(message));

         // loop over the LEDs and turn on one for each record:  
         for (var pinNum=0; pinNum<4; pinNum++) {
            var pin = 'USR' + pinNum;        // set pin name, USR0 - USR3
            if (pinNum < message.length) {   // USR0=1 record, USR1=2 records...
               io.digitalWrite(pin, 1);      // turn on pin
            } else {
               io.digitalWrite(pin, 0);      // turn off pin
            }
         }
      }
   });
}

Raspberry Pi Version

For this version, you’ll need:

• 4 LEDs
• 4 220Ω resistors
• 1 small solderless breadboard
• 4 female-to-male jumpers
• 4 header pins

Although BoneScript is not ported to the Pi as of this writing, there are a few alternative node libraries for controlling the GPIO. None of them are as fully featured as BoneScript, but they do allow you to turn on and off the GPIO pins. Here’s a variation on the BeagleBone example, but for the Pi, using the onoff npm package.

Set up the directory as you did for the BeagleBone Black. The package.json is the same except for one addition in the dependencies:

   "dependencies" : {
    "mifare-classic": "0.0.1",
    "ndef"   :  ">=0.0.4"
    "onoff" : ">=0.1.6"
  },

The onoff package works by writing to virtual files in the system directories that control the GPIO pins. For more details on it, see NPM’s onoff page. Since BoneScript does basically the same thing on the BeagleBone, the two libraries are similar, and the code for this example is similar.

The GPIO pins of the Pi are labeled as shown in Figure 9-1.

Figure 9-1. Raspberry Pi with LEDs attached to GPIO pins 18, 23, 24, and 15; the resistors are 220Ω

In order to make onoff work on the Pi, you’ll need to enable the pins as an administrator. To do this, here’s a short script that will do it:

var Gpio = require('onoff').Gpio,
   led = [];
    led[0] = new Gpio(18, 'out'),   // set LED I/O pins as outputs
    led[1] = new Gpio(23, 'out'),
    led[2] = new Gpio(24, 'out'),
    led[4] = new Gpio(25, 'out');

Save this as suexport.js, then install the whole project using npm install. Then run the script like so:

$ sudo node suexport.js

You won’t see any output, but the script will enable the following script to run as a regular user.

Here’s the index.js for the Raspberry Pi version, with changes from the BoneScript version noted:

var ndef = require('ndef'),                  // require ndef package
    mifare = require('mifare-classic'),      // require this package
    Gpio = require('onoff').Gpio,            // require onoff package
    led = [];                                // array of LEDs  

led[0] = new Gpio(18, 'out'),                // set LED I/O pins as outputs 
led[1] = new Gpio(23, 'out'),
led[2] = new Gpio(24, 'out'),
led[3] = new Gpio(25, 'out'),

setInterval(readTags, 2000);                 // read every 2 seconds

function readTags() {
   mifare.read(function(error, buffer) {     // read tag
      if (error) {                           // if there's an error result
        console.log("Read failed ");         // let user know about the error
        console.log(error);
      } else {                               // you got an NDEF message
         // decode the message into a JSON object:
         var message = ndef.decodeMessage(buffer.toJSON());
         // print the message's records:
         console.log("Found NDEF message with " + message.length +
            // "record" if there's only one, "records" if there's more:
            (message.length === 1 ? " record" : " records" ));
         // print the message:
         console.log(ndef.stringify(message));
         // loop over the LEDs and turn on one for each record:
         for (var pinNum=0; pinNum<4; pinNum++) {
            console.log(pinNum);
            if (pinNum < message.length) {   // LED0=1 record, LED1=2 records...
               led[pinNum].writeSync(1);     // turn on pin 
            } else {
               led[pinNum].writeSync(0);     // turn off pin
            }
         }
      }
   });
}

Require onoff instead of bonescript.

Use an array for the four LED pins. Make a GPIO object for each. Pin numbers come from the Pi GPIO header.

Use Gpio.writeSync() instead of digitalWrite().

When you install and run this script, it will run identically to the BeagleBone version: one LED will light for every record you read in an NDEF message on a tag.

Onoff package on the BeagleBone

It is possible to run this project on the BeagleBone as well as the Pi, with some modifications and caveats. You can’t control the built-in LEDs, but you can control the regular GPIO pins with onoff. You can find the GPIO pin numbers for the BeagleBone on their website. Any of the GPIO pins can be used to output to LEDs.

As of this writing, there’s an issue with semver, the version checking tool used by npm’s build tool node-gyp. In order to use npm to install any scripts using onoff, you’ll need to edit the configuration file related to semver as follows:

$ nano /usr/lib/node_modules/npm/node_modules/node-gyp/lib/configure.js

Look for the following lines (likely lines 104–108):

 if (semver.gte(version, '2.5.0') && semver.lt(version, '3.0.0')) {
    getNodeDir()
 } else {
    failPythonVersion(version)
 }

Replace all four lines with this line and save the file:

    getNodeDir();

Once you make this change, onoff will compile and install on the BeagleBone. You may still find it more convenient to use BoneScript, however.

Although this example is relatively simple, it hints at the possibilities afforded by these embedded boards for physical interaction from NFC. For example, the hotel door lock in Chapter 7 could easily be duplicated for the Raspberry Pi or BeagleBone. The lighting control from Chapter 6, and even potentially the music playback, could be done from either of these boards, with some more work. For more on control of the GPIO for either of these boards, see Matt Richardson’s books mentioned previously, or Adafruit’s excellent tutorials on both boards.

NFC on embedded Linux is still rather nascent in its development, as you can see from these examples. Libnfc offers great potential as a basis for further development, however, and we hope to see further work on it and its spinoff projects. In particular, more development on broadening the range of compatible tag types, and on the peer-to-peer exchange libraries like libllcp will advance the technology considerably on this platform. The potential for NFC-driven physical applications using embedded boards is broad, and the platforms shown here provide a robust, inexpensive, and straightforward way to develop such applications.

You’ve seen NFC in action on three different platforms: Android, using PhoneGap; Arduino, using the NDEF library; and embedded Linux using libnfc. You’ve gotten to know the structure and affordances of NDEF, learned about the various tags that are compatible with NFC, and used peer-to-peer exchanges with NDEF. As you can see, the technology offers some interesting improvements on RFID, most notably a data format that’s independent of the tag technology and the ability for device-to-device communication without tags as well.

There is room for improvement in the various NFC APIs currently available. If you’re a low-level developer, we encourage you to get involved by helping to expand the range of tag types available to higher-level libraries, and to develop NDEF-level APIs for platforms where support for NDEF does not yet exist. If you’re more of a high-level interface designer, we encourage you to use NFC in a wide variety of applications as inspiration for others on the technology’s possibilities.