VoCore as smart sensor

Some days ago I received my VoCore, this device is amazing it’s a full embedded Linux device with  OpenWrt, WiFi and Ethernet on board and many I/O (i2c, GPIO, SPI, UART, ..). Its main strengths are size and WiFi on board. About size look at the following picture.

VoCore size
VoCore size

For a maker a device like this is awesome, combine connectivity and power in a so small size can open infinite possibilities but the first that comes to mind is smart sensors.

Smart sensor is a generic term, my own interpretation is about a device can acquire some physical data, elaborate it and communicate over the internet. What I’d like to present in this post is a simple use of VoCore as smart sensor.

Configuring OpenWrt

Before starting we need to configure OS, I chose to use Python for implementing the smart sensor logic.

VoCore is shipped with a release of OpenWrt doesn’t carry Python, so here the step to install it, I skip basic VoCore setup because can be found on VoCore site. Next steps assumes You are able to connect via ssh to VoCore and it has a internet connection enabled.

OpenWrt uses a package manager called opkg, like many others it uses a list of repositories urls where look for packages. These urls are defined in /etc/opkg.conf and in default configuration isn’t present the repository for python.

So first step is to add a new repository url, add the following line to the end of /etc/opkg.conf

src/gz cheese_packages http://downloads.openwrt.org/snapshots/trunk/ramips/packages/packages

After this we need to update opkg cache with following command

root@OpenWrt:~# opkg update

And finally we are able to install python

root@OpenWrt:~# opkg install python

Ok, less is done 🙂

Making the sensor

Now it’s time to work on hardware, what I’d like to make is a simple intrusion detection system that sends a push notification when someone get in the room. To send push notification I’ll use Pushetta, a service I made specifically to solve this task.

A PIR sensor is used to detect movements, this kind of sensor use infrared radiation to detect temperature changes in a specific range.

PIR Sensor
PIR Sensor

PIR sensors are cheap and really simple to interface with a microcontroller, there are only three pins. Two are VCC and GND and the last one is the OUTPUT.

In the following video I show how it works, I’m using a portable oscilloscope connected to the PIR sensor. As You can see when something move in sensor’s range output level goes high (+5V) and return low after a while.

What we want to do is read PIR output and send a push notification when it changes to high.

Sending notifications with Pushetta

To send notification we’ll use a web service I made called Pushetta, this is made of a web site and two Apps (one for iOS and one for Android).

First we need to register on Pushetta web site, it’s free and it’s a mandatory step to be able to send notifications.

Pushetta signup
Pushetta signup

After signup process we need the API key, this is the key used to call Pushetta service and send notification, it’ll be used in code we’ll write after.


Last step is to create a channel. Channel is something like a topic used to send notifications. User want to receive notifications have to subscribe channel interested in, using Pushetta Apps. More informations about how Pushetta works can be found on www.pushetta.com.

Channel creation
Channel creation

Now we are ready for the last step: connect PIR sensor to VoCore and write a few lines of Python code to handle all the logic.

Schema PIR - VoCore
Schema PIR – VoCore

In the picture there is the schematic used for our experiment. Connecting PIR sensor is really simple, I used GPIO0 as input in the VoCore module. Whit this circuit GPIO0 is put to low when PIR signal is up and vice versa. Must be taken into account that PIR sensor require +5V as power source, on VoCore can be used USB+ pin.

Before writing full Python program is better to test that everything is working as expected with a simple shell script, first step is login on VoCore via ssh and change directory to GPIO0 sys filesystem as follow.

root@OpenWrt:~# cd /sys/class/gpio/
root@OpenWrt:/sys/class/gpio# ls
export      gpio13      gpio18      gpio21      gpio24      gpio7       gpiochip0
gpio0       gpio14      gpio19      gpio22      gpio25      gpio8       gpiochip22
gpio12      gpio17      gpio20      gpio23      gpio26      gpio9       unexport

If we see an output like the one above we are in the right place and next step is to change dir  to gpio0.

root@OpenWrt:/sys/class/gpio# cd gpio0/
root@OpenWrt:/sys/devices/10000000.palmbus/10000600.gpio/gpio/gpio0# ls
active_low  device      direction   edge        subsystem   uevent      value

Two files are important for us, direction is the first one. We need to put the string “in” inside to this to set GPIO0 in input mode (we need to read from it). The other one is value, value is 0 when GPIO0 is low and 1 when high.

Coming to the script we can use the one below, it simply read value every second.

while  [ 1 ]
  cat value
  sleep 1

Executing it console shows something like:


0 mean PIR is sensing motion, else nothing is moving around it, all works fine!

