Category Archives: Connected Objects

HidNSeek iPhone app is out, Android on his way

A few week ago I’ve announced that I’ve started to help HidNSeek in their great attempt to provide a low consumption GPS tracker. As a member of the project, I’ve take part of the client and server backend. The first results are here: the HidNSeek app is available on the App store and the Android version is on the way.
The backend is based on the OpenSensorCloud platform (OpennSensourCloud.com) and handle all the interaction between the devices and the Sigfox network.
The client is a mobile application, that could interact with your device. You can create alert on Geofencing area, motion, you can get the latest positions of the device, and it is fully customizable with nice picture of what you are tracking. The App is already available on the App Store.

Simulator Screen Shot 24 oct. 2015 19.41.51

Simulator Screen Shot 24 oct. 2015 19.42.29

Simulator Screen Shot 24 oct. 2015 19.41.23

Simulator Screen Shot 24 oct. 2015 19.41.06

Orange Live Object experiment

orange
Orange announced yesterday several things regarding IOT and LoRa deployment. Part of the announcement was the Orange IOT LiveObject API, described as « a personalized and secure service that connects your objects to your business applications». Basically, it’s a service to store data sent by connected objects.

Usage

To use the API, you need to register as an orange partner. This is not very complex, but things start to be harder when it came to the datavenue service

There is a concept of Template, Datasource and Prototype. A Datasource can contains several stream of data (like temperature, position, etc..) and should represent typically a connected object. A template can pre-defined what kind of source are available on an objet.

API :
The API is classical. You can send data associated in every datasource, and you can retrieve them in a paginate way. In fact all the function are available through the API (and for most of them only through the API). I think that it could have been simplified a lot.

Documentation :
It’s clearly the biggest lack of the service. There is no start guide, or tutorial. Juste the raw API and some FAQ. You need to dig into the FAQ to understand things. For instance, there is no « how to authenticate »FAQ , but in the « What is an Orange Key » FAQ, you will learn that this key must be included in every request…

There are some Curl example of the API usage, which is good, but they are hidden in the Website (they are at the bottom of the datasource detail, and you might need to refresh your browser to see them).

SDK

There are many ‘SDK’ available: Java, Node.js, iPhone, Android, C (which seems to be empty for now). In fact, too many regarding the current maturity of the product. They seems to have been done very fast and are not very explainatory. For instance, the one I’ve used (Node.js) was not fully debugged despite the fact it was not been modified since 7 month, and had on the other hand a quite good documentation.

Support

I had very good and reactive feedback from Orange support team, which is obviously great

Pricing
No information on it on the Web site
My feeling : Orange should have spent more time in creating documentation than various client

Conclusion
What is it for ?
That’s the biggest question. You can use this to store your information, but there is basically no way to extract some meaning from this information. There is no service around them, even the basic ones. For instance, you can’t even know how much data has been send to a specific stream.

I wanted to export some of the data generated from the OpenSensorCloud platform to the Orange one, but as it as impossible to do something with the data, I had to stop for now my experiment.

What is expected :
Just like other services available, the minmum should be the ability to extract some value of these data :
Display graphical value :

  • that’s usually the first service that come with such offering
  • Be able to trigger some event based on some condition
  • Be able to operate on large volume of data (both on the same stream, or on multiple stream). Example : average / stream, average on multiple stream, etc..
  • Etc…

The Orange site claim for instance that you can “View your connected objects’ data on your existing business applications or personalized interfaces », but no clue on how to do this. I assume that it should be possible using Orange services

The service seems to be far from being operationnal, at least for the average user (I guess it might be different for their « partner ») so let’s wait a little bit and see how this will evolve, and especially how the competition will react . Ovh launched his Time Paas serie a few month ago (in an experimental way) but was more mature than current Orange offering.

Why I’ve joined HidNSeek project as technical advisor

A few month ago, I’ve discovered a great project that just started on Kickstarter : HidNSeek, which was an innovative tracking device, based on Sigfox. If you read my blog, you probably now that I am a big supporter of Sigfox and I find their approach very smart. I met the HidNseek team during the last Connected Object conference, and we immediately had a good fit.

HidNSeek

HidNSeek is a GPS tracker, and thanks to Sigfox, the energy consumption is very low and you can have several monthes of activity without charging. The other advantage is that you don’t need any GSM subscription, while having a good coverage .

The campaign was successful, and I’ve proposed to help them and support the development. I will take part of the mobile client development (iPhone/Android) as well as the backend, and use my previous experience both in mobile and big data to make this a great product.

