A home environment sensor

Visionect, 6 Mar 2014

How we made a home environment sensor display from a Raspberry Pi and electronic paper DIY kit.

Matevž scraped together some hardware collecting dust around the office. A Raspberry Pi out of a fellow startup’s device, an e-ink display his startup is working on, and a Wi-Fi dongle from the internets.

What happens when you deploy Visionect’s stack to the Raspberry Pi? A Webkit instance on a server that renders websites and sends the resulting images to simple e-paper devices over the air. The device is just the interface, the server does all the heavy lifting.

Can the Raspberry Pi handle it?

Visionect’s frontend wizard, Matevz, decided to find out. He found Raspberry Pi boards inside Cubesensors, mixed two of the most interesting Slovenian hardware startups together, and barely broke a sweat doing it.

Cubesensors are cute!

You might not have the same stuff laying around as Matevž does, but you don’t need much really.

The hardware

A Raspberry Pi will act as the server doing all the heavy lifting. Talking to the sensors, rendering output for the display and so on. Something, anything, on the Pi needs to produce ZigBee log files. We’re going to parse these to produce a shiny dashboard.

Getting a few cute and cuddly Cubesensors will be easiest.

Then you need some way to display the data. Matevž used Visionect’s V Tablet, but anything that can open a webpage will do. E-ink just happens to have great battery life.

Shiny V Tablet with a cute Cubesensor. Perfect.

Visionect+Cubesensors+node.js = win

Contrary to what you’d expect, shoving a server that usually takes a beefy processor and many rams onto the 700MHz Raspberry Pi was completely uneventful. It just worked.

  • install some dependancies
  • make deb packages for Visionect things
  • use gvm to update Go and get the admin panel working
  • write a log parser for sensor logs
  • make a simple static file server
  • write some code to display data
  • hook up the tablets

And that’s it. That’s all it took. Imagine my disappointment expecting a juicy tale of trial and error, of heroic hacking and triumph. Instead, everything just … worked.

Matevž says the hardest part was creating those deb packages, but now you can just run sudo apt-get install koala.

If you ever need to make a deb package, Matevž swears by the seven step guide from Web Upd8.


Because there’s still no official API, Matevž had to do some inventive hacking – parsing ZigBee logs.

When Cubesensors talk to each other, they leave a trail in /var/log/ziggy.stdout.log. I’m not sure why, but it sure came in handy.

Logs look like this:

 New node id=409D, eui64=000D6F0003053413  000D6F0003C16E48: data = {"noise": 16.532, "temp": 24.5, "fw": 28, "battery": 2464, "light": 1708, "voc": 400, "humidity": 1576, "pressure": 986.0, "voc_resistance": 14590, "shake": true}  000D6F0003C16E48: score = 66.297 (temp=23.5/1.0 humidity=20.0326797386/-0.348102820428 voc=450/1 noise=16.532/1)  000D6F0003C16E48: reply = '\x11\x00B' (kwargs={"home": true, "score": 66}, queue={})  Sequences: '8F' added  Sequences: '8F' done (ACK), removing.  000D6F0003053413: received ping  000D6F0003053413: reply = '\x10\x00' (kwargs={"home": true}, queue={})

Parsing those into a useful form is a simple matter of using node’s Tail package and applying a regex.

var tail = new Tail("/var/log/ziggy.stdout.log"),
 pat = /\ (.*?): data = (.*?})/g,
 sensors = {};

tail.on("line", function(line) {
 var data = pat.exec(line);
 if (data) {
 sensors] = JSON.parse(data);

See, simple.

Displaying the data

Sweet, V Tablet shows some data!

Our data is in a friendly JSON format. All we need now is a web app to display it.

First you’ll need a static server. Because you’re using node.js to parse the logs, a server is just a node-static away. But Matevž is a frontend developer so he didn’t know that and built it himself. That’s okay too.

Most of the frontend code is boring because it just handles navigation. FetchData is more interesting because it deals with displaying the data. An interval calls it every ten seconds.

fetchData = function() {
 $.getJSON('data.json', function(new_data) {
 data = new_data;
 $.each(data, function(id, cube) {
 cube.voc = Math.max(cube.voc - 900, 0)*0.4 + Math.min(cube.voc, 900)
 cube.humidity = Math.min(95, Math.max(10, (cube.humidity -330*5.1)/(600/1000*5.1) + 55))
 cube.light=10/6.0*(1+cube.light/1024.0)*4.787*Math.exp(-(Math.pow((cube.light-2048)/400.0+1, 2)/50.0))) *(102400.0/Math.max(15, cube.light) - 25);
 if ($('#data').is(':visible')) {

Mmm, maths. And magic numbers.

To be honest, I’m not sure how those conversions work or what any of the numbers mean, but the end result is a human readable display of temperature, noise, humidity, light, air pressure, and air quality in a room. You can get the full source code at

A bunch of environmental data on an e-paper V Tablet.

Hooking up the tablets

Now we have to turn the Raspberry Pi into a WiFi hotspot for the tablets.

You’ll need a wi-fi dongle, some more deb packages, and a bit of configuration. Matevž says he used the TP Link TL-WN722N dongle, but you can use whatever you’ve got. Especially if it’s based on the Atheros chipset.

Then you have to add deb wheezy non-free to/etc/apt/sources.list and run apt-get install firmware-atheros isc-dhcp-server hostapd to install all the packages.

After that, some configuration:

auto wlan0
 iface wlan0 inet static

# /etc/dhcp/dhcpd.conf

subnet netmask {
 option routers;
 interface wlan0;


# /etc/hostapd/hostapd.conf

 wpa_pairwise=TKIP CCMP

# /etc/init.d/hostapd.conf


Then tell the Raspberry Pi to turn into an access point every time it boots:

update-rc isc-dhcp-server defaults
update-rc hostapd defaults

A bunch of sensors inside a plastic box hooked up to a Raspberry Pi talk to a palm-sized e-paper tablet.

And voila. A self-contained system where a bunch of sensors inside a plastic box hooked up to a Raspberry Pi talk to a palm-sized e-paper tablet.

Well, you have to tell the tablet to connect to this access point as well. But that’s trivial – go into settings, input the right IP addresses. Then don’t forget to visit Visionect admin panel at and tell it which URL to serve. For the Cubesensors experiment this was

Do it yourself

Let’s recap. To turn your Raspberry Pi into a Visionect server you have to:

  • add Visionect’s deb packages to sources.list, visit:
  • get a Wi-Fi dongle
  • convince your Pi to act as an access point
  • tell the tablet where to connect

But I’m sure with some of elbow grease you can make almost any combination of hardware do these things. Our way might just be easier.


Matevž made a room sensor display on an e-paper V Tablet. What are you going to build?


Swizec Teller is a geek with a hat. He wrote this guest post as part of an ongoing showcase of interesting projects from our community. You can follow him on twitter, here.