Java, Edison, new GitHub repository

I have decided to organize the repository for the Java code in a slightly different way.

The URL to access is: 

https://github.com/luigisaetta/edison-java-projects

The first project is RoomStation, where you find Java code for:

• using Grove Temp, Light, Air Quality sensors
• send MQTT msg to a broker
• formatting msg in JSON (using Google GSON)

bye.

Huh, should I read myself?

Sometimes I make good things.

http://lsaetta.blogspot.it/2015/04/learning-how-to-learn-my-final-work.html

Java, mon amour (again on Edison)

Yes, it is true that Java is rather old. But it is also a wonderful language.

When I started working in Java, coming from C++, it seemed to me a breeze. No problems with memory allocation, no problem with pointers. Difficult to make big mistakes. Elegant and simple.

Then, year after year, with many improvements a lot of packages and functionalities have been added.

No more simple.

It is a long and complicated discussion. Probably Java is old.

But it is really nice for me to write code in Java (well, I don’t write code as an everyday job, as it was 20 years ago, so I’m not so fast) but… it is nice.

I have discovered that it is really easy to write a program for Intel Edison, in Java, using UPM libraries to read sensors and using MQTT to communicate with an MQTT broker.

Here, in one of my github repository, you find the Java code. It took only some hours.

https://github.com/luigisaetta/edison/tree/master/src/edison

Will it work?

Yes, sure.

I’ll describe the pieces of the code in another blog post. But do I really need?

update… here is the proof that it works. The client is the Paho GUI client.

Intel Edison and Java

I have worked for a long time with Java, and probably Java is the language that I better manage.

But, Java is not frequently used on IoT devices and boards. The main reason is that it is considered a resource hog. It requires a lot of memory.

Anyway, Intel Edison is not so resource-constrained as some other boards (Arduino), with its 1 GB Ram, and therefore it is perfectly justified the decision to try to test Java and UPM libraries to see how they works.

The development environment that I’m going to use is the one provided by Intel: The Intel Studio IoT Edition (ISS) based on Eclipse.

But, I don’t want to use the Java JDK normally distributed with Yocto (OpenJDK) and, therefore, the first step that I’m going to do is to install Oracle JDK 8 on Edison.

mkdir /usr/java

Then downloads Oracle JDK 8 on Edison; The version I have downloaded from the Oracle site is:

jdk-8u91-linux-i586.tar.gz

(be sure to download the X86 version and NOT the X86_64, Edison is 32-bit).

Then, extract the tar file with the command

tar -xvzf jdk-8u91-linux-x64.tar.gz

after, move the exploded directory under /usr/java

mv jdk1.8.0_91 /usr/java

At this point, you only need to setup correctly two environment variables

export JAVA_HOME=/usr/java/jdk1.8.0_91

 

export PATH=$JAVA_HOME/bin:$PATH

Then, you can check that Oracle Java JDK 8 is correctly installed with:

 

java -version

 

java version "1.8.0_91"

 

Java(TM) SE Runtime Environment (build 1.8.0_91-b14)

 

Java HotSpot(TM) Client VM (build 25.91-b14, mixed mode)

 

Ok, the first step is done, the JDK 8 is installed and working.

 

Now, you need to install the Java libraries for MRAA and UPM.

 

The latest version of the Java (JNI) libraries from IOTDK 3.0 can be downloaded from

 

http://iotdk.intel.com/repos/3.0/java/iotdk-java-latest.zip

 

I have downloaded this zip file, extracted the contents in 

 

/home/root/javaprograms/lib

This directory have to be put inside the classpath, when you run your program.

To test I have created a simple Java program, made by a single Java Class. The program uses two sensors from the Grove Starter Kit Plus: Temperature and Light.

import upm_grove.*;

public class Test1

{

        private static int PIN_TEMP = 0;

        private static int PIN_LIGHT = 1;

        private static int SLEEP_TIME = 3000;

       

        public static void main(String[] args)