The traction is incredible, and there is a lot of great on-going discussions with potential partners and customers, beyond the initial Kickstarter campaign in the #IOT field.

I am a strong believer in the potential of connected object not only in B2C markets but even more in B2B.

So let’s wait a little bit to see the first results of these efforts coming into the market…..

Africa

Does IOT will be the next leap for Africa ?

What is really exciting with new technologies is that some evolution can be sometime revolution, especially in Africa. Cell phone for instance, took a long time to evolve in Europe, from early attempt (‘Radiocom 2000’, BeBop in France) to GSM, and then UMTS. In most of Africa countries, which were totally uncovered with fixed phone, GSM and UMTS was a technology gap: 40 years has been catch up, and now most of the African countries are well covered, and people have probably a better access to telecommunication than electricity! I am quite sure that in many of top African cities there much more smartphone per habitant than in Europe.

This jump generated a lot of creativity in related services, the biggest one being mobile money, which is much stronger in Africa than in any other continent. But there are plenty of others services, mainly SMS based.

I think that that it will be the same for the Internet of things, or connected object. With new innovations coming in this space, and due to the current status of ‘connectivity’ in Africa, and thanks to the fact that low bandwidth technologies like Sigfox or LoRa will reduce connectivity costs.

Some area that could really boom with IOT :
Agriculture : This is usually the biggest part of the economy, with numerous smaller actors. Low cost object will be useful to provide feedback on fields parameters, for self-system irrigation for instance.
Government infrastructure: it’s very hard to monitor all infrastructures deployed, and due to hard climatic condition there is usually a fast degradation. IOT could help them to monitor such infrastructure and be warned when they need to do something.
Security : security is usually a big problem in emerging country. Connected object will allows to provide real time position of persons and goods (like containers, trucks, …) and will allow to trigger alarms that informs of an immediate danger.
Medical : usually poorly developed, connected object would help to provide real time information on patients, and could allows remote infrastructure to be better handled.

Even if the relative price of connected object will be high compared to the average salary, the added value in these countries is much higher than in many of eastern ones.

I think that African government should support efforts in this direction, and push operators to deploy the needed infrastructure to cover all rural area, and this will push forward Africa in the 21st century.

Of course, there are plenty of related challenges, the biggest one being the access to the electricity but momentum is here.

arduinopi

Raspberry or Arduino: how to choose?

arduinopi
When you look at a platform to play with connected objects, these are the two stars. But which one to choose? Especially when you look at the spec, there is one much more powerful than the other, so why we should bother of the Arduino ?

So we will try to understand which one is suited for what kind of project, in order to help you to do the right choice.

The raw specs are the following:

Arduino Raspberry
RAM 2 kb 515 Mb
Program size 32 kb Up to 32 G, depending of SD card
IO output 14 Digitals, (6PWM), 6 analog 8 digital 17 GPIO
CPU 16 Mhz 700Mhz
Price 25 euros 30 euros
Connectivity None by default, Ethernet/Wifi using shield or more powerful Arduino cards Ethernet, Wifi using an USB key

So definitvely raw spec of Raspberry are better than Arduino’s. But CPU and memory in IOT are not the only criteria to choose.
In fact, it depends totally from your type of project. If you want something close to the hardware, simple, cheap (a single arduino chip is around 3 euros).
To help you, here is a more detailed tab of various area of interest of each:

So, if your project is ….

Arduino Raspberry
Close to the hardware +++ +
Require analog input/output +++ -
Require CPU power - +++
Require Internet connectivity + +++
Require Screen output + +++
Needs to use USB devices - +++
Needs to store a lot of data + +++
Need to work on battery +++ +
Need to work alone +++ ++
Need to boot quickly +++ +
Need cheap device +++ ++
Require high level language
(python, javascript, ruby,…)
- +++

Raspberry is not expensive, but much more than an Arduino when it comes to industrialization. You can have an Arduino up an running for less than 3 or 4 euros, and you can freely build your own layout.

So for exemple :

Good Arduino usages
- autonomous gps tracking device
- small connected devices
- house sensor (gaz, electricity, intrusion, etc…)

Good Raspberry projects :
- home central automation
- media center
- ip camera recorder

Project that could be both :
- autonomous robot
- “complex” connected object , .i.e. nest like

Some project could need both. A good example is home automation, you can do simple capture device using arduino, and collect data in a master system based on Raspberry

Both are great device to play with, so I strongly encourage you to test both and to do your choice, depending on your project.

Who needs an operating system for the Internet Of Things?

Recently, there was a rise of so called « operating systems for the internet of things ». To name a few, there is Arm, Contikit, Riot. Even Google and Microsoft wants to be in the race. This is probably the worst thing that could happen to the IOT.

Internet of things is about simple interactions, but also about communication.

As a user of IOT, you don’t care about the OS of your ” things ” but should you care as a developer ?
Connected devices are for most of them simple devices, that does one thing that does it well. Price is a key factor, and Arduino as the major prototype board for the IOT shows us the path. Simple, no OS, just a few functions to interact with the board and the external world, and no real OS.

The biggest issue is about communication and that’s the today weakness of IOT. To be able to do communication you need something much more powerful that was is needed to interact with the user. In Arduino for instance, you embedded a full Linux based system just to be able to do Wifi with the rest of the world (Arduino YUM).
Of course, some connected devices will require some complex and powerful OS, typically those with strong interaction with users but that’s only a fraction of the IOT
Others, like Spark.IO or Electric Imp try to solve the system by integrating at the chipset level the communication stack.

So we don’t need another OS, we need communication stack and protocol, to be able to discover, interact, commands objects. This is the « real » OS for the IOT, and this have yet to come.
The basic list of features should be:

  • simple
  • secure
  • light
  • provide a discovery and registration protocol
  • ability to send and receive information
  • pull AND push! (push is really key here)

There are some candidate for this, but no real winner so far, unless I’ve missed something!

Power monitoring using Arduino

Another small but interesting project is power monitoring usage using Arduino.

The idea was to be able to get instant feedback on my home power consumption.

So I bought some CT sensor from EBay (9 euros/each) . The only problem is that I have a three phased installation. So instead of two phases as usual, (three wires) there are three phases and four wires.

The installation was made in two steps: first a breadbord connected to the CT sensor and the arduino, sending the information every ten seconds on OpenSensorCloud using an Eternet Shield.

EMon
As this worked fine, I’ve bought an a shield instead of my breadboard. This cost little bit but the result is much better than a custom one.

The advantage of having a three phase installation is that you can display each phase individually, so it gives you much more indication on what is currently hapenning. For instance, I no that on Phase 3 there is the heat pump installation, on phase 2 the kitchen, etc…

The result is visible here, you have a dashboard showing the instant consumption on each phase, as well as the daily total :
Emon

The sketch is here:
ArduinoCode
As a bonusI wanted something to display these data in the living room, so I used the spark core that I bought as an #IoT geek: the core is connected to the server and receive the data every ten seconds. This is probably not the optimum configuration (Ethernet -> Server -> Wifi -> Spark core) and I plan to do an updated version if a different connectivity. In the meantime, the result is quite nice: the core display the total consumption and the phase consumtion ona small olde display, as well as the usage graph of the last ten minutes.

The RGB led of the core is also used to provides feedback on power usage: green -> low usage, red, high usage

Bo_RURHIUAEGdMI_002

First SigFox program with Arduino (Akeru)

Following my previous post, I’ve started to explore Sigfox capacities with a small first project. The idea was to make a low powered GPS tracker. So I’ve just added a 10€ GPS adapter from China and wrote my first sketch.
The idea is to make a simple GPS Traker, ideally not using SMS but being able to send his position from anywhere, with of course very low energy consumption. This first version is just a proof of concept so we are not yet focused on the consumption. The data are then send to the OpenSensorCloud platform (feel free to register! )

photo(2)

The programe is quite simple:
1. initialize everything
2. wait for the GPS to get fix position
3. send it to server through Sigfox network
4. wait 10 min
5. start at 2)

We need to wait 10 minutes before sending another 22 bytes messages, it’s a Sigfox limitation and the tradeoff between low consumption, high coverage, and size. I don’t see this as a big issue for many usage, but for sure, it will add some interesting challenges

In short:

// include the library code:
#include <Akeru.h>
#include <TinyGPS.h>
#include <SoftwareSerial.h>

// initialize the library with the numbers of the interface pins
TinyGPS gps;
SoftwareSerial ss(8, 9);  // GPS RX is set on pin 8

void setup() {

  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  Akeru.begin();  // Not sure it's neded, as I need to call it again later
  delay(1000);
  ss.begin(9600);
  // Init modem
  delay(1000);
}

// int is 16 bits, float is 32 bits. All little endian
typedef struct {
  float lat;
  float lon;
  float alt;
} Payload;


void loop()
{
  Payload p;
  float flat, flon;

  gps.f_get_position(&flat, &flon, &age);
  p.lat=flat;
  p.lon=flon;
  p.alt=gps.f_altitude();
  
  if(flat==TinyGPS::GPS_INVALID_F_ANGLE){
    delay(1000);
  }else{
    // Note Seems that we need to call Akeru.begin() again or
    // further call to isReady or send will be blocked...
    delay(1000);
    Akeru.begin();
    delay(1000);
    Serial.println("is ready:"+String(Akeru.isReady()));
    Serial.println("Sending");
    bool status=Akeru.send(&p,sizeof(p));
    Serial.println("done result:"+String(status));
    // Wait for 10 minutes before sending another one
    for(int i=0;i<600;i++){
       delay(1000);
    }
    Serial.println("wake up");
  }
}

Of course, the program need some improvements, like waiting to have more satellite fixed before seding the first message, but let’s keep it simple.

The full source code is available

I had some minor issue, it seems that the Akeru API needs to be “reseted” before sending new data

The payload is quite simple, just a structure with three float: lat , lon, and alt (the last one might not be the most interesting but it was just a test).

The most interesting things is that now opensensorcloud support Sigfox devices. Sigfox allows you to send data in a limited way. You are allowed only 22 bytes per message, so no way to do ascii or json. So you usually send binary information, typically raw C or C++ structure. Then you have to decode them on the server.
Hopefully, OpenSensorCloud provides full support for such feature:
When creating a sensor for an Akeru enabled device, you just need to specify the format of the payload, this will be automatically converted to corresponding sensor values.
SigFoxConf

Make sure that your sigfox device id is well defined
Format are described in a generic json way, for instance, in may case, the payload contained 3 float field, so format is the following:

[
  {'name':"lat",'type':'float'},
  {'name':"lon",'type':'float'},
  {'name':"alt",'type':'float'}
]

As I wanted to map this to a “Position” object, and not to thre sensors, I ad to add a little bit of definition


[{'name':'pos',
  'type':'position',
  'struct':[
   {'name':"lat",'type':'float'},
   {'name':"lon",'type':'float'},
   {'name':"alt",'type':'float'}
  ]
 }
]

As a Sigfox callback, put the URL of the OpenSensorCloud callback, like this

http://api.opensensorcloud.com/device/sigfox?api_key=YOUR_API_KEY


Replace with the value of the platform.
OpenSensorCloud expect two extra parameters: device value, with the device_id you’ve just entered before, and data with the binary payload.

The API_KEY is visible on your profile,
And let’s go

The map location appears on the platform

You can see the result on the
Real Time Dashboard live
capture

In next part, we will add geofencing and twitter features thanks to the Trigger functions of the OpenSensorCloud platform…

Akeru board completed

Akeru unboxing!

SigFox logo
Juste received my Akeru board from Snootlab today, and here are my first reactions. Akeru is a Arduino with a SigFox chip inside, allowing to send (small) messages – shorter than sms – but with very low poswer consumption.

Here is some screen shot of the kit: looks nice, close to a Uno, but need a little bit of soldering

photo 3

photo 2

A few minutes later, it’s done, the board is up and ready to be plugged.

Trying to follow the instruction of Snootlab, I’ve downloaded the FDTI drivers, and connect the board, and….nothing happens….no led blinking, nothing

So I started to investigate: in fact, it appears that the driver for mac seems to have a lot of problems. I need to plug/unplug several time to start the usb driver. But even, the board was not visible.

So I used a PC to do the same manipulation. Good news, the board was recognized, and wake up, and I was able to program it but the driver was very unstable, I had to plug/unplug several time to program the board.

But finally, I was able to do it, and to send my first message to the Sigfox network and receive it to . I still need to use the Snooplab proprietary gateway (actoboard) which is quite limited: it can not pas directly the raw SigFox message as raw data, you need to specify one and only one format, which is not very practical.
Also, there is no statistic about your usage. You should not send more than 140 messages a day but there seems no indication of your daily usage. Beyond the 140 messages, your are limited but also you have to paye some “proportinal penalties”, which seems to be contrary to the limitation.

But back to the Mac , impossible to make it works: the driver have problems to load, and even when the loaded, the card was not recognized. So the bad news is that I can not program it using my everyday computer (MacBook air, OS X 10.9.2) and I have to go back to the PC

So I’ll start to play a little bit with it, and keep you updated with the results!

Playing with Arduino: real HashtagBattle Twitter display

I just started a few days ago to play with Arduino.

