Tag Archives: node.js

6:49 am - March 4, 2015 - Reid Carlberg

Node.js IoT Host on Heroku: The Simplest Thing that Might Possibly Work

TL;DR – Look ma — CODE that stores DATA which becomes usable in SALESFORCE via OData.

For the last couple of days, I’ve been talking about some hardware I’ve put together (here and here). These efforts all come from a pretty simple problem I have:

My house is old, drafty and hard to heat. And I live in Chicago.

This problem is particularly noticeable in January and February, but July and August can be just as bad in the other direction so I need to address it somehow. Ugh.

Well, that which can be measured can be improved, right? So that’s where I’m going to start. Measurement is actually the easy part. Simple Data Recorder handles that. Where I’ve struggled is figuring out where to put that data which I measure, how to put it there and then what to do with it. This post covers the first two.

Most of the time, I work on the Force.com side of the Salesforce1 platform. I’m extremely comfortable in it, but the free Developer Edition will run out of storage very quickly if you start throwing a new record at it every minute or so. Enter the other side of Salesforce1: Heroku.

Naive IoT Host, deployed to Heroku, solves my storage problem. I’m using the free tier of everything so far, and should be able to for ~20 days at my current rate of data production. You can see a live dataclip of conditions in my house right now should you be interested. If you’ve even glanced at the code, you know it won’t scale to 100,000 devices any time soon. But it will do a couple of dozen just fine, and that’s just the scale I need for this experiment.

The high level end to end looks something like this:

Everything starts out on the Arduinos. The Raspberry Pi polls the Arduinos for data, transforms that data into JSON, and then posts that to a Node.js app running on Heroku. The Node.js app augments that data with current weather conditions and then writes it to a PostgreSQL table. I have it set to do this about every 5 minutes.

The basic Node.js app is built using Express, but I haven’t spent any significant time optimizing it.

I’m using ipfilter to ensure that only someone from a whitelisted IP address can make a request on the app. If you aren’t calling from some recognized IP, you get an “unauthorized” response.

Sequelize coordinates the database activities. For some reason I didn’t look at ORM when I wrote that tweet a couple of months ago. Sequelize isn’t perfect, but it’s super fast as a getting started tool, and it’s way better than anything I might write. You start by declaring a model, which it then automatically creates for you in the actual database. It doesn’t do database modifications as far as I can tell — there’s some kind of a separate module for that which I haven’t investigated yet.

var Reading = sequelize.define('Reading', {
	deviceName: Sequelize.STRING,
	rangeStartDate: Sequelize.DATE,
	rangeEndDate: Sequelize.DATE,
	maxBrightness: Sequelize.INTEGER,
	minBrightness: Sequelize.INTEGER,
	maxTemperature: Sequelize.DECIMAL(4,2),
	minTemperature: Sequelize.DECIMAL(4,2),
	weatherSummary : Sequelize.STRING,
	weatherTemperature: Sequelize.DECIMAL(4,2),
	weatherWindSpeed: Sequelize.DECIMAL(4,2),
	weatherWindBearing: Sequelize.INTEGER
});

Lastly, the Forecast module connects me to Forecast.io to get the current outside weather conditions. I thought this would be useful information to keep in mind as I start to look at the data. Now, I could have chosen to work with current-condition-then data in a number of ways, including querying for it analysis time (whenever that turns out to be), but the incremental cost of including it with each reading was so trivial I decided to do it.

And voila — for your enjoyment — the data.

OK, so far so good.

Next: Accessing the data in Salesforce using Heroku Connect External Objects OData

Category: Development Tags: heroku, IoT, node.js

4:07 pm - February 27, 2015 - Reid Carlberg

Read Data from Multiple Arduinos with a Raspberry Pi B+ using I2C and Node.js

Last year I wrote about controlling an Arduino using a Raspberry Pi and I2C. I2C being, of course, a 30+ year old protocol that everybody and their brother still supports. I tried this again, for reasons I’ll state in the very last sentence of this blog, and it failed. Significantly.

Why? Well, turns out I had forgotten the cardinal rule of I2C.

