Category: Eclipse

Categories
Eclipse IoT

5 Things I Learnt at IoT World 2016

Last week I attended IoT World in Santa Clara. It was a great event, and what was particularly exciting was to meet with adopters of Eclipse IoT technology who stopped by our booth. It just felt incredibly energizing (and even more so given I had to spend 2.5 hours at US immigration the day before the show, which was quite annoying, to say the least), and moments like this are why I love my job, really.

Here are 5 things I learnt at IoT World that I thought I would share with you:

→ Eclipse Wakaama and Eclipse Leshan are saving lives

thingwaveThat tweet I reshared above was done right after a discussion I had with Jens Eliasson from Thingwave. Thingwave is a company that is building a connected device that aims at monitoring vibration in rock bolts used in the mining industry, in order to detect anomalies such as excessive strain.

Their solution, called the Smart Rock Bolt, is attached directly to a bolt (see picture) and uses LWM2M (thanks to open source implementations Eclipse Wakaama and Eclipse Leshan) and IPSO Smart Objects to expose sensor data that a gateway collects and analyzes.

You can read more on the Smart rock bolt on Ericsson Research blog.

→ MQTT remains an IoT protocol of choice

mqttorgIt was only one hour or so before the end of IoT World that my colleague Ian and I found out that just next to our booth was a company, infiswift, building an IoT platform around a highly-scalable MQTT broker. But in fact, it is no surprise, since pretty much every person we met, and many of the companies exhibiting, were either building solutions using MQTT or already very much aware of its capabilities. So we should have just guessed about infiswift 🙂

→ Eclipse IoT technology to be shipped with a Kickstarter project that raised $1.7M

pine64bw

Pine 64 is a Raspberry Pi-like single board computer which aims to be a very affordable 64-bit computing solution, with a price tag starting at just $15.