First, I must say it’s a great platform: setup is easy, samples are great. I’ve made some embeeded development by the past, and I would dreamed of such platform!

So here is my first small project: an “Hashtagbattle display”

Real World hashtagBattle
The idea is to show the result of an Hashtagbattle on Twitter using a something more physical, in that case an arrow indicating the tendance of the results.
So we are couting the number of tweets containing hashtag a (let’s say “iphone”) and compare it to the numbers of tweet containing hashtag b (let’s say “#android”) and the direction of the arrow depend of the result. If we have the same amount of hashtag b and hashtag a, the arrow will indicate the center.

The small difficulty here was to use the streaming API of Twitter to do this real time

The board:

- the board is quite simple: there is a servo that will display the arrow direction, and two leds, a red and green, each one flashing when there is on tweet on HashTag A (red) or HashTag B are coming

sketch
The software:

As I currently have only an Arduino UNO, there is no direct connection with the internet. But I use the PC for this task, and communicate with the board through the serial line.
So the PC sends every 100 ms a line with 3 informations:
- the angle of the servo
- 0 or 1 to indicate if first leds need to be enabled
- 0 or 1 to indicate if second leds needs to be enabled

For instance:

32 1 0

Will tell that the servo need to be of 32° and red led needs to blink

So the program is the following:

require 'tweetstream'
require "serialport"

input=ARGV.shift || "#bordeaux,#strasbourg"
#params for serial port
port_str = "/dev/tty.usbmodem1411"  #may be different for you

sp = SerialPort.new(port_str, 9600, 8, 1, SerialPort::NONE)

TweetStream.configure do |config|
  config.consumer_key       = '<YOUR KEY>'
  config.consumer_secret    = '<YOUR CONSUMER KEY>'
  config.oauth_token        = '<OAUTH TOKEN>'
  config.oauth_token_secret = '<TOKEN SECRET>'
  config.auth_method        = :oauth
end

@client=TweetStream::Client.new;

total=0
last=Time.now
words=input.split(',')
flags=Array.new(words.size)
buffers=words.map{|w| []}
sp.puts "512 0 0" # reset the servo
@client.track(words) do |tweet|
  begin
    search=tweet.text.downcase
    words.each_with_index do |word,i|
      if search.include? word
        flags[i]=1
        buffers[i]<<tweet
      end
    end
    if (Time.now-last)>0.11
      begin
        ratio=(180*buffers[0].size/(buffers[0].size+buffers[1].size)).to_i
        str=ratio.to_s+" "+flags.join(' ')
        puts str
        sp.puts str
        last=Time.now
        flags=Array.new(words.size,0)
      end
    end
  end
end

Note that you canstart with parameters:

ruby notifyTweets.rb “#apple,#orange”
or use words instead of hashtags:
ruby notifTweets.rb “apple,orange”
The program needs to be run on the PC where the arduino is connected!

The Arduino part is here
We just se the serial line, wait for a line, and extract the informations from it.

#include <Servo.h> 
int ledPin=13;    // select the input pin for the potentiometer
int nbLed=2;
Servo myservo;  // create servo object to control a servo 

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  for(int i=0;i<nbLed;i++){
   pinMode(ledPin-i, OUTPUT); 
  }
 myservo.attach(9);  // attaches the servo on pin 9 to the servo object 
}

# Utility function to get a value from a string at a given pos
String getValue(String data, char separator, int index)
{
  int found = 0;
  int strIndex[] = {0, -1};
  int maxIndex = data.length()-1;

  for(int i=0; i<=maxIndex && found<=index; i++){
    if(data.charAt(i)==separator || i==maxIndex){
        found++;
        strIndex[0] = strIndex[1]+1;
        strIndex[1] = (i == maxIndex) ? i+1 : i;
    }
  }
  return found>index ? data.substring(strIndex[0], strIndex[1]) : "";
}


void loop() {
  if(Serial.available() >0) {
    String str=Serial.readStringUntil('\n');
    Serial.println("Read:"+str);
    for(int i=0;i<nbLed;i++){
      // look for the next valid integer in the incoming serial stream:
      if(!getValue(str,' ',i+1).equals("0")){
        digitalWrite(ledPin-i, HIGH);  
      }
    myservo.write(getValue(str,' ',0).toInt());
    }
  }
  delay(100);  
  for(int i=0;i<nbLed;i++){
    digitalWrite(ledPin-i, LOW); 
  } 
}

That’s all for this first project, was really fast to develop, thanks to Arduino (and Ruby!)