Link your devices, master and slave, sender and receiver, using a shared ground wire. Otherwise, you’re going to have a bad time. Really.

Mmm’k, with that out of the way:

1) The Adafruit tutorial is still the best one I’ve found for enabling I2C on your Raspberry Pi. However, raspi-config now helps you do this under advanced options. I used the advanced options and then doubled checked everything Adafruit told me to do. (Rule #1: do what Adafruit says.)

2) Add your user to the i2c group. The command is “sudo adduser pi i2c“. This will make your life easier. Thank you ABC Electronics.

3) Configure your Arduinos as slave senders. The example code that comes with the Wire library in the Arduino IDE is perfect for this. Wire ground to ground, SDA to SDA and SCL to SCL. Once you add power to the Arduino, install the slave sender example code and boot your pi, you should be able to see your I2C device using the i2cdetect -y 1 command. Mine with two Arduinos looks like this:

My code looks a little different than the slave sender sample, since I have a photocell and a temperature probe on each one. There’s a fair amount of boiler plate code to read those values, but the fundamental structure is the same as the sample code: configure an I2C address, wait for a request, send a fixed length string in response.

#include <Wire.h> 
#include <OneWire>

// Define analog pin
int sensorPin = 0;
int lightLevel = 0;

int DS18S20_Pin = 2; 
OneWire ds(DS18S20_Pin);  // on digital pin 2

String deviceId = "D001";
int wireId = 4;

String lightLevelString = "";
String output;
int m;
char c[5];
char d[10];

// Setup
void setup() {
 Wire.begin(wireId);
 Wire.onRequest(requestEvent);
 // Init serial
 Serial.begin(9600);
}
 
// Main loop
void loop() {
 
 // Get temperature
 int sensorValue = analogRead(sensorPin);
 
 lightLevel = map(sensorValue, 10, 1000, 1, 100);
 m = sprintf(c, "%03d", lightLevel);
 
  float temperature = getTemp();
  
  dtostrf(temperature, 6, 2, d);

  output = deviceId;
  output.concat("|");
  output.concat(String(c));
  output.concat("|");
  output.concat(String(d));
  
  Serial.println(output);
  
 
 delay(1000);
}

void requestEvent() {
  
  char newOut[16];
  output.toCharArray(newOut, 16);
  
  Wire.write(newOut);
}

float getTemp(){
  //returns the temperature from one DS18S20 in DEG Celsius

  byte data[12];
  byte addr[8];

  if ( !ds.search(addr)) {
      //no more sensors on chain, reset search
      ds.reset_search();
      return -1000;
  }

  if ( OneWire::crc8( addr, 7) != addr[7]) {
      Serial.println("CRC is not valid!");
      return -1000;
  }

  if ( addr[0] != 0x10 && addr[0] != 0x28) {
      Serial.print("Device is not recognized");
      return -1000;
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44,1); // start conversion, with parasite power on at the end

  byte present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE); // Read Scratchpad

  
  for (int i = 0; i < 9; i++) { // we need 9 bytes
    data[i] = ds.read();
  }
  
  ds.reset_search();
  
  byte MSB = data[1];
  byte LSB = data[0];

  float tempRead = ((MSB << 8) | LSB); //using two's compliment
  float TemperatureSum = tempRead / 16;
  
  return TemperatureSum;
  
}

4) Install node.js on your rpi, and then use npm to install the i2c library. You should now be able to read your Arduino via Node.js. My code declares two devices, both with addresses matching the settings in my Arduino code, and it looks like this:

var i2c = require('i2c');
var address = 0x18;

var device1 = new i2c(address, {device: '/dev/i2c-1'});
device1.setAddress(0x4);

var device2 = new i2c(address, {device: '/dev/i2c-1'});
device2.setAddress(0x6);

var devices = [ device1, device2 ];

function handleTimeout() {
	  setTimeout(function() { handleRead(); }, 1000 );
}

function handleRead() {
  	for (i = 0; i < devices.length; i++) {
		    devices[i].readBytes(null,15, function(err,res) {
			      console.log(res.toString('ascii'));
  		  });
  	}
	  handleTimeout();
}