        {

                System.out.println("Starting program...");

               

                GroveTemp tempSensor = new GroveTemp(PIN_TEMP);

                GroveLight lightSensor = new GroveLight(PIN_LIGHT);

               

                int i = 0;

                while (i < 100)

                {

                        float temp = tempSensor.value();

                        float light = lightSensor.raw_value();

                        System.out.println("Temperature is : " + temp + ", Light is: " + light);

                       

                        try

                        {

                                Thread.sleep(SLEEP_TIME);

                        } catch (InterruptedException e)

                        {

                                e.printStackTrace();

                        }

                }

        }

}

The java class is called Test1 and it is packed inside test1.jar file.

To run the program:

java -cp .:/home/root/javaprograms/lib/*:test1.jar Test1

where Test1 is the name of the main class

 

It works !!. Simple. 

 

In the next blog post, once again, I will integrate with MQTT library Paho and I will test sending msgs with readings from sensors to a Mosquitto MQTT broker.

Now with real sensors

The hardware configuration I’m going to test consist of an Edison Board equipped with a Grove Shield to which we have connected three sensors (for now Air Quality Sensor is not used):

• Temperature sensor, to A0
• Light sensor, to A1

To handle reading from sensors, we will use UPM library. As we will see the Node code is simple.


With the following code, we read values from sensors and send every 2 secs. (in the config) a msg to AWS IoT, containing value read for temperature (C) and light (lux).

Configuration is read from a file (config.js), whose content is:

{

"keyPath" : "/node_app_slot/certs/thunder10-private.pem.key",
"certPath" : "/node_app_slot/certs/thunder10-certificate.pem.crt",
"caPath" : "/node_app_slot/certs/root-ca.crt",
"region" : "eu-west-1",
"clientId" : "thunder10",
"sleepTime" : 2000

 }

The last piece (config.js) shows you what must be considered a best practice: Keep separated the logic from the configuration, that probably needs to be different from device to device and maybe can change more frequently. This way you need only to replace the config.js file.

The nice thing with Edison is that, if you want to change the configuration, you can simply upload the config.js file Over The Air.

Amazon AWS IoT: quick update

Since one of the communication protocol supported is MQTT, the obvious question is: can I use directly a MQTT client (in addition to the AWS SDK that we have used in the last post)?

Yes, you can.

For example, if you have some familiarity with MQTT, you probably have installed and worked with Mosquitto.

With Mosquitto you get installed two utilities that can be used to test publish and subscribe:

• mosquitto_pub
• mosquitto_sub

To test the transmission of a MQTT messages to your IoT gateway in AWS you need, as always, the certificate and the private key generated when you have registered your thing (the abstract representation in AWS of your device).

To publish a message:

/usr/local/bin/mosquitto_pub --cafile ./rootCA.pem --cert ./thunder10-certificate.pem.crt --key ./thunder10-private.pem.key -p 8883 -q 1 -d -t thunder10/test -m "Hello" -h A1NQFCHBXLAAH3.iot.eu-west-1.amazonaws.com

Client mosqpub/29492-MacBook-P sending CONNECT

Client mosqpub/29492-MacBook-P received CONNACK

Client mosqpub/29492-MacBook-P sending PUBLISH (d0, q1, r0, m1, 'thunder10/test', ... (5 bytes))

Client mosqpub/29492-MacBook-P received PUBACK (Mid: 1)

Client mosqpub/29492-MacBook-P sending DISCONNECT

The value you pass in the parameter -h is the hostname you have to refer to. You find it in your AWS IoT console.

-m: the value of the message (any sequence of bytes).

-p is the port

-q for the QoS; 1 means “at least once”. AWS doesn’t support “only once”.

You can easily run also a subscriber (mosquito_sub) on the same topic (in the example thunder10/test) and receive on your board (or laptop) the msg sent.

 

/usr/local/bin/mosquitto_sub --cafile ./rootCA.pem --cert ./thunder10-certificate.pem.crt --key ./thunder10-private.pem.key -p 8883 -d -t thunder10/test -h A1NQFCHBXLAAH3.iot.eu-west-1.amazonaws.com

 

Client mosqsub/29874-MacBook-P sending CONNECT

 

Client mosqsub/29874-MacBook-P received CONNACK

 

Client mosqsub/29874-MacBook-P sending SUBSCRIBE (Mid: 1, Topic: thunder10/test, QoS: 0)

 

Client mosqsub/29874-MacBook-P received SUBACK

 

Subscribed (mid: 1): 0

 

Client mosqsub/29874-MacBook-P received PUBLISH (d0, q0, r0, m0, 'thunder10/test', ... (5 bytes))

 

Hello

 

Client mosqsub/29874-MacBook-P received PUBLISH (d0, q0, r0, m0, 'thunder10/test', ... (5 bytes))

 

Hello

Edison talk to AWS: Hello

In this post I’d like to explore, with some details, how to connect an Intel Edison Board to Amazon AWS.
This is the architecture we’re going to test:



 The development language that I will use is JavaScript, running in NodeJS.
First, you need to have a working subscription with Amazon AWS, and you need to have provisioned AWS IoT.
Then, using AWS Console, you need to create a Thing.
I have called this thing Thunder10.
Then, you need to connect to this thing a Device. When you do this operation, you can select an SDK.
We will select NodeJS JDK.

Then, you generate a certificate and a policy, that is attached to the thing. In this way you will create the public/private key-pair that will be used by the SDK to secure the communication.
Since it is attached to the thing, it will also ensure that your thing is recognized.
Then, you download the public/private key and the certificate. Take care that this is a one-time operation. In other words, after this step, if you don’t save the public and private key you won’t be able to retrieve them another time.
You will need to upload these files on the Edison board, in a well defined directory (you choose which one).
I have decided for /node_app_slot/certs
Then, after downloaded the keys and the certificate, you arrive to this page:


In the page you find the information needed to setup the connection between the thing and Amazon AWS. Then you can download the SDK.
You can download the root CA certificate from here:

https://www.symantec.com/content/en/us/enterprise/verisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem

The SDK is based on MQTT.js. You can also install the SDK using npm. You find all the detailed instructions on the github.

https://github.com/aws/aws-iot-device-sdk-js/blob/master/README.md

To install it,

npm install aws-iot-device-sdk

After having installed the SDK and having uploaded keys and certificate to the directory chosen, you can quickly test a connection and send a ms with the following NodeJS code

var awsIot = require('aws-iot-device-sdk');
console.log('Started Test with AWS !!!');
var device = awsIot.device({
keyPath: "/node_app_slot/certs/thunder10-private.pem.key",
certPath: "/node_app_slot/certs/thunder10-certificate.pem.crt",
caPath: "/node_app_slot/certs/root-ca.crt",
clientId: "thunder10",
region: "eu-west-1"
});
device
.on('connect', function() {
console.log('connect');

});
device.publish('thunder10/test', JSON.stringify({ test_data: 1}));

take care that the program will stay on and connected waiting for… a CTRL-C.
Now, the important question is: how can I verify that my Edison (called Thunder10, has connected to AWS IoT and has successfully sent a msg.
There is a simple way:
Go to the console and use the MQTT client (yes !!!, the device is using MQTT, what else?)


Create a client, specify a clientId and then, subscribe to the same topic you have defined in the publish invocation in the code (thunder10/test)
If everything is ok, you will see a msg on the left.



One more thing. If you want to send messages in a loop, the code becomes

var awsIot = require('aws-iot-device-sdk');
var connected = false;
console.log('Started Test with AWS !!!');
var device = awsIot.device({
keyPath: "/node_app_slot/certs/thunder10-private.pem.key",
certPath: "/node_app_slot/certs/thunder10-certificate.pem.crt",
caPath: "/node_app_slot/certs/root-ca.crt",
clientId: "thunder10",
region: "eu-west-1"
});
device
.on('connect', function() {
console.log('connect');

connected = true;

});
function doSomething()
{
if (connected)
{
device.publish('thunder10/test', JSON.stringify({ temp: 25}));
console.log('Sent...');
}
// re-schedule executionn of publish
setTimeout(doSomething, 5000);
}
doSomething();

It is easy. In more or less 1.5 hours.
In the next post, maybe I’ll explore how to set-up a rule and invoke a Lambda function.
Another idea is to verify how it works on Azure.
Good Night baby.