I met Daniel Kottke, one of the persons involved with the Pine 64 project (and employee #12 at Apple, where he participated to the H/W design of the Apple I), and this is from him that I learnt about the project and its incredibly successful Kickstarter campaign. What I found really exciting is that Pine 64, in its “IoT Package” version, will ship with openHAB pre-loaded on its SD card. And as you probably know, openHAB is running on top of the very popular Eclipse IoT project Eclipse SmartHome.

smarthome

→ Eclipse Kura becoming a framework of choice for building IoT gateways

kuraFrom Litmus Automation, to Eurotech, to the likes of Microsoft or Cisco now looking at Eclipse Kura, it was great to see that many companies are endorsing it as a framework of choice for building modular and extensible IoT gateways.

→ Consumer IoT leaving the headlines

All in all, IoT World was a very good conference. I am looking forward to next year’s edition and to see how the IoT industry will have evolved by then.

This year it was pretty clear that the consumer IoT market is starting to consolidate, and that everyone’s attention is shifting towards Industrial IoT (as an example, this year’s hackathon was sponsored by GE).  And how could I complain to see that end-consumer gadgets like connected dog collars are leaving room to more useful, like Thingwave’s connected rock bolt, or to see that the likes of GE are working on kick-ass Industrial IoT platforms built on top of open source and open standards such as CloudFoundry or MQTT.

By the way, from one conference to the other: this week I am in Austin for OSCON’16. If you are attending, please stop by Eclipse Foundation booth to say hello!

Categories
Eclipse IoT

Installing the Zulu open source Java Virtual Machine on Raspberry Pi

I’ve recently been playing with the early-access version of Zulu Embedded for ARM32. Zulu is an open-source and certified build of OpenJDK. It is a great alternative to the JRE from Oracle as it does not requires you to pay any licenses, and it is also a huge improvement over the OpenJDK build you can get off the Debian repositories, which is not really optimized for ARM (and that’s a euphemism! :smile:).

Before giving you more information on my experience running Eclipse IoT projects on Zulu in subsequent blog posts, here’s a quick tip for anyone interested in installing an alternate JVM on a Raspberry Pi (or pretty much any Linux-based environment, really), and switching between default JVMs easily.

Download the Zulu JVM

At the time of writing this blog post, Zulu for ARM32 is only available through an early access program. Once you’ve downloaded your Zulu archive, you need to unpack it somewhere on your system (in a zulu folder within our home directory, in this example). From the command-line, and while in the directory where you’ve downloaded Zulu:

mkdir ~/zulu
tar xvfpz ezre-1.8.0_60-8.9.0.6-cp1-eval-linux_aarch32.tar.gz -C ~/zulu

Add the Zulu JVM to the list of alternate VMs

The update-alternatives command-line utility allows to easily bind a given symbolic name to different commands. In our case, we want to update the symbolic link for /usr/bin/java

sudo update-alternatives --install /usr/bin/java java ~/zulu/ezre-1.8.0_60-8.9.0.7-cp3-eval-linux_aarch32/bin/java 100

Enable Zulu

sudo update-alternatives --config java

In the list of alternative Java version that’s proposed to you, select the one corresponding to Zulu by entering its ID and pressing .

And voila! Zulu is now your default Java Virtual Machine, you can check by executing the following command:

java -version
openjdk version "1.8.0_60-Zulu-Embedded"
OpenJDK Runtime Environment (build 1.8.0_60-Zulu-Embedded-EA3, profile compact1)
OpenJDK Minimal VM (build 25.60-b23, mixed mode, Evaluation)
Categories
Eclipse IoT

Running Eclipse Che on a Raspberry Pi

Eclipse Che is a very cool Eclipse technology that provides you with a browser-based IDE that can be extended with plug-ins for virtually any language, framework, or tool that you may want to use in your day-to-day development.

This means that, right from your browser, you can do Java development and have Maven automatically build your stuff, or do Javascript development and still be able to easily integrate with e.g grunt to build your website.

As you may have guessed, most of the magic of Che is in its server. While in many cases you will run the Che server on your own laptop or private server, it’s also pretty cool to run it on an embedded/IoT device such as Raspberry Pi so as not only you have an “IDE-in-a-box” setup, but you can also actually develop code targeting the Pi itself. And yes, that means blinking LEDs… and more ! 😉

Install Docker

Assuming you are running an up-to-date Jessie distribution, it should be fairly straightforward to install the armhf version of docker provided by the Hypriot team.

cd ~/Downloads
wget https://downloads.hypriot.com/docker-hypriot_1.10.3-1_armhf.deb
sudo dpkg -i docker-hypriot_1.10.3-1_armhf.deb
sudo usermod -aG docker pi


At this point, you want to quickly logout and login again, in order for the addition of the user pi to the docker group to be properly applied. Then, we can test that docker is indeed running:


docker ps


This should grant you with an empty list of running docker containers. How surprising!? But at least it means you have Docker setup taken care of!


FWIW, the Hypriot folks have a Debian repo for making things easier. I have had problems with it though so you may want to stay away from it until they fix it?


Downloading Che


wget https://install.codenvycorp.com/che/eclipse-che-latest.zip
unzip eclipse-che-latest.zip
cd eclipse-che*


Updating Che’s built-in stacks to be ARM-compatible


When Che creates your development environment, it instantiates a Docker container that has the tools you need. That is to say, if you are to do Node development, Che can provision a so-called “stack” that contains npm, grunt, etc. The stacks configured by default in Che are based on x86 Docker images, so you will need to replace them with armfh-compatible ones.


sed -i 's/codenvy\/ubuntu_jdk8/kartben\/armhf-che-jdk8/g' stacks/predefined-stacks.json
sed -i 's/codenvy\/node/kartben\/armhf-che-node/g' stacks/predefined-stacks.json


I’ve built an image for Java and Node development, which means you’ll be able to use the “Java”, “Node”, and “Blank” ready-to-go stacks. Should you want to have a look at the Dockerfiles for those, see here.


Note that you don’t have to use the built-in stacks, and you can also create your on-the-fly, using a custom recipe. There as well, the base Docker image you’re building from will need to be ARMHF. You may want to use images from hypriot or armv7 on DockerHub.


Update other default settings


The Raspberry Pi 3 is quad-core, which means you actually get some very decent performances out of it. However, it’s still an embedded sort of device, and SD cards are typically not fast either. It’s a good idea to increase the timeout Che uses to detect a workspace is properly provisioned.


sed -i 's/machine.ws_agent.max_start_time_ms=60000/machine.ws_agent.max_start_time_ms=240000/g' conf/che.properties


Launch Che!


You’re good to go! All that is left is to launch Che. As you will likely be accessing it from e.g your Desktop computer, you need to make sure to use the -r:<external-IP> command-line argument to make sure it works properly from “non-localhost”:


./bin/che.sh run -r:192.168.2.26


Note that depending on your setup, the JAVA_HOME environment variable may not be set, in which case Che will complain, and you will have to first set the said environment variable:


export JAVA_HOME=/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt


You can actually add this to your ~/.bashrc to make sure JAVA_HOME is always set.


That’s it! You can now use the Java and Node stacks, and start using your web browser to develop right on your Pi, with *all* the features you would expect from a “real” IDE. Enjoy, and stay tuned for a video tutorial soon.