handleTimeout();

The output is pretty simple — it just prints the data it receives, like so:

My final setup consists of two Arduinos (D001 and D002 in the data) connected to one Raspberry Pi B+. You’ll notice that the RPi is powering both Arduinos. (Red is power. Back is ground. Blue is SCL. Yellow is SDA.) Everything is integrated via the breadboard.

Lessons learned (and remembered):

1) Always connect the grounds. If you’re not seeing your minimally configured, powered and connected slave-sender device, check the ground first.

2) You can easily power a couple of Arduino’s from the RPi. Nice. I wonder how many you can power. I’m sure it depends on what you’re doing.

3) The SDA and SCL wires seem to be pretty flexible. You don’t have to chain them in a particular order as far as I can tell. Just make sure there’s some kind of connection and you’re good to go.

4) Arduinos, with built in analog to digital converters, are a lot less painful (and more reliable) to work with when it comes to reading basic sensors and sharing that data with an app running on the RPi. My original reason for revisiting this use case was dissatisfaction with reading a photocell directly on the RPi using Python (tutorial) and Arduinos are cheap — $10 at MicroCenter.

Category: Development Tags: arduino, i2c, node.js, NodeJS, raspberry pi, rpi

5:49 am - February 21, 2015 - Reid Carlberg

npm install parenting

My young son and I (aka The Critter) talk about a lot of things, including the fairly abstract work I do. I wanted to make it more concrete for him, so, for fun, created a super simple node library which is now, shockingly, available via the esteemed npm and of course on github.

The gist? Well, you put a number of things you might say to your child in as prompts, and can then have the computer say them out loud. It comes with defaults, you can create your own, and it of course has auto mode where it just says one right after the other.

Useful phrase like, Reid, use your napkin. Reid, clean your room. Reid, stop doing that.

You get the idea!

It must have connected a little because here you can see him changing the configured name to be that of his sister!

Haven’t tested on a Windows machine.

Category: Development Tags: node.js, parenting

11:00 am - February 21, 2014 - Reid Carlberg

Philips Hue, Raspberry Pi, Node.js, Salesforce and You

One of the devices I brought to the Dreamforce Connected Device Lab was a Philips Hue Starter Kit. A friend of mine whipped up a little Ruby script to flash the lights and change colors at random for the Lab, and I got to wondering what it would look like to control the whole thing through Salesforce. Here’s what I did.

TL;DR: Connected a Raspberry Pi to the Hue bridge using Node.js. The same app is connected to a Salesforce app using the Streaming API and is controllable using the Salesforce1 mobile app. Salesforce Package (and raw code). Node.js Code.

The Hue system has a pretty straightforward architecture. The bulbs connect to a bridge and that bridge connects to your network. Once it’s on the network, you can start to control them via the Hue app or the Hue API.

Step 1. The first thing you need to do is choose the device you want to use to control the bridge. This device will have to live on the same physical network as the Hue bridge. I chose a Raspberry Pi. Configuring the Raspberry Pi is pretty easy, these are my standard steps. This includes installing Node.js which isn’t part of the Raspbian distro.

Step 2. Use NPM to install the Hue interface library. “Node-Hue-API” seems to be the winner in this department. Follow the instructions on the Github repo. They’re really good. The basics are:

Find the bridge and get the IP address (code).
Create a user on the bridge (code) — note that you’ll need to update the code with your bridge’s IP address.
Remember everything it just spat out for later.

Step 3. You are now ready to configure Salesforce. There are a few steps to this process. If you don’t have a developer org, it’s time to go get one.

Configure a new connected app in your developer org (detailed instructions from Help).

Start by clicking on Setup at the top of your screen, click on Create on the side, click on Apps, and then click on the New button under Connected Apps.

You will now see the New Connected App screen. Enter the required fields indicated in red. The API Name is an internal name that will fill itself in once you complete the name field. Check the box labeled “Enable OAuth Settings” and add http://localhost:3000/oauth/_callback as your callback URL. Select all of the available OAuth scopes, and click the add button. Click on Save.