Becoming a smart sensor

Now the code, I found an already made wrapper for interacting with GPIO made by Stefan Wendler and to not reinvent the wheel I use this, is called DigitalIO and I put it on github with all the code of this article.

This wrapper makes really simple to read GPIO status, with the following five line of code we can print on console the GPIO status read every half second (something like we made with shell script).

pin = DigitalIO.get_input(GPIO0)
while True:
    read = pin.state()
    print "GPIO0 state = " + str(read)

Last piece of code we need is the one used to send the notifications, we make a function to solve this task later used in final code.

def sendNotification(token, channel, message):
	data = {
		"body" : message,
		"message_type" : "text/plain"

	req = urllib2.Request('http://api.pushetta.com/api/pushes/{0}/'.format(channel))
	req.add_header('Content-Type', 'application/json')
	req.add_header('Authorization', 'Token {0}'.format(token))

	response = urllib2.urlopen(req, json.dumps(data))

With all piece in our hands it’s time to assemble all together and make real our smart sensor.

pin = DigitalIO.get_input(GPIO0)
while True:
    read = pin.state()
    if read == 0:
       print "Something move"
       # NOTE: API_KEY and MYCHANNEL name must be updated with values
       #       created in pushetta web site in the previous steps
       sendNotification("API_KEY", "MYCHANNEL", "ALARM!!! Something move")
       print "No motion" 

Isn’t a “production ready” software but a good starting point to make the real one. A small problem with this code is it send a push notification for every motion it detects. This can generate many notifications and Pushetta protects for this problem blocking requests if these are too frequent. This can be simply addressed recording last notification sent and send another one only some time has passed, I leave this as an exercise for the reader.

Here the full code.


Push notification from Arduino Yún

I have often wished a system to send notifications to cell phones without paying for it (ie SMS) or using emails.

Major mobile operating systems include those that are commonly referred to as push notifications and slowly these are getting available also on Desktop system. The use of push notifications is not trivial because every system (or at least the major ones) requires to develop a custom App as receiver of notifications.

Simply put, notifications aren’t like SMS, where knowing the phone number is enough to send a message, no!! You need to develop an App and use a server provided by manufacturers of mobile operating system (ie Apple, Google, Microsoft, …) but this isn’t enough there are also some security requirements like digital certificates and other pagan rituals.

Back to the top what I needed was a simple notification system and looking around I was not able to find one, so I made Pushetta. The opportunity came from the integration of my pellet stove in Domitio, my home automation system. One of objectives was to get notified when pellet level was below a threshold, this information is important because some stoves fails to start,  when refilled, if pellet has been previously completely exhausted (mine is one of these).

Pellet Stove
Pellet Stove

So, Pushetta is a simple system I made to send notifications to mobile phones (and also desktop in future), components are:

Typical use case is:

  • User interested in send notification register on pushetta.com
  • He /She defines a Channel, that is a node where send notification
  • User wants to be notified downloads the App
  • By the App he seeks interested channels and subscribes them
  • Every time a message is “pushed” to a channel subscribers receive it

Back to my stove I made a custom shield for my Arduino Yún to interact with it, this interfaces Arduino with a ultrasonic sensor that measure pellet level and some relays to controls start and stop of the stove.

Stove controller
Stove controller
Ultrasonic sensor
Ultrasonic sensor

So, stove controller continuously measures pellet level and when under a threshold uses Pushetta to send a notification. Sending notification from Arduino it’s really simple, nothing can explain it better than show a trivial example.

Sample sketch
Sample sketch

Example shown in picture is a modified version of the “Button” example found in Arduino IDE, in this version (made for Arduino Yún) when button connected to pin 2 is pressed a push notification is sent. In my stove automation system I use the same code to send notification when pellet level goes too low.

Pushetta isn’t limited to Arduino, it can be used virtually from any system can make an http post with a json payload. I used it also in an experiment with Raspberry Pi where I made a simple face recognition software who sends a push notification if I’m the subject in the camera.

I’m looking for beta tester because Pushetta is a “spare time” project but I would like to transform it in a production level software, look at www.pushetta.com if You can help me.

Making a simple Robot

Making a robot is a big challenge, also when You say to yourself “I make only a simple robot” simple will be not so simple.

I started making the “simple robot” mainly because I like to make things, and I like more to make things that move. For the first version I decided to concentrate my efforts in electronic and software, for this I bought a cheap robot platform for mechanical platform (this one).

I gave to myself some goals:

  • Make a WiFi connected robot
  • Make use of websockets for the control interface
  • Make the robot speech
  • Use some simple form of shape recognition

I made many projects based on Arduino but this time I looked for something more powerful, looking in my “stuff drawer” I found a beaglebone (white one) and I choose her for the brain of the robot.

BeagleBone is an incredible platform, it can run various OS like Arch Linux (default), Ubuntu and many others. One thing that made BeagleBone a little “special” compared to others it’s expansions capabilities (65 GPIO, 8 PWM, 7 Analog input, …) and a feature I found only in this board : PRU.

PRU is acronym for Programmable Realtime Unit, BeagleBone has two of them. Essentially PRU are autonomous chip with a specific assembly instruction set capable of performing realtime task, they run separately from main OS but can communicate with it using shared memory.

PRU are essential to make tasks with high precision time constraints, like make a pulse wave modulation or, as in my case, to read short pulse from a PING))) sensor.

