Intel Edison, Node.js and Azure IoT

The Intel Edison is small, Wi-Fi and Bluetooth enabled development board running an Atom processor. It can be mounted on an Arduino-compatible board in order to interface with the wide variety of shields available.


I was interested in running Node.js and Johnny-Five – an open source framework originally created for robotics – on the Edison and connecting it to Azure IoT Hubs (Microsoft’s PaaS offering for the IoT).


  • The Azure IoT SDK requires Node.js 0.12 or greater.
  • The Yocto project image (the officially supported Linux image for the Edison) only supports Node.js 0.10.
  • Updating Node.js on Yocto is a non-trivial task.

Thanks to some ideas and help from Rex St. John and Rick Waldron, I was able to accomplish this.

Install ubiLinux on the Edison

ubilinux is a Debian variant and allows installation onto the internal flash of an Intel Edison platform.
 Where the Yocto project is a custom configured Linux image that Intel has built to be lightweight, ubiLinux is a more full-featured Debian variant that, among other things, allows the installation of different versions of Node.js.

The installation instructions for ubiLinux are pretty straight forward.

ubilinux installation instructions for Intel® Edison

Using either PuTTy (Windows) or Terminal (Mac OS X), connect to the Edison setting the baud rate to 115200.

Example – Mac OS X w/ Terminal

screen /dev/cu.usbserial-######## 115200 -L

Replace ######## with the unique ID of your Edison (its easiest to type screen /dev/cu.usbs then press the tab key to auto-complete the device ID, then add 115200 -L to it.)

Press Enter twice and log in with the user name root and the password edison.

Once connected, set the time of on the OS to the current UTC time (you need to check and possibly set the time whenever the Edison is without power for any duration).

Check the current date in the terminal SSH session, by executing the following command:


If the date is incorrect, execute the following, replacing the date and time with the current UTC time.

date --s='23 FEB 2016 14:34:00'

Remember: You need to check (and possibly correct) the date any time the Edison has been without power.

Configure Wi-Fi

Use vi to edit the interfaces file (where the Wi-Fi connection information is maintained).

vi /etc/network/interfaces

Edit the following, changing Emutex and passphrase to your SSID and passcode respectively.

#auto wlan0
iface wlan0 inet dhcp
     # For WPA
     wpa-ssid Emutex
     wpa-psk passphrase

Restart the networking service with the following command:

/etc/init.d/networking restart

After networking is restarted, ensure the Wi-Fi is running.

ifup wlan0

You should see output similar to this (note the IP address in the bound to line)

root@ubilinux:~# ifup wlan0
Internet Systems Consortium DHCP Client 4.2.2
Copyright 2004-2011 Internet Systems Consortium.
All rights reserved.
For info, please visit
Listening on LPF/wlan0/90:b6:86:0b:53:2d
Sending on   LPF/wlan0/90:b6:86:0b:53:2d
Sending on   Socket/fallback
DHCPREQUEST on wlan0 to port 67
DHCPDISCOVER on wlan0 to port 67 interval 5
DHCPREQUEST on wlan0 to port 67
bound to -- renewal in 39220 seconds.

Update APT packages

From the same terminal session, enter the following command:

apt-get update

Install Node Version Manager

From the terminal session, clone the Node Version Manager (NVM) repo.

git clone ~/.nvm && cd ~/.nvm && git checkout `git describe --abbrev=0 --tags`

Then activate NVM

. ~/.nvm/

Next, add these lines to your ~/.bashrc, ~/.profile, or ~/.zshrc file to have it automatically sourced upon login:

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/" ] && . "$NVM_DIR/" # This loads nvm

Install a Newer Version of Node.js

Use NVM to install whichever version of Node.js you prefer. For this example I am installing Node.js v4.3.1 (stable and mature), but you could install 0.12.7 or 5.0.0 or 5.6.0, or stable, etc..

From the terminal session, run the following command:

nvm install 4.3.1

This will install Node.js v4.3.1 and make it the current version (e.g. running node -v will tell you the current version).

Congratulations! The Edison is now set up with Node.js 4.3.1 and ready to run an app that leverages sensors and communicates with Azure IoT Hubs.

The IoT App

For this example I am using the Grove Stater Kit – Intel IoT Edition from  Seeed Studios, although you could use something else if you’d like. The advantage of prototyping/experimenting with the Grove kits is that they eliminate the error-prone wiring and breadboarding and make connecting a variety of sensors to digital, analog and I2C pins easy. The Grove kit includes an Arduino compatible shield that a wide variety of sensors plug into.


The app I built uses the Grove kit, but you can easily modify it to use sensors on a breadboard – so continue reading even if you don’t have the Grove kit.

I am also making the assumption that you have set-up and Azure IoT Hub (if you haven’t, check out this lab)


Johnny-Five is a framework I have been using a lot because of its nice abstraction of the GPIO complexities and exposes objects for the development board and sensors. The board and input sensors have events that invoke callback functions making it easy to work in an event-driven way.

Define the Application Dependencies

Start by defining the application manifest, including the dependencies. In your working directory on you PC, create a file called package.json.

    "name": "thinglabs-iot-sample",
    "repository": {
        "type": "git",
        "url": ""
    "version": "0.1.2",
    "description": "Sample app that connects a device to Azure using Node.js",
    "main": "iot-starter-kit.js",
    "author": "Doug Seven",
    "license": "MIT",
    "dependencies": {
        "azure-iot-device": "1.0.1",
        "azure-iot-device-amqp": "1.0.1",
        "azure-iot-device-http": "1.0.1",
        "azure-iot-device-mqtt": "1.0.1",
        "johnny-five": "0.9.25",
        "edison-io": "0.9.2"

Write the Application

There are a few key concepts to cover in the application, so I have commented it verbosely. Create a new file named iot-starter-kit.js (named after the Grove kit) and add the following:

'use strict';
// Define the objects you will be working with
var five = require("johnny-five");
var Edison = require("edison-io");
var device = require('azure-iot-device');

// Define the client object that communicates with Azure IoT Hubs
var Client = require('azure-iot-device').Client;
// Define the message object that will define the message
// format going into Azure IoT Hubs
var Message = require('azure-iot-device').Message;

// Define the protocol that will be used to send messages
// to Azure IoT Hub
// For this lab we will use AMQP over Web Sockets.
// If you want to use a different protocol, comment out
// the protocol you want to replace, 
// and uncomment one of the other transports.
// var Protocol = require('azure-iot-device-amqp-ws').AmqpWs;
var Protocol = require('azure-iot-device-amqp').Amqp;
// var Protocol = require('azure-iot-device-http').Http;
// var Protocol = require('azure-iot-device-mqtt').Mqtt;

// The device-specific connection string to your Azure IoT Hub

// Create the client instance that will manage the connection
// to your IoT Hub
// The client is created in the context of an Azure IoT device.
var client = Client.fromConnectionString(connectionString, Protocol);

// Extract the Azure IoT Hub device ID from the connection string
var deviceId = device.ConnectionString.parse(connectionString).DeviceId;

// location is simply a string that you can filter on later
var location = 'Home Office';

// Define the sensors you will use.
var thermometer, lcd, led;

// Define some variable for holding sensor values
// celsius, fahrenheit, red, green, blue
// and initialize them all to 0
var c, f, r, g, b = 0;

// Define the board, which is an abstraction of the Intel Edison
var board = new five.Board({
 io: new Edison()

// Open the connection to Azure IoT Hub
// When the connection respondes (either open or error)
// the anonymous function is executed
var connectCallback = function (err) {
  console.log("Azure IoT connection open...");
  if(err) {
    // If there is a connection error, show it
    console.err('Could not connect: ' + err.message);
  } else {
    console.log('Client connected');
    // Create a message and send it to the IoT Hub every five-seconds
    var sendInterval = setInterval(function () {
      sendMessage('temperature', c);
    }, 5000);
    client.on('message', function (msg) {
      console.log('Id: ' + msg.messageId + ' Body: ' +;
      var body =":");
      var indexOfLed = body.indexOf("led");
      if(indexOfLed >= 0) {
        if(body[indexOfLed+1] === "on"){
        } else if(body[indexOfLed+1] === "off"){
      client.complete(msg, printResultFor('completed'));
      // reject and abandon follow the same pattern.
      // /!\ reject and abandon are not available with MQTT
    // If the client gets an error, handle it
    client.on('error', function (err) {
    // If the client gets disconnected, cleanup and reconnect
    client.on('disconnect', function () {

function sendMessage(src, val){
  // Define the message body
  var payload = JSON.stringify({
    deviceId: deviceId,
    location: location,
    sensorType: src,
    sensorValue: val
  // Create the message based on the payload JSON
  var message = new Message(payload);
  // For debugging purposes, write out the message payload to the console
  console.log("Sending message: " + message.getData());
  // Send the message to Azure IoT Hub
  client.sendEvent(message, printResultFor('send'));
// Helper function to print results in the console
function printResultFor(op) {
  return function printResult(err, res) {
    if (err) console.log(op + ' error: ' + err.toString());
    if (res) console.log(op + ' status: ' +;

// Linear Interpolation
function linear(start, end, step, steps) {
  return (end - start) * step / steps + start;

// The board.on() executes the anonymous function when the 
// board reports back that it is initialized and ready.
board.on("ready", function() {
  console.log("Board connected...");;
  // Plug the Temperature sensor module
  // into the Grove Shield's A0 jack
  thermometer = new five.Thermometer({
    pin: "A0",
    controller: "GROVE"
  // Plug the LCD module into any of the
  // Grove Shield's I2C jacks.
  lcd = new five.LCD({
    controller: "JHD1313M1"
  // Plug the LED module into the Grove Shield's D6 jack
  led = new five.Led(6);
  // The thermometer object will invoke a callback everytime it reads data
  // as fast as every 25ms or whatever the 'freq' argument is set to
  thermometer.on("data", function() {
     * The LCD's background will change color according to the temperature.
     * Hot -> Warm: Red -> Yellow
     * Moderate: Green
     * Cool -> Cold: Blue -> Violet
    // If there is no change in temp, do nothing.
    if (f === Math.round(this.fahrenheit)) {
    f = Math.round(this.fahrenheit);
    c = Math.round(this.celsius);
    r = linear(0x00, 0xFF, f, 100);
    g = linear(0x00, 0x00, f, 100);
    b = linear(0xFF, 0x00, f, 100);
    lcd.bgColor(r, g, b).cursor(0, 0).print("Fahrenheit: " + f);

Copy App Files to Edison

Using FileZilla you can connect to the Edison using sftp and drag-n-drop files onto the Edison.

  1. Launch FileZilla and connect to the Edison:
    Host: The IP address of the Edison
    Username: root
    Password: edison
    Port: 22
  2. Press Quickconnect
  3. Set the Local site path to the directory where your app files are located.
  4. Under the root directory on the Edison (Remote site), create a new directory named iot-labs.
  5. Drag the application files from the Local site directory to the Remote site directory.

Run the Application

From the terminal session, move to the iot-labs directory.

cd iot-labs

Use NPM to install the application dependencies.

npm install

Run the application

node iot-starter-kit.js

The application will launch and you will see some initial messages as the board initializes. After a few seconds you should see the temperature displayed on the LCD screen, and every five seconds you should see a messaged sent (‘enqueued’) to your Azure IoT hub.

root@ubilinux:~/iot-labs/azure-iot# node iot-starter-kit.js 
1456213504410 Device(s) Intel Edison 
1456213504440 Connected Intel Edison 
1456213504469 Repl Initialized 
>> Board connected...
Azure IoT connection open...
Client connected
Sending message: {"deviceId":"d7-edison","location":"Home Office","sensorType":"temperature","sensorValue":24}
send status: MessageEnqueued
Sending message: {"deviceId":"d7-edison","location":"Home Office","sensorType":"temperature","sensorValue":24}
send status: MessageEnqueued

You can monitor the messages coming into Azure IoT Hubs by using the iothub-explorer command line utility. In a new terminal window, install the iothub-explorer with NPM.

npm -g install iothub-explorer

Once installed, turn on the iothub-explorer event monitor (this will monitor messages as they come into your Azure IoT hub – so you know they are getting there).

iothub-explorer [YOUR IOT HUB OWNER CONNECTION STRING] monitor-events [YOUR DEVICE ID]

Note: On Mac OS X put the connection string in quotes. On Windows, do not use quotes).

You should see the same messages that your Edison is sending showing up in the monitor.

Event received: 
{ deviceId: 'd7-edison',
 location: 'Home Office',
 sensorType: 'temperature',
 sensorValue: 24 }

Sending Cloud to Device Messages

One of the capabilities I slipped into the application without much fanfare is the ability for the Edison to run an LED on and off based on messages sent to it via the Azure IoT hub. You can look at the application code for this block:

client.on('message', function (msg) {
  console.log('Id: ' + msg.messageId + ' Body: ' +;
  var body =":");
  var indexOfLed = body.indexOf("led");
  if(indexOfLed >= 0) {
    if(body[indexOfLed+1] === "on"){
    } else if(body[indexOfLed+1] === "off"){;
  client.complete(msg, printResultFor('completed'));
  // reject and abandon follow the same pattern.
  // /!\ reject and abandon are not available with MQTT

This block listens for incoming messages over AMQP and evaluates them for the sting led in the body of the message. If led is found, and the very next item in the body (split on a semicolon) is the word on or off, then the LED state is changed respectively (this is a simple/crude example of how to do this).

You can send messages to the Edison from the iothub-explorer with the following command:


Try it a few times using led:on and led:off as the message body.

There you have it. You can now use Node.js on the Intel Edison to send Device-to-Cloud messages and receive Cloud-to-Device messages (which can be command messages).