Once you click on “Save”, you’ll have a fully configured connected app. You’ll be using the Oauth2 web server flow, which requires your consumer key and your consumer secret.

Note: it may take a few minutes for your new connected app to be fully active. This is normal.

Finally, configure your personal security token. (Lots of information about Salesforce Security Concepts including the security token is available in the API docs.) Start by clicking on your name at the top of the screen, click on My Settings in the drop down menu, then click on Reset My Security Token on the left.

Click on the big green “Reset My Security Token” button. This will result in an email which we’ll use again in a minute.

Now that your Connected App is created, you need to install the unmanaged package which contains the objects, code and UI that helps you control the Hue. You’ll be able to see the code once you’ve installed it, or you can see it on Github. For now, use this link to start the install process.

https://login.salesforce.com/packaging/installPackage.apexp?p0=04tU0000000E0eU

This will guide you through a series of steps. Since this is a demo and you’re in a demo environment, just accept all the defaults. You’ll click “Continue”, “Next”, “Next” and finally “Install”.

When you have done this successfully, you will land on a screen which declares “Install Complete!”. You must now click on the app selector in the upper right which probably says “Sales”. Then click on the app labeled “LAB Hue Interface”.

Once you do that, you immediately see a screen telling you that setup is not yet complete. Please go ahead and click on the big “Complete Setup” button.

This will bring you to a screen that helps you insert something called a Push Topic. Push Topics are part of the super cool and extensively documented Streaming API. Don’t worry, just click the button.

And then click the link.

Which brings you back to the Hue interface, which now looks like this:

As an aside, you might be thinking, wow, that’s a lot of steps. And you’re right! There is a way to automate this configuration, however, you wouldn’t be able to see the code as easily. So I’ve opted for a few more steps so the example is easier to understand.

Step 4: Finish configuration of your Raspberry Pi. The good news? This is now going to be very easy.

First, use npm to install nforce and faye (“npm install nforce faye“).

Next, get the basic code required to connect Salesforce to the Hue. When you get it on the Raspberry Pi and save it as “hueforce.js”, you’ll want to use nano or another editor to update the field values to yours. You’ll need to add your user info, your OAuth / Connected App info and your Hue info.

And now you can run your app using “node hueforce.js“. Now all those great blue buttons are controlling your Hue!

Step 5. Finally, turn it into a mobile app using Salesforce1 (iTunes, Google Play). In Salesforce, you’ll need to navigate to the tab configurations and edit the “Hue” tab.

In the Hue tab settings, make sure you have “Mobile Ready” checked. Be sure to save your changes.

Now you are ready to add this page to the Mobile Configuration. Click on Setup, select Mobile Administration, and click on Mobile Navigation.

Once that’s done, you simply login to the Salesforce1 app, touch the menu selector in the upper left, then scroll down until you see “Hue” listing under “APPS”. The UI is exactly the same.

I’ve also added a fun trigger that automatically fires the “siren” setting when a new lead comes in.

That’s it. Questions, comments, I’d love to hear them.

Category: Tech Life Tags: hue, node.js, raspberry pi

1:19 pm - February 10, 2014 - Reid Carlberg

Control an Arduino with a Raspberry Pi Using Node.js and I2C

You might also find this post helpful: Read Data from Multiple Arduinos with a Raspberry Pi B+ using I2C and Node.js

As a software developer, I usually stay away from lower level communication protocols. My logic has historically been: they’re a lot of work, and my time is better spent higher up the stack.

A couple of weeks ago, after suffering through a variety of failures and uncertainty higher up the stack, I decided the only way out was to go at least a little deeper. So I bit the bullet and connected a Raspberry Pi to an Arduino using the I2C protocol, and then was able to control the Arduino using Node.js. This post covers how I did it.

My use case was fairly simple. I decided to drive a Wild Thumper using the Salesforce1 mobile app. The Wild Thumper is controlled by an Arduino compatible board, aptly named the “Wild Thumper Controller“. You might remember I had a couple of these with me at the Connected Device Lab this Dreamforce. In order to communicate with Salesforce, it needs to have some kind of a gateway that can talk to the Internet using HTTPS, which is where the Raspberry Pi comes in. If you have a different flavor or Arduino sitting around this should still work.