PING))) sensor from parallax is cheap and theoretically really simple to use, this is true for example with Arduino but using it with BeagleBone make things a bit more difficult. This sensor works emitting an ultrasonic signal when the board send a short signal on trigger pin (40Khz), to misure distance board have to read the echo response duration. Here is where things get complicated.

Using a GPIO to read an hight frequency signal and pretend to precisely measure it is really optimistic. Isn’t a hardware problem but more a software one. GPIO on BeagleBone are handled by operating system (Linux), this is not a realtime OS so software scheduler can’t grant a precise response time to an hardware event.

In a next post I’ll show how to use PRU in BeagleBone, stay tuned!

A Raspberry PI based Arcade

Word “videogame” is for me a big piece of my youth. I spent many hours playing with arcade games when I was young and many of them are still impressed in my mind.

For other like my grew up in the 80s a screen like this:


are immediately are commented out with something like “AHHH!!! Bubble Bobble what a great game!!”. Yes it was and in a nostalgic day I decided to bring these day to a new life.

Today it’s really simple to play with these old games, You can install MAME in one of it’s flavours and look around for game’s ROM (note: isn’t legal to own ROMS file of games You don’t own). But I was looking for something more, I was looking for reproduce THE FULL EXPERIENCE.

What I wanted was to reproduce the experience of arcade game and for this was mandatory to make one. So I made a custom arcade game cabinet, indeed I made a miniature version of it.

In the Internet there are many projects about making a custom arcade machine but I tried to make one from scratch. As hardware platform I used a RaspberryPI with a custom Linux distribution specifically made for this kind of games : PiMAME. I made the cabinet laser cutting some MDF wood, I don’t own a laser cut machine so I made the CAD drawing and I used vectorealism, a really good online service for laser cut and also 3D print.

First prototype isn’t really cool but making it gave me a lot of satisfaction and experience, this is only a starting point because I’m planning to make a second version with two player support and more attention to aesthetics.

This is not the end, this is only a starting point. With experience I gave making the first prototype now I planning to make a second device with more ambitious targets:

  1. Two player
  2. More powerful board (I’m evaluating many like BeagleBone Black, Phoenix A20,…)
  3. More attention to cabinet esthetic
  4. Simple to build, I’m thinking about a system where cabinet can be assembled like an Ikea one

I’ll post in my blog progress of this second phase.



Domitio is a classic always open project with a no real end. Its purpose is to automate some house tasks like:

  • Handling sprinkler timers
  • Handling house temperature
  • Managing electrical power

Some tasks already works some other partially and others are still in development. Domitio is deliberately an heterogeneous system, I used (and presumably I’ll use) many different devices and technologies for many reasons. First because advancing slowly technology evolve and solutions used in past are overcome by new (and often cheap) ones.

An example of this is the sprinkler controller, this was made (about three years ago) using a Fox Board G20, today most likely I would choose a different hardware and maybe a different approach. Evolving speed of technology is a common problem in industry, in my case without market requirements I can choose what I like when I like it, but in a industrial approach this isn’t the right way.

Working with different technologies which contribute to the same goal it’s a good challenge because I need to face many problems. First I need a “glue” to make different parts communicate each other, this glue is made by protocols and software.

For the software I chosen  Python as main language, but I used also C/C++ for some parts. Talking of protocols I started looking for one specifically made for domotics, I found many but  I got the impression that often are vendor specific, closed or based on obsoletes ideas. Out of curiosity some of these are X-10, UPB, Z-Wave, Insteon… Abandoned these protocols I decided to use the today ubiquitous TCP/IP as transport and web protocols as Application layer.

At this time Domitio is made of these components:

  • Sprinkler control (fox board G20)
  • Gas boiler controlled by Arduino with bluetooth shield
  • Pellet stove controlled by Arduino Yún