energievisible Archive

After being asked by several members of WoT the community and beyond to release the Energie Visible prototype, we finally managed to find the time to package it and now give it for free on the Web! To recap: the Energie Visible project aims at making the your energy consumption … visible!

We created a page to host the application, you’ll find the latest version and additional info there.

Note that it currently only works with the Bluetooth Ploggs and on Windows (XP or later).

The bundle you download there basically contains two applications. First is contains a Web of Things Gateway for the Ploggs (written in C++) which is discovering the Ploggs and making them available through a RESTful interface. Then, it contains a Web UI and datastore based on the great Google Web Toolkit and on the wonderful RESTlet.

The bundle contains the binaries but not the source code. If you are interested in getting the source code please contact us.

We hope you’ll enjoy the software! Note that it is provided “as is” without support. However, you are very welcome to use this blog entry to post your comments, bugs reports or feature requests.

EnergieVisible screenshot

All the medias in the world are talking about it, but we didn’t yet. We have an awesome announcement to.. well.. announce. Last week while Dom was busy eating churros and discussing about twittering chimpanzees, he was also preparing to go to a little village in Switzerland because he was told to go there for Energissima.

But why?

Because his project Energie Visible has won the Jade Nature award (and 10k chf with it), out of 20 other selected projects! The Jade Nature award recompenses an innovating project in the area of sustainability and protection of the environment. And that’s cool.

That’s awesome news, Dom, CONGRATULATIONS!!!!! It’s very encouraging for our work, and it clearly shows that we’re on the right track to make something so much bigger. If you all clap hands and do a standing ovation for the awesomeness of Dom, we’ll tell you more about it.

Read about it here, or here, or here.

Dominique Guinard and Vlad Trifa, Towards the Web of Things: Web Mashups for Embedded Devices

Dominique Guinard presents this paper. (You might wonder how I manage to both present it and blog about it, well this is thanks to Ghislain Fourny who wrote a summary of my talk).
After introducing a couple of smart objects and noticing that the audience is uncool as nobody has a Poken, Dominique asks how we are going to deal with the 1000+ smart objects each person is going to have within the next 5 to 10 years. Communicating with these objects could be made easier with Mash-ups.

The agenda will consist of a discussion of the Web of Things, the introduction of a Web-oriented architecture of the real world, the demonstration of two prototypes one of which is going to crash, and finally real-world Mash-ups.

Architecture:
1. Resource design: each resource is accessed through a URL, e.g., http://webofthings.com/spots/2/sensors/light
2. Representation design: XHTML would be the default, JSON would be better for parsing and XML would be ideal for integration
3. Uniform interface: the HTTP protocol does the job with GET, PUT, DELETE, POST. HTTP headers tell what data is being sent, and HTTP bodies contain the data.

The integration could be done through a smart gateway which discovers the devices, understands their API and exposes them as a RESTful API. Dominique mentions that Nokia is going to introduce a home control center, which will, so he says, fortunately for his work be proprietary. As opposed to the integration with the smart gateway, a direct integration would consist of smart objects having all a RESTful API.

Dominique attempts a demonstration. He turns on a sensor which gets an IP address. Two LEDs indicate that it is on the web. With an AJAX website developed with the Google Web Toolkit, Dominique selects the sensor URL and explores its services, described using JSON.

The goal of the next example is to integrate smart plugs (Ploggs) thanks to the smart gateway. Dominique plugs one of them to his smart phone, the other one to his computer and starts the gateway. Using three rounds of bluetooth, the gateway identifies all phones, well, plugs (as of course everybody in the room kindly turned off their phones upon Dominique’s request). Then Dominique navigates to the gateway URL and notices with surprise that his computer consumes 80W.

In order to compose real-world Mash-ups using these devices and this architecture, it is possible to use Yahoo pipes, Microsoft Popfly, etc. For the example, he uses his own program showing diagrams of the consumption of his devices. After 20 seconds, the data are plotted and Dominique notices that his smart phone only consumes a cool 4W.

Eventually, he introduces a physical Mash-up with an ambient energy meter, which is a Mash-up made of Ploggs, Sun Spots and gateways.

Dominique concludes by considering REST as a suitable approach for small embedded applications, although it would be nice to have asynchronous mechanisms so that they are investigating protocols like XMPP. Mash-up editors would also be nice to have.

The video of the prototype in this presentation is available on: http://www.youtube.com/watch?v=1H49H1pPSBI
The presentation is available below:

Bibtex:

@inproceedings{dguinard:wotMashups:2009,
author = {Dominique Guinard and Vlad Trifa},
title = {Towards the Web of Things: Web Mashups for Embedded Devices},
year = {2009},
month = apr,
booktitle = {Workshop on Mashups, Enterprise Mashups and Lightweight Composition on the Web (MEM 2009), in proceedings of WWW (International World Wide Web Conferences)},
address = {Madrid, Spain}
}

I’m pretty sure that by now you got the fact that the Energie Visible project is one of our favorite use-cases for the Web of Things. In this project we apply the concept of smart things with webservers and RESTful APIs to create a plug-and-play energy monitoring system for your home or company.

In order to better illustrate the application and for us not to have to carry a printer, a kettle and a… fridge around for each demo, we shot a video of the prototype.

The end of the video also contains some more technical insights on the structure of this project and of the web of things in general.

Enjoy! (PS: choose the HQ version, because it is rather hard to read the screen-casts on the other one, PS 2: Thanks to Iulia Ion for the great “fridge opening” acting!)

Together with people (Dominique Guinard, Markus Weiss and Tobias Graml) from the BitsToEnergy lab of ETH Zurich we are actively working on a Web of Things system that helps people to better understand their energy consumption.

A major burden for people, who want to save energy at home, is for them to identify how much energy is consumed by different appliances. How much does my computer consume in operation / when it is powered off? Is the consumption of my energy-saving lamp significantly lower in the long run than the normal lamp I’ve got there? Such questions are key to understand where energy can be saved without too much effort. Currently available solutions, such as pluggable power monitors, are helpful, but do not fully fit the needs of individuals. They lack demonstrating power such as being able to compare consumption on a centralized screen, in an appealing manner.

In this project we implement a system that’s very simple to set up and that can be used in everyday life. All you need to do is to get a number of Ploggs and plug them on the appliances you want to montior. Then, our software finds all the Ploggs in the environment and makes their functionalities accessible through a dynamic web page as shown below:

screenshot_english_correct

The interface offers six real-time graphs. The four graphs on the right side provide detailed information about the current consumption of all the appliances currently available (i.e. attached to a Plogg). The two remaining graphs show the total consumption (KWh), and respectively a comparison (on the same scale) of all the running appliances.

A more geeky description of that system is available in this post.

The software will soon be available for download here so stay tuned!

Hi guys and gals,

Remember not long ago I was talking about our first real-world implementation of the WOT concepts in an energy monitoring application: Are you Energy Efficient? Sense it the WEB way, well this system, now named “l’énergie visible” or “visible energy” was selected amongst a number of projects for the Jade national energy award in Switzerland.

It is now entering the final selection phase, 20 projects are on the list. The folk can vote for the projects on Jade Award. So if you like the Energie Visible project then do support us, vote for project 13.

More news on that when the selection occured…

Just felt like sharing with you one of our latest prototype which we created for a private foundation working in the field of energy awareness and sustainability in Switzerland called Cudrefin02.

I think that a major burden for people, who want to save energy at home, is for them to identify how much energy is consumed by different appliances. How much does my computer consume in operation / when it is powered off? Is the consumption of my energy-saving lamp significantly lower in the long run than the normal lamp I’ve got there? Such questions are key to understand where energy can be saved without too much effort. Currently available solutions, such as pluggable power monitors, are helpful, but do not fully fit the needs of individuals. They lack demonstrating power such as being able to compare consumption on a centralized screen, in an appealing manner.
In this project we implement a system that’s very simple to set up and that can be used in everyday life. As a first step each device to be monitored is coupled to a Plogg . These cool sensor nodes are a combination of an electricity meter plug and a data logger. They offer a Bluetooth interface to retrieve the current or logged consumption, making them great for appliance-level monitoring.

In order to automatically acquire the logged data, we extended the basic functionality of the Ploggs to feature continuous measurements on a fine, granular, time basis. In addition, we developed an integration of the Ploggs’ measurements to a web-based user interface which allows for attractive visualization and control as well as integration of the data on the web.
Thanks to the good cooperation with Energy Optimizers, makers of the Ploggs, we got access to a C-language API that enables us to connect to the core functionalities of the Ploggs. Our first component is a C++ gateway that discovers and manages the Ploggs. In order to enable interoperability with other applications, the gateway embeds a web server (SHTTPD) and offers access to the sensors’ functionality through simple and structured URLs, the web way!

As an example the monitoring data of all the available Ploggs, can be retrieved by accessing the following URL:

http://webofthings.net/energymonitor/ploggs/*

The gateway then discovers the devices and returns the results in the form of a JSON document:
[{
"deviceName": "ComputerAndScreen",
"currentWatts": 50.52,
"KWh": 5.835,
"maxWattage": 100.56
}, {…}]

The approach, that makes an application’s functionality accessible through a simple and well-defined web interface is often referred as RESTful, and has several advantages over more traditional interoperability approaches such as classic WS-* Web Services. First of all it is quite straightforward to use and integrate: any application that can access the web can consume RESTful services and any sensor that has an embedded web server can directly push content onto the web. Secondly, the use of JSON instead of XML reduces the need for complex parsers and requires very little bandwidth.

The second part of our software architecture is in charge of presenting the monitoring data to the end-user. We needed the interface to be attractive, easily-accessible (no additional software to learn or install) and to display real-time data rather than snapshots. Thus, we decided to use a web interface. The implementation is based on the Google Web Toolkit (GWT), a toolkit for building AJAX applications, as well as the OFCGWT toolkit which offers a set of customizable graphs. Using GWT, our application is written in Java and then automatically translated into client-side javascript. This javascript initiates a connection to the gateway every few seconds and directly translates the JSON Ploggs’ results into graphs.
The attached screenshot is what the app looks like in action.

We are now trying to polish the whole application so that someone owning Ploggs could install it and run it within a few minutes. We’ll keep you updated about the advances and publish the code here as soon as we’ll release it!

screenshot_english_correct