There are a lot of really great technical introductions to I2C (including — gasp — one from 2001), but you don’t really need them to get started. Keep these two basic ideas in mind:

You’re going to work in a Master-Slave configuration.
You need to connect three pins. SDA, SCL and Ground.

That’s it.

Step 1: Slave Configuration on the Arduino compatible Wild Thumper Board is pretty easy. In fact, you can simply use the “Wire > Slave Receiver” sample code included with the IDE to get started (below). Load this in the Arduino IDE as is, send to your device and then start the serial monitor. Put it aside.

// Wire Slave Receiver
// by Nicholas Zambetti <http://www.zambetti.com>

// Demonstrates use of the Wire library
// Receives data as an I2C/TWI slave device
// Refer to the "Wire Master Writer" example for use with this
// Created 29 March 2006
// This example code is in the public domain.
#include <Wire.h>

void setup()
{
  Wire.begin(4);                // join i2c bus with address #4
  Wire.onReceive(receiveEvent); // register event
  Serial.begin(9600);           // start serial for output
}

void loop()
{
  delay(100);
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
  while(1 < Wire.available()) // loop through all but the last
  {
    char c = Wire.read(); // receive byte as a character
    Serial.print(c);         // print the character
  }
  int x = Wire.read();    // receive byte as an integer
  Serial.println(x);         // print the integer
}

Step 2: Setting up the Raspberry Pi is a little more difficult, but it’s well documented. If you are using a standard Raspbian distro, the I2C port is not yet enabled. Adafruit has an excellent post on enabling the I2C port. Follow those instructions, then c’mon back.

Step 3: Wire your Raspberry Pi and your Arduino together and make sure the RPi can see the Arduino. Pinouts on the RPi are a little irritating. I use the Pi Cobbler. It gives you a handy, easy to read guide to which pins are where. If you are connecting directly to the GPIO pins, be sure to consult a pinout digram.

Before you connect everything, your RPi should produce this when you use the i2cdetect command.

The basic configuration is really simple. Master SDA pin to Slave SDA, Master SCL pin to Slave SCL, Master GND pin to Slave GND. On the Wild Thumper Controller, SDA is A4, SCL is A5 and GND is any pin on the outside edge of the board. And an Arduino Uno R3, there are special pins for I2C, above the AREF pin, clearly labeled on the back side of the board. In my case, the result looks like this (that’s the Wild Thumper Controller on the right, Pi Cobbler on the left):

After connected, your RPi should produce this (note that there is now a device on 4).

Step 4: Install Node.js on to your Raspberry Pi using this simple link. If you prefer to be a bit more hands on, you can follow these instructions. If you prefer to be really hands on, you can install it by compiling from the source, but it will probably take > 2 hours and so far in my experience it’s no different.

Step 5: Install something that lets Node.js talk to the Raspberry Pi’s I2C system. You should use the I2C library. There are a couple of others out there, but this is easy and popular. Now you should be able to do something like this:

var i2c = require('i2c');
var device1 = new i2c(0x18, {device: '/dev/i2c-1', debug: false});
device1.setAddress(0x4);
device1.writeByte(0x2, function(err) { console.log("error"); console.log(err); });

And see a “2” in the Arduino serial port monitor (like so).

There you have it — the basics of controlling an Arduino using a Raspberry Pi with Node.js and I2C. My original goal was to control the Wild Thumper via the Salesforce1 app. I was able to accomplish that pretty easily. Here’s my basic controller for the Thumper, and here’s the Node.js app running on the RPi. I created a simple UI on the Salesforce1 mobile app (below) that sends commands to the Thumper using the Streaming API and connects to Salesforce using the excellent nforce.

Category: Tech Life Tags: arduino, i2c, node.js, raspberry pi, salesforce, salesforce1

Tag Archives: node.js

Share this:

Like this:

Share this:

Like this:

Share this:

Like this:

Share this:

Like this:

Share this:

Like this: