Specificities of Azure IoT Edge

Pre installation before Azure IoT Edge

Bang, another issue: LISTEN_FDNAMES

The concepts

• Provide your application a special access that will give full right to the entire directory, Office 365 information with some granularity. Granularity is Read, or Read/Write, for mail, calendar…
• Do the authentication somewhere else and provide the token to the application. This allow much more granularity vs the previous solution and allow to have a normal user with normal privileges connected.

Preparing Office 365 tenant and Azure Active Directory

1. Prepare your Azure Active Directory tenant. Follow the steps here. You will need an Office 365 business account, the rights to add an app into the Azure portal
2. When following the steps add a “Native client application”
3. When specifying the App permission, add Microsoft Graph and select what you need
4. You’ll need to add return URIs. Those are the address that are allow to be redirected on to pass the token/codes after authentication. In the example, I’ll use a Raspberry in a UWP. Name will be “laurellerpitest” and will return on port 81 on page token. So https://laurellerpitest:81/token
5. Then download the Manifest, save it and open it with Visual Studio for example
6. Change “oauth2AllowImplicitFlow” to true and save the file
7. Upload the saved manifest. This specific modification in the manifest will allow this manipulation of doing the authentication on a machine which is not the one which will use the token. It will just allow to pass the token to a different place in a flow. This is needed only in cases like this one where the authentification has to follow a flow from one place to another. If you are doing the authentication on the same machine you’ll use the token, this is not needed.

Creating the authorization URL

• response_type=token: this is where you’re asking for the access token. You may ask for other types of token depending on what you need to do later on. You will find more information on supported token type here. Authentication will happen on a webpage and the token will be returned to the return URI.
• redirect_uri=https://laurellerpi:81/token (encoded to be compatible with uri parameters): this is the return URI you’ve setup into your portal.
• client_id=01234567-89ab-cdef-1234-567890abcdef: this is the unique ID of your app that you’ll find as well un the Azure portal.
• resource=https://graph.microsoft.com/: request access to Microsoft Graph. Can be as well other services suing the same endpoint for which you gave autorisation

Getting the access token

httpServer = newHttpServer(81);

httpServer.StartServer();

    publicsealedpartialclassHttpServer : IDisposable

    {

        privateconstuint BufferSize = 8192;

        privateint port = 80;

        privatereadonlyStreamSocketListener listener;

        privatestring token;

        publicstring Token

        {

            get

            {

                return token;

            }

            internalset

            {

                token = value;

            }

        }

        public HttpServer(int serverPort)

        {

            listener = new StreamSocketListener();

            port = serverPort;

            listener.ConnectionReceived += (s, e) => ProcessRequestAsync(e.Socket);

        }

        publicasyncvoid StartServer()

        {

#pragmawarningdisable CS4014

            await listener.BindServiceNameAsync(port.ToString());

#pragmawarningrestore CS4014

        }

        publicvoid StopServer()

        {

            ((IDisposable)this).Dispose();

        }

        publicvoid Dispose()

        {

            listener.Dispose();

        }

        privateasyncvoid ProcessRequestAsync(StreamSocket socket)

        {

            awaitTask.Run(async () =>

            {

                try

                {

                    // this works for text only

                    StringBuilder request = new StringBuilder();

                    using (IInputStream input = socket.InputStream)

                    {

                        byte[] data = newbyte[BufferSize];

                        IBuffer buffer = data.AsBuffer();

                        uint dataRead = BufferSize;

                        while (dataRead == BufferSize)

                        {

                            await input.ReadAsync(buffer, BufferSize, InputStreamOptions.Partial);

                            request.Append(Encoding.UTF8.GetString(data, 0, data.Length));

                            dataRead = buffer.Length;

                        }

                        Debug.WriteLine("Request received: {0}", request.ToString());

                    }

                    using (IOutputStream output = socket.OutputStream)

                    {

                        string requestMethod = request.ToString().Split('\n')[0];

                        string[] requestParts = requestMethod.Split(' ');

                        if (requestParts[0] == "GET")

                            await WriteResponseAsync(requestParts[1], output);

                        else

                            return;

                        Debug.WriteLine("Request processed from WebServer");

                    }

                }

                catch (Exception e)

                {

                    Debug.WriteLine("Exception in Socket: {0}", e.ToString());

                }

                finally

                {

                    try

                    {

                        socket.Dispose();

                    }

                    catch (Exception e)

                    {

                        Debug.WriteLine("Exception in cleaning exception Socket: {0}", e.ToString());

                    }

                }

            });

        }

        privateasyncTask WriteResponseAsync(string request, IOutputStream response)

        {

            string pageUtil = "token";

            string strFilePath = request;

            string strResp = "";

            if (strFilePath.Length >= pageUtil.Length)

            {

                if (strFilePath.Substring(1, pageUtil.Length).ToLower() == pageUtil)

                {

                    ProcessResponsePage(response, strFilePath);

                    return;

                }

            }

            // send blank text

            await OutPutStream(response, strResp);

        }

        privateasyncvoid ProcessResponsePage(IOutputStream response, string rawURL)

        {

            string strResp = ""; ;

            if (DecryptProcessResponsePage(rawURL))

                strResp = "OK";

            else

                strResp = BuildScript();

            await OutPutStream(response, strResp);

        }

        privatestring BuildScript()

        {

            string strResp = "";

            strResp += "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";

            strResp += "<html xmlns=\"https://www.w3.org/1999/xhtml\"><head><title></title>";

            strResp += "<SCRIPT language=\"JavaScript\">";

            strResp += "if (window.location.href.indexOf(\"#access_token\") > 0)";

            strResp += "{var token = window.location.href.substring(window.location.href.indexOf(\"#access_token=\") + 14);";

            strResp += "token = token.substr(0, token.indexOf(\"&\"));";

            strResp += "var xhr = new XMLHttpRequest(); ";

            strResp += "xhr.open('GET', '/token?access_token=' + token);";

            strResp += "xhr.onreadystatechange = function() {if (xhr.readyState == 4) {boxMSG.innerHTML=xhr.responseText;}}; xhr.send();}";

            strResp += "";

            strResp += "</Script>";

            strResp += "</head><body><span id='boxMSG'></span></body></html>";

            return strResp;

        }

        privatebool DecryptProcessResponsePage(string strDecrypt)

        {

            // decode params

            Param[] Params = Param.decryptParam(strDecrypt);

            bool isvalid = false;

            try

            {

                if (Params != null)

                {

                    for (int i = 0; i < Params.Length; i++)

                    {

                        //on cherche le paramètre strMonth

                        int j = Params[i].Name.ToLower().IndexOf("access_token");

                        if (j == 0)

                        {

                            token = Params[i].Value;

                            isvalid = true;

                        }

                    }

                }

            }

            catch (Exception)

            {

                isvalid = false;

            }

            return isvalid;

        }

        privateasyncTask OutPutStream(IOutputStream response, string strResp)

        {

            try

            {

                using (Stream resp = response.AsStreamForWrite())

                {

                    byte[] bodyArray = Encoding.UTF8.GetBytes(strResp);

                    resp.Write(bodyArray, 0, bodyArray.Length);

                    //Flush need to be SYNC. If async, then it goes closed before!

                    //resp.Flush();

                    Debug.WriteLine("OutputStream sent");

                }

            }

            catch (Exception e)

            {

                Debug.WriteLine("Exception in outputstream: {0}", e.ToString());

            }

            return;

        }

}

    publicsealedclassParam

    {

        publicstring Name { get; set; }

        publicstring Value { get; set; }

        publicstaticchar ParamStart { get { return'?'; } }

        publicstaticchar ParamEqual { get { return'='; } }

        publicstaticchar ParamSeparator { get { return'&'; } }

        publicstaticParam[] decryptParam(string Parameters, char start = '?')

        {

            Param[] retParams = null;

            int i = Parameters.IndexOf(start);

            String strtocut = Parameters;

            if (i >= 0)

                strtocut = Parameters.Substring(i + 1);

            var strcut = strtocut.Split(ParamSeparator);

            if (strcut != null)

            {

                retParams = newParam[strcut.Length];

                for (int inc = 0; inc < strcut.Length; inc++)

                {

                    var strgood = strcut[inc].Split(ParamEqual);

                    retParams[inc] = newParam();

                    if (strgood.Length == 2)

                    {

                        retParams[inc].Name = strgood[0];

                        retParams[inc].Value = strgood[1];

                    }

                    else

                    {

                        retParams[inc].Name = "";

                        retParams[inc].Value = "";

                    }

                }

            }

            else {

                retParams = newParam[1];

                retParams[0].Name = "";

                retParams[1].Value = "";

            }

            return retParams;

        }

}

if (window.location.href.indexOf("#access_token") > 0)

{

    var token = window.location.href.substring(window.location.href.indexOf("#access_token=") + 14);

    token = token.substr(0, token.indexOf("&"));

    var xhr = new XMLHttpRequest();

    xhr.open('GET', '/token?access_token=' + token);

    xhr.onreadystatechange = function () {

        if (xhr.readyState == 4) { boxMSG.innerHTML = xhr.responseText; }

    };

    xhr.send();

}

Using the Microsoft Graph REST API

HttpClient client = new HttpClient();

client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);

HttpResponseMessage response = await client.GetAsync("https://graph.microsoft.com/v1.0/users/");

string retResp =await response.Content.ReadAsStringAsync();

Next steps

Setup the Mindstorms ev3

I already used the excellent monobrick to run C# code on the brick and it was working perfectly. Now my challenge was to run node.js and connect it to Azure IoT Hub. So I looked quickly at various available images and found quickly the ev3dev one.

So I’ flashed a 4Gb SD card and booted on it. Just follow the steps on the ev3dev site to flash the SD card. I’m using a very cheap wireless dongle, an Edimax. It does cost less than 10$/€ and it’s very small, so easy to add to the brick. It does connect at 150Mb max but you really don’t need to have more on the brick!

Time to boot the brick using ev3dev. I’m using an external power supply so I’m not consuming batteries and I do recommend to do it while running all those tests. It is very convenient during the development and test phase. Later you can of course run on batteries.

Once you’ve booted, connect to the wifi, you can as well use a wired dongle if you prefer. Careful as you only have 2 minutes to enter your key, so you better have to speed up to enter it I had to redo it 3 times the first time as I have a quite long key and it’s not that easy to enter using the buttons and screen from the ev3.

Once connected to wifi, the IP address will display on the screen. Time to connect to the brick. I’m using PuTTY to connect to the brick.

login as: root
root@192.168.1.20's password:
             _____     _
   _____   _|___ /  __| | _____   __
  / _ \ \ / / |_ \ / _` |/ _ \ \ / /
|  __/\ V / ___) | (_| |  __/\ V /
  \___| \_/ |____/ \__,_|\___| \_/

Debian jessie on LEGO MINDSTORMS EV3!

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Wed Dec 23 18:49:39 2015 from pc10.home
root@ev3dev:~#

Follow the instruction of the e3vdev website to update the brick. It will take some time to update and upgrade all packages.

At the end of the day, when running a node –v, you’ll get v0.10.29 and npm is 1.4.21. And it’s the best you can get on this armel distribution so far.

Setup the development environment

I’ve decided to go for Visual Studio. You can get a free version of Visual Studio Community here. I’ve installed as well the needed tools as explained in my blog post here. If you prefer you can go as well for Visual Studio Code which you’ll find here. It does work perfectly as well.

Once all ready, create a new node.js project, I went for the simple web server one. Again, follow the steps from my previous article to get it all setup. I’m of course using TypeScript as it makes it easy to maintain the code. It does generate automatically at build time the javascript files.

Add the azure-iot-device and ev3dev packages.

Up to this point, it was quite straight forward and I didn’t had any issue. The next steps are where I started to face issues.

Deploy the solution on the brick

To deploy the solution, it’s just about creating a directory and copying the needed files on it. This time I used WinSCP for this. I’ve created a nodeNXT directory in /home and deployed the files there. Just copy the generated server.js and package.json file.

On the device, in the /home/nodeNXT directory, run an “npm install” command. It will install the missing packages. Be patient, it does take a while. And it’s where the problems starts.

As the needed version of node.js for the Azure IoT SDK is 0.12, and as the system can’t get more recent build than 0.10.29, some of the packages do not get deploy correctly. The main faulty one is the websocket one.

If you try to create in your code a “var device = require('azure-iot-device');” you’ll get an error message on the device. I have to say I didn’t had any idea on how to get thru this. So I’ve asked Pierre Cauchois who is working in the Azure IoT team for advices. And he told me to remove the websocket part and just use classes which I’ll need. In my case I just needed the http way to publish in Azure IoT Hub.

For this, you’ll need to edit on the device “./node_modules/azure-iot-device/device.js”, in the last part of the file, just keep this:

var common = require('azure-iot-common');

module.exports = {
    Client: require('./lib/client.js'),
    ConnectionString: require('./lib/connection_string.js'),
    Http: require('./lib/http.js'),
    Message: common.Message,
    SharedAccessSignature: require('./lib/shared_access_signature.js'),
};

And you’ll need as well to edit the file on the device  “./node_modules/azure-iot-device/lib/http_receiver.js”, comment the following lines:

//var util = require('util');

//util.inherits(HttpReceiver, EventEmitter);

It looks like there is an issue as well in the util package. For what I’l do later, looks like those 2 lines have no issue. My goal is just to send data to Azure IoT Hub from the NXT. I haven’t tested to receive data from the Azure IoT Hub, so this may have an impact.

I’ve spend a lot of time fixing this issue due to the outdated version of node.js running on the brick but if you do this, you’ll be able to upload data in the Azure IoT Hub.

I found another issue, not related to the Azure IoT SDK but to the ev3dev version. The version deployed thru npm is the 0.9.2 and is quite basic. You can find a new version on github which is 0.9.3. So download and install this version in your node modules, add it as a project in Visual Studio, and use this one. There is a bug in the index.ts file. Some references are missing for sensors.

In the sensor.ts file, make sure you reference all sensors from the sensor.ts file:

// Sensors
export var Sensor = sensors.Sensor;
export var I2CSensor = sensors.I2CSensor;
export var TouchSensor = sensors.TouchSensor;
export var ColorSensor = sensors.ColorSensor;
export var UltrasonicSensor = sensors.UltrasonicSensor;
export var GyroSensor = sensors.GyroSensor;
export var InfraredSensor = sensors.InfraredSensor;
export var SoundSensor = sensors.SoundSensor;
export var LightSensor = sensors.LightSensor;

Note that the code is coming in TypeScript, so you’ll need to compile it and deploy it manually to the device. I did it in a very basic way, once compiled, I’ve just copied all files from the directory. In theory, you just need the js ones and the package.json and the scprits folder.

OK, now we’re really done on the device side Good because it takes me a lot of time to figure out all those issues.

Some code to upload data

Now here is some code to play with. This is a very basic code but shows all what you need to get data from sensors and upload them in Azure IoT Hub:

import http = require('http');
var url = require('url');
var ev3dev = require('./node_modules/ev3dev-lang/index.js');
var device = require('azure-iot-device');
var connectionString = 'HostName=XXX.azure-devices.net;DeviceId=NXT;SharedAccessKey=XXXXXXXXXXXX';

var port = process.env.port || 1337
http.createServer(function (req, res) {
    var request = url.parse(req.url, true);
    var action = request.pathname;
    var tablee = [];
    var i = 0;

    if (action == '/battery') {
        var battery = new ev3dev.PowerSupply();
        var str = '';

        if (battery.connected) {
            str += '  Technology: ' + battery.technology + '\n';
            str += '  Type: ' + battery.type + '\n';
            str += '  Current (microamps): ' + battery.measuredCurrent + '\n';
            str += '  Current (amps): ' + battery.currentAmps + '\n';
            str += '  Voltage (microvolts): ' + battery.measuredVoltage + '\n';
            str += '  Voltage (volts): ' + battery.voltageVolts + '\n';
            str += '  Max voltage (microvolts): ' + battery.maxVoltage + '\n';
            str += '  Min voltage (microvolts): ' + battery.minVoltage + '\n';
            tablee[i] = JSON.stringify({
                Sensor: 'PowerSupply',
                technology: battery.technology,
                type: battery.type,
                measuredCurrent: battery.measuredCurrent,
                currentAmps: battery.currentAmps,
                measuredVoltage: battery.measuredVoltage,
                voltageVolts: battery.voltageVolts,
                maxVoltage: battery.maxVoltage,
                minVoltage: battery.minVoltage
            });
            i++;
        }
        else {
            str = '  Battery not connected!';
            tablee[i] = JSON.stringify({
                Sensor: 'PowerSupply',
                error: 'not connected'
            });
            i++
        }
        sendmsg(JSON.stringify({
            tablee
        }));
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end(str + JSON.stringify(battery));
    } else if (action == '/sensor') {
        var touchSensor = new ev3dev.TouchSensor();
        var colorsensor = new ev3dev.ColorSensor();
        var UltrasonicSensor = new ev3dev.LightSensor();
        var InfraredSensor = new ev3dev.InfraredSensor();
        var SoundSensor = new ev3dev.SoundSensor();
        var str = '';

        if (touchSensor.connected) {
            str += 'touch pressed: ' + touchSensor.isPressed + '\n';
            tablee[i] = JSON.stringify({
                Sensor: 'TouchSensor',
                isPressed: touchSensor.isPressed
            });
            i++;
        }
        if (colorsensor.connected) {
            str += 'color sensor: \n   reflectedLightIntensity: ' + colorsensor.reflectedLightIntensity + '\n';
            str += '   ambientLightIntensity: ' + colorsensor.ambientLightIntensity + '\n';
            str += '   color: ' + colorsensor.color + '\n';
            str += '   red: ' + colorsensor.red + '\n';
            str += '   green: ' + colorsensor.green + '\n';
            str += '   blue: ' + colorsensor.blue + '\n';
            tablee[i] = JSON.stringify({
                Sensor: 'ColorSensor',
                reflectedLightIntensity: colorsensor.reflectedLightIntensity,
                ambientLightIntensity: colorsensor.ambientLightIntensity,
                color: colorsensor.color,
                red: colorsensor.red,
                green: colorsensor.green,
                blue: colorsensor.blue
            });
            i++;
        }
        if (UltrasonicSensor.connected) {
            str += 'UltrasonicSensor: \n   distanceCentimeters' + UltrasonicSensor.distanceCentimeters + '\n';
            str += '   otherSensorPresent: ' + UltrasonicSensor.otherSensorPresent + '\n';
            tablee[i] = JSON.stringify({
                Sensor: 'UltrasonicSensor',
                distanceCentimeters: UltrasonicSensor.reflectedLightIntensity,
                otherSensorPresent: UltrasonicSensor.ambientLightIntensity
            });
            i++;
        }
        if (InfraredSensor.connected) {
            str += 'InfraredSensor: \n   proximity: ' + InfraredSensor.proximity + '\n';
            tablee[i] = JSON.stringify({
                Sensor: 'InfraredSensor',
                proximity: InfraredSensor.proximity
            });
            i++;
        }
        if (SoundSensor.connected) {
            str += 'SoundSensor: \n   soundPressure: ' + SoundSensor.soundPressure + '\n';
            str += '   soundPressureLow: ' + SoundSensor.soundPressureLow + '\n';
            tablee[i] = JSON.stringify({
                Sensor: 'SoundSensor',
                soundPressure: SoundSensor.soundPressure,
                soundPressureLow: SoundSensor.soundPressureLow
            });
            i++;
        }
        sendmsg(JSON.stringify({
                tablee
            }));

        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end(str);
    } else {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Try /battery /sensor \n');
    }
}).listen(port);

function sendmsg(data) {
    var client = device.Client.fromConnectionString(connectionString);
    var message = new device.Message(data);
    message.properties.add('NXTsensors', 'sensorData');
    console.log("Sending message: " + message.getData());
    client.sendEvent(message, printResultFor('send'));
}

function printResultFor(op) {
    return function printResult(err, res) {
             if (err) console.log(op + ' error: ' + err.toString());
             if (res && (res.statusCode !== 204)) console.log(op + ' status: ' + res.statusCode + ' ' + res.statusMessage);
       
    };
}

The code is quite simple, I do return, as text, in the page, the sensors and their states. At the same time I’m building a JSON table containing the sensors data.

The function sendmsg is sending the data to Azure IoT Hub. This part of the code coming from the sample code you can find in the excellent SDK (it’s the simple http one). In the code, replace the XXX in the connection string by your IoµT Hub, make sure the name of your device is NXT or replace NXT by the name of device you want to use. Don’t forget to create a device before if needed. And of course, the primary key of the device.

Now, compile everything, deploy the server.js file to the device, run “node server.js” and wait 30 seconds. In a browser, you can now access the NXT brick on port 1337 like https://ipaddress:1337/ (replace ipaddress by the IP address of your ev3). It will return: Try /battery /sensor

the /sensor returns in my case:

/battery returns:

On the device side, you can check that the data has been sent:

What about Azure IoT Hub? Well, just use the Device Explorer (see my previous article on where to get it and how to use it). Run the Device Explorer and connect it to your IoT Hub before trying /sensor and /battery.

And voilà we made it The Lego Mindstorms ev3 is now connected to Azure IoT Hub using node.js and able to send data to Azure.

Bottom line: when you have sources of and SDK, don’t be afraid to adapt, change and modify what you need for your own platform. I did it with the Azure IoT SDK because my node.js version was too old to fully run it. And I did it with the ev3dev package as it was outdated and there were couple of bugs in it.

As always, feedbacks welcome!

I wanted to deploy the code thru FTP and deploy selected part of my project. My idea is to deploy the Device Explorer site I’ve build in my previous post. So for the rest of the article, I will assume you’ve already created a node.js website using either the simple http listener, either an express, jade template like in my example.

Step 1: create an Azure WebApp

I’ll assume you already have an Azure subscription. If you don’t, just open a trial account, it’s quite fast and easy. You’ll need your credit card but it won’t be used. It’s just in case you’ll go over the free costs. And in my example, as I don’t need this website to be all the time online and I will only use it sporadically, I’ll use free hosting.

In the Azure portal, select New, then Web + Mobile, then Web App

Then create the site, the App Service Name is the name of your site.

Allow couple of minutes for it to be created.

Step 2: allow FTP uploads in the WebApp

Now, you need to allow FTP deployment.

In the portal, select your newly created site, go into All Settings then deployment credentials, add a username and a password.

Once done, you’ll get this in the summary view. The blue boxes include information to connect to the ftp deployment with the user name to use.

Now, you can check that you have access using any FTP tool like the Explorer in Windows or anything else.

Step 3: creating the web.config file

Now, we have to go into the project and add a web.config file. This is necessary to be able to have the node.js project running correctly.

Right click on your project, select Add then New Item

Just write web.config and click on OK

Then place this XML code into the web.config file:

<?xml version="1.0" encoding="utf-8"?>

  <configuration>

    <system.webServer>        

      <handlers>

        <add name="iisnode" path="app.js" verb="*" modules="iisnode"/>

      </handlers>

      <rewrite>

        <rules>

            <rule name="DynamicContent">

                 <match url="/*" />

                 <action type="Rewrite" url="app.js"/>

            </rule>

       </rules>

      </rewrite>

    </system.webServer>

  </configuration>

Important part is on the <handlers> as it tells Azure Web App that it’s a node.js app and need to use the node engine. The path="app.js" tells which js file to use as startup.

The other important part is the <rewrite> section as it will make sure the app.js page will be called as default page. If you don’t do that, you’ll have to access your site like https://mysite.net/app.js and you just want to access it like https://mysite.net/

Step 4: deploying the files to the Web App

To deploy, I’m simply using the Windows Explorer as an FTP client. For copying files, it’s just working perfectly. Connect to the FTP host, you’ll be ask for login and password, that’s the one you’ve created at step 2.

Once connected, you can go to the /site/wwroot directory for example. but it can be any directory, you’ll just need to set it up in the Web App properties. In order to make it simple and as it’s the default directly, I’ll use this one.

Now, very important, copy all the files and directories that do contains the code you’ve produced. Make sure you deploy the newly created web.config, your package.json. Do not deploy the node_modules directory.

Once compiled with Visual Studio, if you’re creating your site using TypeScript, it will create the js file. You don’t need to deploy the ts file, you just need the JavaScript generated js files.

Step 5: making sure all node modules are installed

Now you’ve copy all the right files, you can make sure the node.js packages are deployed. In theory, when you’ll run for the first time your app, packages will be downloaded and installed. It is better to do it manually by connecting to the Kudu console.

So connect to https://nameofsite.scm.azurewebsites.net where nameofsite is the name of the site you’ve created, use the login and password you’ve created.

Navigate to your main directory, select Debug console and CMD

In the console type “npm install”, this will install al your packages.

This will create the node_modules directory and deploy all the packages in it:

Step 6: you’re good to go

Now you can connect to your web site and test it! It will just work  

And big thanks to Julien Corioliand for his help.

Code is available on GitHub: https://github.com/Ellerbach/nodejs-webcam-azure-iot/tree/master/DeviceExplorer. The code on GitHub does include more than what is explained in this article.

Setup the dev environement

I’ll use Windows as my development environment. Visual Studio 2015 can support node.js development and debugging. So first I needed to setup Visual Studio 2015:

• You can get for free Visual Studio Community 2015 here.
• Then you need to the free node.js tools for Visual Studio, download them here.
• And you need of course to install the node.js framework from here.

Once those 3 steps done, you’re good to go!

Creating a node.js project in Visual Studio

This is quite straight forward, you have new project type which is node.js. I’ve created a Start Node.js Express 3 Application project. It does come with a simple MVC project containing couple of example pages which makes it easy to learn and understand how all is working.

Views are using jade. This is a part where I had quite some difficulties to use. I do recommend to read the Language Reference as well as the examples from https://jade-lang.com/. The most important is to keep in mind the indentation must be respected and this is what makes groups and makes all the code logic. When you got that, the rest is quite easy and really nice to use.

It will create a full web site. I do recommend to create TypeScript file and not Javascript. this will allow to have a better support and maintainability over time. Javascript file are generated once compiled. And you can choose which version of Javascript you want to generate.

Listing devices

The idea is to have a page that will allow to enter the connection key:

Once the key is entered, it will list the devices plus their keys and couple of other info (in real, keys are displayed instead of the blue box):

So to build this, we will need to:

• Create a view which is about adding a jade file in the views directory
• Add a function to handle requests on the page
• Add a route so the traffic will be correctly redirected to the page

I will first explain how the principle of views and code is working.

Adding the view

Right click on Views then Add and New Items…

select jade file and create one call devices.jade. Let start by replacing what is generated by this code:

extends layout

block content
  h2 #{title}
  h3 #{message}

div.connbox
  p please enter your connection string like HostName=XXX.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=XXX
  form(name="connection", action="/devices", method="post")
    input(type="text", name="constr")
    input(type="submit", value="Connect")

In jade, it will create a page where the #{title} will be replaced by the default text rendering of the title object which will be given to the page. It can be a string or any object. This will allow to manipulate those objects and we will see later how to do that.

The second part will create a form which will post the value of the text box to the page names /devices

Adding a function to handle the code

In the routes/index.js file, add this code:

export function devices(req: express.Request, res: express.Response) {
    var cnxstr = req.body['constr'];
   res.render('devices', { title: 'Devices', message: 'this is the connection string: ‘ + cnxstr });
};

This simple code just find the value of ‘constr’ which has been send by the post form and ask to render the page by sending back the info in the message object. Now, we still don’t have everything as the function has not been declared as a route when the page /devices is called.

Adding the route for a page

Find the file app.ts and add the lines after the line “app.get(‘/’, routes.index);”

app.get('/devices', routes.devices);
app.post('/devices', routes.devices);

Basically, the function we’ve just wrote is now linked to a get or post request on the /devices page.

All together, if you click F5, go on the /devices pages, you’ll be able to fill the text box, send the data to the page and see what you’ve posted. This is a very basic example but it does allow to understand how express and jade are working together.

Requesting Azure IoT Hub devices list in node.js

You’ll need to add the ‘azure-iothub”"’ module.  Using Visual Studio, makes it super easy. Just right click on “npm” in your project then select “Install new npm Packages…”

This will open this window where you can search for the packages.

Here is the code to request all devices present in the IoT hub. It is quite straight forward as the node.js SDK is really nicely done:

var iothub = require('azure-iothub');
var cnxString = '';

export function devices(req: express.Request, res: express.Response) {
    var cnxstr = req.body['constr'];
    if ((cnxstr != undefined) || (cnxString)) {
        if (cnxString) {
            if ((cnxstr == undefined)||(cnxstr ==''))
                cnxstr = cnxString;
        }    
        var registry = iothub.Registry.fromConnectionString(cnxstr);
        registry.list(function (err, deviceList) {
            if (!err) {
                cnxString = cnxstr;
                res.render('devices', { title: 'Devices', year, message: 'Getting list of devices', devicelist: deviceList });
            } else
                res.render('devices', { title: 'Devices', year, message: 'Error getting list of devices', devicelist: null });
        });
    } else
        res.render('devices', { title: 'Devices', year, message: 'Please give a valid connection key', devicelist: null });   
};

First part of the code is really here to check if a connection string has already been provided. If yes, it will reuse the connection string. The key 2 lines are:

this will return in devicelist an array of devices. If no error, then it is passed to the devices view. So very straight forward.

Modifying the jade view to render devices list

Go back to the devices.jade file and add the following code:

div.text
if(devicelist!=null)
  table
    thead
      tr
        th
          | DeviceId
        th
          | Prim Key
        th
          | Sec key
        th
          | Last upd
        th
          | Status
        th
          | Msg waiting
    tbody
      each device in devicelist
        tr
          td
            a(href='/devicedetail/' + device.deviceId) #{device.deviceId}
          td
            | #{device.authentication.SymmetricKey.primaryKey}
          td
            | #{device.authentication.SymmetricKey.secondaryKey}
          td
            | #{device.lastActivityTime}
          td
            | #{device.status}
          td
            | #{device.cloudToDeviceMessageCount}
  p
  a(href='/adddevice/') Add a new device

This part took me quite a lot of time. The reason is jade and the way indentation is working. It is really super important to respect it and the alignment almost drives the behavior of what will be generated. the good news is that you can add code in the jade file like testing if you have a devicelist object. and do for each in the code. The code will generate a simple table which contains some of the device properties. I’ve created as well a page for details as well as a page to add a new device.

This code will render exactly as in the screen capture from the first part of this article. Now, let see how to generate the detailed page for devices as well as creating a new device.

Listing devices properties

Similar to the previous part, add a devicedetail jade, here is the code very similar to the previous page to generate the details in a table:

extends layout

block content
  h2 #{title}
  p #{message}

  div.text
  if(device!=null)
    table
      thead
        tr
          th
            | Details
          th
            | Values
      tbody
          tr
            td
              | Device Id
            td
              | #{device.deviceId}
          tr
            td
              | Primary Key
            td
              | #{device.authentication.SymmetricKey.primaryKey}
          tr
            td
              | Secondary Key
            td
              | #{device.authentication.SymmetricKey.secondaryKey}
          tr
            td
              | Last Activity
            td
              | #{device.lastActivityTime}
          tr
            td
              | Generation Id
            td
              | #{device.generationId}
          tr
            td
              | Messages waiting
            td
              | #{device.cloudToDeviceMessageCount}
          tr
            td
              | etag
            td
              | #{device.etag}
          tr
            td
              | Status
            td
              | #{device.status}
          tr
            td
              | Status Reason
            td
              | #{device.statusReason}
          tr
            td
              | Connection State
            td
              | #{device.connectionState}
          tr
            td
              | connectionStateUpdatedTime
            td
              | #{device.connectionStateUpdatedTime}
          tr
            td
              | statusUpdatedTime
            td
              | #{device.statusUpdatedTime}

We’ll need to create a function that will handle the request and return the device object:

export function devicedetail(req: express.Request, res: express.Response) {
    var devId = req.params.deviceId;
    var strcnx = getHostName(cnxString);
    if (strcnx == '')
        res.render('devicedetail', { title: 'Device detail', year, message: 'Error getting device details. Connection string was: ' + cnxString + ' and deviceId: ' + devId });
    strcnx += ';DeviceId=' + devId;
    var registry = iothub.Registry.fromConnectionString(cnxString);
    var msg = 'No device found';
    registry.get(devId, function (err, device) {
        if (!err) {
            strcnx += ';SharedAccessKey=' + device.authentication.SymmetricKey.primaryKey;
            res.render('devicedetail', { title: 'Device detail', year, message: 'Those are the device details. Connection string: ' + strcnx, device: device });
        } else
            res.render('devicedetail', { title: 'Device detail', year, message: 'Error connecting' });
    });
};

function getHostName(str)
{
    var txtchain = str.split(';');
    for (var strx in txtchain) {
        var txtbuck = txtchain[strx].split('=')
        if (txtbuck[0].toLowerCase() == 'hostname')
            return txtchain[strx];
    }
    return '';
}

As you’ll see in the jade page, the link to the page is /devicedeatil/name_of_a_device. In order to catch it, we’ll need to declare it in the route and it will allow to have it thru the req.params function. I will name it deviceid. so add this line in the app.ts file:

app.get('/devicedetail/:deviceId', routes.devicedetail);

First part of the code is about getting the list of devices and making sure the device exists. then it’s about getting the device and returning it. As sometimes you need the device connection string, this string is built and returned as well. As a result, you’ll get a detailed page like:

Those properties are the ones available for every device. The status shows is the device is allow or not to connect. If not, you’ll have a reason (128 bit max) displayed in the Status reason. If you send messages to your device, you’ll see as well if messages are waiting.

Adding a device to Azure IoT hub

Very similar to the previous part, we’ll just add a jade file adddevice. Here is the code:

extends layout

block content
  h2 #{title}
  p #{message}

  div.connbox
  if(deviceId==null)
    p please enter your device name
    form(name="adddevice", action="/adddevice", method="post")
      input(type="text", name="deviceId")
      input(type="submit", value="Add")

Simple code, very similar to the first example. For the main function code, it’s quite easy as well:

export function adddevice(req: express.Request, res: express.Response) {
    var devId = req.params.deviceId;
    if (devId == undefined) {
        devId = req.body['deviceId'];
        if (devId == undefined)
            res.render('adddevice', { title: 'Add device', year, message: 'Error, no device ID' });
    }
    if (cnxString == '')
        res.render('adddevice', { title: 'Add device', year, message: 'Error, no connection string' });
    else {
        var registry = iothub.Registry.fromConnectionString(cnxString);
        //create a new device
        var device = new iothub.Device(null);
        device.deviceId = devId;
        registry.create(device, function (err, deviceInfo, response) {
            if (err)
                res.render('adddevice', { title: 'Add device', year, message: 'Error, creating device' + err.toString() })
            else
                if (deviceInfo)
                    res.render('adddevice', { title: 'Add device', year, message: 'Device created ' + JSON.stringify(deviceInfo) });
                else
                    res.render('adddevice', { title: 'Add device', year, message: 'Unknown error creating device ' + devId });
        });
    } 
}

All up, first part of the code is just to check if there is a device name either thru get as a param, either thru post. Second part is about adding a device:

Again, very simple, very straight forward. we’re connecting to the Azure IoT Hub registry, then create an empty device, set the deviceId name and ask for creation.

Don’t forget to add the route as well. the “?” in “/adddevice/:deviceId?” is to make the param as optional.

app.get('/adddevice/:deviceId?', routes.adddevice);
app.post('/adddevice', routes.adddevice);

Once created, if there is no error, the device is sent back. I’m just converting it into a JSON and display it in the message:

You can do a very similar code to delete a device. You can as well send a message to the device and monitor the results. I have to say the Azure IoT SDK in node.js is really great and working perfectly. And please note that this website can be deployed on Azure, Windows or Linux or anything else that can run one of the latest node.js version (see restriction in the Azure Iot SDKs on GitHub here)

More examples on my GitHub! Enjoy and feedback welcome.

Setup the dev environement

I’ll use Windows as my development environnement. Visual Studio 2015 can support node.js development and debugging. So first I needed to setup Visual Studio 2015. You can get for free Visual Studio Community 2015 here. Then you need to the free node.js tools for Visual Studio, download them here. And you need of course to install the node.js framework from here.

And you’re all done for the dev side! so fast, so quick on the Windows side!

Setup the RaspberryPI

I have to say, this part was a bit more difficult for me. First I’m not a Linux guy, second, it’s not that easy to install node.js when you don’t really know what you need. So here are the steps to install the latest version. I have to say I’ve spend quite a lot of time trying to install the right version. The one by default in the raspian repository is not the latest version. Finally, after some time I found the way to properly install it from the Azure IoT SDK github page here. The version I’m running on the RPI is a Debian (wheezy). So if you’re running the Jessie or Wheezy version, to get node.js installed correctly, here are the steps:

sudo apt-get install curl
sudo curl --silent --location https://deb.nodesource.com/setup_0.12 | bash –
sudo apt-get install --yes nodejs

Most likely because of previous/bad versions installed before it didn’t worked right away. After a reboot, it did finally (who said, no reboot is necessary in Linux? ). This will install as well “npm” which will allow later to download some needed module packages.

Creating a node.js project in Visual Studio

this is quite straight forward, you have new project type which is node.js. I’ve created a Web project (this will allow easily to test couple of functions)

It will create a server.ts file. I do recommend to create TypeScript file and not Javascript. this will allow to have a better support and maintainability over time. Javascript file are generated once compiled. And you can choose which version of Javascript you want to generate.

You can hit F5 and run your code by default, it will create a project with a simple web server, you can try to debug, put break point. Quite magic

How to run all this on Raspberry?

the only 2 files you’ll need are the “server.js” and the “package.json” one. this second one contains the dependencies with other modules. So far, no real dependencies. It’s needed as well if you want to publish and share back your code as a package. So you’ll make sure that you’ll get all the right dependencies for your package and that it will always work.

to lunch the server, just type:

node server.js

The server will run as long as you close the console or stop it. Access it thru a browser with https://ipaddress:port/ the ipaddress is the ip address of the RPI and the port, the port you’ve chosen in your code.

If at this point it does not work, then it’s maybe because you have a node.js problem. Try to type “node –v”, this is supposed to give you the installed version. The one I’ve installed is v0.12.7

Installing packages on dev environment

With node.js you’ll need to install couple of packages. Both on the dev environment and on the production environment.

Using Visual Studio, makes it super easy. Just right click on “npm” in your project then select “Install new npm Packages…”

This will open this window where you can search for the packages.

We’ll need the following ones: “azure” and “azure-iot-device”. So install them. this will install all the packages and dependencies needed. It makes it very easy to see what are the available versions, if a package is already installed locally.

Installing packages on the RPI

it’s about the same except it’s in command line. Thanks to the npm utility in Visual Studio, I know the packages I’ll need to install  

sudo npm install azure
sudo npm install azure-iot-device

Note: if you need a specific version, you can install it by giving the version like: sudo npm install azure-iot-device@1.0.0-preview5

Connecting a device to Azure IoT Hub

The first thing to do is to create an Azure IoT Hub. Step by step here. This is great step by step, very easy. I do recommend to do all the tutorial and create all the codes in C#. This will allow you to understand how Azure IoT Hub is working. You’ll need this to continue this article.

The most important is to create at least 1 device identity. If you don’t, you will not be able to access the IoT Hub, send and receive messages.

The other tool I recommend you to use is part of the Azure IoT SDK and named DeviceExplorer. Follow the tutorial to create a device, launch this tool, put the connection string from your Azure IoT Hub in it (connection string look like: HostName=youriothub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=thekey), and you should be able to see the device:

From here, you’ll need for later the device ConnectionString. this connection string is different from the main hub connection string! it is formed the same way as the previous one but is contains DeviceId (here calle LaurelleRPI) which is the name of your device instead of SharedAccessKeyName.

HostName=youriothub.azure-devices.net;DeviceId=LaurelleRPI;SharedAccessKey=thedevicekey

In the code, you’ll need this to get connected to the IoT Hub:

var device = require('azure-iot-device');
// must match the deviceID in the connection string
var connectionstring = HostName=youriothub.azure-devices.net;DeviceId=LaurelleRPI;SharedAccessKey=thedevicekeyI';
var iotHubClient = new device.Client(connectionstring, new device.Https());

And yes, that’s all what you need! How to test it? We can modify a bit the web server code to have a function which will send data to the IoT Hub. We will check with the Device Explorer if data arrive. So add this to the previous code and change the server function.

var url = require('url');
var deviceID = 'LaurelleRPI';
var port = process.env.port || 1337

http.createServer(function (req, res) {
    var request = url.parse(req.url, true);
    var action = request.pathname;

     if (action == '/senddata') {
        var payload = '{\"deviceid\":\"' + deviceID + '\",\"wind\":42 }';
        var message = new device.Message(payload);
        iotHubClient.sendEvent(message, function (err, res) {
            if (!err) {
                if (res && (res.statusCode !== 204)) console.log('send status: ' + res.statusCode + ' ' + res.statusMessage);
            }
            else
                console.log('no data send, error ' + err.toString());
        });
        res.end('data sent');
    } else {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Linux RPI working perfectly, try /status /postimage /senddata and /image.jpg \n');
    }

}).listen(port);

Run the code and access to the https://ipaddress:1337/senddata

this will post data to the Azure IoT Hub and you’ll see them in the Device Explorer, You’ll need to monitor the device you’ve just created and you’ll use in your node.js code. At this point, you should see this:

if not, you’ll most likely get an error message. Most of the error I got was because I made a mistake in the connection string or in my Typescript.

Now, the next step is to be able to receive messages from the IoT Hub. In order to see if we have received a message or not, we’ll need to listen all the time to check is a message is arrived. The function bellow check is a message is arrived and place it into messageFromIoTHub

var messageFromIoTHub = "";

function pushtoblob()
{ //do nothing

}

function isMessage()
{
    iotHubClient.receive(function (err, res, msg) {
        if (!err && res.statusCode !== 204) {
            console.log('Received data: ' + msg.getData());
            // process the request
            messageFromIoTHub = msg.getData();
            if (messageFromIoTHub === "picture")
                pushtoblob();
            iotHubClient.complete(msg, function (err, res) {
                if (err) console.log('complete error: ' + err.toString());
                if (res && (res.statusCode !== 204)) console.log('complete status: ' + res.statusCode + ' ' + res.statusMessage);              
            });
            return true;
        } else if (err) {
            console.log('receive error: ' + err.toString());
        }
    });
    return false;
}

var isWaiting = false;
function waitForMessages() {
    isWaiting = true;
    isMessage()
    isWaiting = false;
}

// Start messages listener
setInterval(function () { if (!isWaiting) waitForMessages(); }, 1000);

The hub will be checked every second. Up to this point, you can test the code. Place a break point on the line “messageFromIoTHub = msg.getData();” and run the code.

From Device Explorer, send the message “picture”, if all geos well, you’ll receive back a feedback.

In terms of code, it’s quite straight forward, the Azure SDK IoT is very well done and easy to use. Most of the function to access the IoT hub are super well designed and only 1 or 2 functions are needed.

Uploading the picture to an Azure Blob storage

As for the previous part, you’ll need a storage setup. Follow the very well done step by step here. You’ll need to go thru to continue this code.

Blob storage are very easy as well to access in node.js. They can get access like https://mystorageaccount.blob.core.windows.net/mycontainer/myblob.

In terms of code, as for the IoT Hub, you need the connection string and create the access to the blob service.

var azure = require('azure');

//need to change AccountName and AccountKey
var connectionblob = 'DefaultEndpointsProtocol=https;AccountName=mystorageaccount;AccountKey=thelongkey';
var blobSvc = azure.createBlobService(connectionblob);

From the previous code, replace

function pushtoblob()
{
    blobSvc.createContainerIfNotExists('webcam', function (error, result, response) {
        if (!error) {
            // Container exists
            if (result == true)
                console.log('blob created');
            else
                console.log('blob existing');
        }
    });
    //create the picture named image.jpg
    //webcam.run();  
    // this will upload the picture named image.jpg which needs to be in the same directory as the js file
    blobSvc.createBlockBlobFromLocalFile('webcam', 'picture', 'image.jpg', function (error, result, response) {
        if (!error) {
            // file uploaded
            console.log('file uploaded :-) ');
        } else {
            console.log('error uploading picture');
        }
    });
}

the code is very straight forward as well. I do create a blob called “webcam” and upload an existing picture from the disk called “image.jpg”. We’ll see right after how to generate this picture from the webcam. In the meantime, make sure you add a picture called “image.jpg” in the same directory as your server.js file.

You can as well add the following code into the ‘'”http.createServer” function, after the “action =”.

if (action == '/image.jpg') {
        //webcam.run();
        var img = fs.readFileSync('./image.jpg');
        res.writeHead(200, { 'Content-Type': 'image/jpeg' });
        res.end(img, 'binary');
    }

Hit F5 in VS and test the code by accessing https://ipaddress:1337/image.jpg

You should be able to see the picture you’ve placed in the folder. now, go back to the Device Explorer, and send again the “picture” message. You will see a confirmation in the Device Explorer that the message has been received.

So how to check if the blob picture has been uploaded correctly?

One of the way is to check in the Azure portal is the container has been created. And you can change the properties to make it public for example, so you can directly from the browser check your image. You’ll access it like https://yourblobstorage.blob.core.windows.net/webcam/picture

You can use as well the excellent CloudBerry Explorer for Azure which you can download from here. Once setup (see my previous post where I show how to move one Azure VM from one subscription to another to have more info on how to setup this tool). If all went correctly, you should be able to see the “webcam” container created

if you double click in it, you’ll see the picture blob:

and if you double click on the “picture” blob, you can open it and download your picture.

Saving a picture from the webcam

I have to say, I did quite a lot of research to see if there is an efficient way to do this on a RPI. And there are not that many nice, easy and straight forward way to do it. First, not all webcam are supported. I had to check couple of webcams to find an old Lifecam-VX-6000 supported.

I finally went for some command line tool that generate images from the webcam entry (/dev/video0 for the default webcam). I’ve installed fswebcam

sudo apt-get install fswebcam

To create an image, just run “fswebcam image.jpg” and it will generate an image. Worked quite well on my Raspberry.

Then I’ve created in my project a webcam.ts file and put the following code:

'use strict'

var child = require('child_process');

module.exports = {
    run: function () {
        child.execSync('fswebcam image.jpg', function (err, stdout, stderr) {
            if (err !== null) {
                console.log('error ' + err);
            } else
            {
                console.log('image saved');
            }
        }); 
    }
};

and in the main server.js file:

var webcam = require('./webcam');

You can un comment the 2 lines you’ll find with this “//webcam.run();” This code just create the image from the webcam. Now, if you test this code on Windows, it will not create the image as the command “fswebcam” does not exist. But it will work on the RPI where you’ve install the command. Note that you need to use execSync to create the external process. It will wait for the external process to finish before continuing. If you're using the normal exec, the picture won't have time to be saved before the next steps.

Deployment on the Raspberry and all together

You’ll need to deploy only the 3 files: “server.js”, “webcam.js” and “package.json”. Use the method you want (I personnaly use the old smb way, so installing and setting up smb…). I have to say I like as well to access my Raspberry with Remote Desktop. Just install “xrdp”  and you’re good to go for this

And voilà, you can get it from your blob storage:

For sure all this can be improved, especially with the webcam part.

<edit> I've placed the webcam on the RPI which is in the garden and the picture can be found here. </edit>

Conclusion

Visual Studio 2015 + node.js tools + Azure IoT Hub + Azure Storage = happiness

So easy to develop, so easy to debug, so easy to find the right module with the npm tools in VS. All the Azure resources are really easy and simple to use with node.js.

The great news is that my solution is working the same way under Windows and Linux. Only difference is about the webcam part but I really didn’t need it on the Windows side.

I’ve learned a lot in this project and will for sure continue it!

https://portalvhdskb2vtjmyg3mg.blob.core.windows.net/webcam/picture

Step 1: Move the Azure VM from one Blob storage to another one

In Microsoft Azure, when you have a blob  storage, it can be attached only to 1 subscription. You can of course have multiple storage attached into a subscription. So first step is to move the VHD which is used by the VM.

For this, I used the excellent CloudBerry Explorer for Azure which you can download for free here. After installation, just register for free and you’re good to go.

You’ll need to add your 2 blob storage, the one you want to move the VHD from and the one you want to move the VHD to.

To find the name of the storage and the key, just go into the Azure management console and select Manage Access Keys, you’ll get the info you need to setup both accounts.

Once setup, you can now have a view like this:

Stop your VM and you’re good to copy/paste your VM from one storage to another.

Step 2: Create a Disk from VHD

In the management console, go to Virtual Machine then Disks

then Create

fill a name, select the VHD from the storage you just moved your VHD file to.

Step 3: Create the VM from the Disk

Go to the Virtual Machine instances

then create a New

select From Gallery

and go to Disks to select the disk you just created.

And you’re good to go to run your VM!

You can find them for few $, usually around 3$. It’s a low consumption board which can be powered by a battery and charged with a solar panel without draining the battery too fast when not connected tot eh wifi. So it makes it an interesting element for Internet of Things (IoT).

As there is an UART, you can as well use it as a super cheap wifi board for Arduino, Netduino and other boards like this. Full documentation for AT commands is here.

The other great news is that the Arduino community has been working on making a compatible version so you can use the wiring framework to program those boards. You can follow the steps here to install the components in the Arduino IDE. More info here.

And as good news are not coming alone, if like me, you’re a use fan of Visual Studio, you can even use the excellent Visual Micro complement to program it. And more info on Visual Micro and ESP8266 support here.

The most complicated part with this board is that it is only 3.3V, so be careful when alimenting it. I did a mistake and used 5V for couple of hours, the module is still alive but made the board reboot any time I wanted to drive a bit of current out of a GPIO. And that’s how when controlling I figured it out! To flash the board, you must put the GPIO0 to ground and reset the board. The UART is 5V tolerant so if you have an FTDI cable or equivalent which you can use to upload the code, make sure you will use only the Ground, RX and TX from the FTDI. Alimentation have to be 3.3V for the board. And once flashed, don’t forget to remove the GPIO0 from the ground.

And as I explained in this previous post with the Spark.io (renamed Particle.io), you can then directly post to Azure Mobile Services with this 3$ chip! I’m planning to use it to measure temperature and humidity plus level of water from my cellar (I have to manually empty a bucket of water from my cooling system). And this 3$ chip plus 1 DHT11/22 plus a water level sensor (using the digital output only as no analog input) will be perfect! And I’ll still need to see if I can use the UART as something else.

Enjoy :-)

But as .NET is a managed code runtime, there are some limitations when it come to do some very short timing operations as managed code can’t guaranty those easily. In order to have those operations working, you’ll need to build some native C code. But wait, I know you’re a fan of C# like me and you don’t want to build your full project in C! It’s like the old time when we had the excellent Visual Basic to build all the graphical interfaces, fast development for anything related to interfaces but lack of performance. At this time, most of the code were don in a C/C++ dll and imported with the famous dllimport into the VB code.

Well, we will do exactly the same here but replacing the old VB by the modern C# and for anything that need to be hard real time, we’ll put that into a C dll and import it into C#. But wait, here, our RaspberryPI is running Linux. So how to make that possible? In Linux as well, there are equivalent of dll, those are called library. They start with lib and have .so extensions. They are the exact same as dll but in the Linux world with the same advantages and same weaknesses.

Then, let start by the library first. I wanted to find some code that already worked with the WiringPI framework as I’m using it (see this article on how to install it on a RaspberryPI). And I fond this great example which was almost what I wanted. I just needed to adapt it a bit to make it working.

So I created (using my preferred tool Visual Studio), a normal C++ project. My main idea is to use it as an editor. I need 2 files: the library header and the core code. Both are important, and if you want to build a library you must have both. Let start with the header (called DHT11library.h in my code), here is the code:

#ifndef _DHTLIB

#define _DHTLIB

#ifdef __cplusplus

extern "C" {

#endif

       extern bool InitDHT(int pinval);

       extern float getTemp();

       extern float getHumidity();

       extern bool dht11_read_val();

#ifdef __cplusplus

}

#endif

#endif

What is the most important here is to have the entry point of the library properly declared in this header with extern. Now, the rest of the code in the file DHT11library.cpp:

#include <wiringPi.h> 

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include "DHT11library.h"

#define MAX_TIME 85

int DHT11PIN;

int dht11_val[5] = { 0, 0, 0, 0, 0 };

bool isinit = false;

bool InitDHT(int pinval)

{

       if (wiringPiSetup() == -1)

       {

              isinit = false;

              return isinit;

       }

       DHT11PIN = pinval;

       // initialize pin

       isinit = true;

       return isinit;

}

float getTemp()

{

       return (float)(dht11_val[2] + dht11_val[3] / 10);

}

float getHumidity()

{

       return (float)(dht11_val[0] + dht11_val[1] / 10);

}

bool dht11_read_val()

{

       if (!isinit)

              return false;

       uint8_t lststate = HIGH;

       uint8_t counter = 0;

       uint8_t j = 0, i;

       float farenheit;

       for (i = 0; i < 5; i++)

              dht11_val[i] = 0;

       pinMode(DHT11PIN, OUTPUT);

       digitalWrite(DHT11PIN, LOW);

       delay(18);

       digitalWrite(DHT11PIN, HIGH);

       delayMicroseconds(40);

       pinMode(DHT11PIN, INPUT);

       for (i = 0; i < MAX_TIME; i++)

       {

              counter = 0;

              while (digitalRead(DHT11PIN) == lststate){

                     counter++;

                     delayMicroseconds(1);

                     if (counter == 255)

                           break;

              }

              lststate = digitalRead(DHT11PIN);

              if (counter == 255)

                     break;

              // top 3 transistions are ignored 

              if ((i >= 4) && (i % 2 == 0)){

                     dht11_val[j / 8] <<= 1;

                     if (counter>16)

                           dht11_val[j / 8] |= 1;

                     j++;

              }

       }

       // verify cheksum and print the verified data 

       if ((j >= 40) && (dht11_val[4] == ((dht11_val[0] + dht11_val[1] + dht11_val[2] + dht11_val[3]) & 0xFF)))

       {

              if ((dht11_val[0] == 0) && (dht11_val[2] == 0))

                     return false;

              return true;

       }

       return false;

}

As you can see, the code is very similar to the example code I found. I just added 3 functions to initialize the pin I’ll use and return both the temperature and humidity. Every time I’ll need to read the DHT11, I’ll call the dht11_read_val and then call both functions to return the temperature and humidity.

Now, this is where you have to pay attention to make sure you’ll build the library correctly. You need to copy both file the DHT11library.cpp and .h into the Raspberry (I’m using a Samba share for this), then using PyuTTY or another way, connect to the Raspberry, go to the directory where you have placed the 2 files and compile the library:

sudo gcc -o libDHT11.so DHT11library.cpp -L/usr/local/lib -lwiringPi –shared

-o command will allow you to define the name of the library, on Linux, name need to start with lib and finish with so. At least that’s the only way I managed to make it working. I’m not a Linux expect so I may have miss something.

-L and –lwinringPI reference the rest of the library. You must have compiled and installed the WiringPI framework before of course.

-shared is the command to tell gcc to build a library

If everything goes well, you’ll get your libDHT11.so compiled and ready to use. So let move to C# now. You can create a normal C# project using Visual Studio, .NET 4.0 type is recommended to work on Mono.

I have created a class that embedded the C library and then allow to be used like a normal class:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using RaspberryPiNETMF;

using Microsoft.SPOT.Hardware;

using System.Timers;

namespace SerreManagement

{

    public class NewDataArgs

    {

        public NewDataArgs(float temp, float hum)

        { Temperature = temp; Humidity = hum; }

        public float Temperature { get; private set; }

        public float Humidity { get; private set; }

    }

    class DHT11

    {

        //bool InitDHT(int pinval)

        [DllImport("libDHT11.so", EntryPoint = "InitDHT")]

        static extern bool InitDHT(int pinval);

        //float getTemp()

        [DllImport("libDHT11.so", EntryPoint = "getTemp")]

        static extern float getTemp();

        //float getHumidity()

        [DllImport("libDHT11.so", EntryPoint = "getHumidity")]

        static extern float getHumidity();

        //bool dht11_read_val()

        [DllImport("libDHT11.so", EntryPoint = "dht11_read_val")]

        static extern bool dht11_read_val();

        // private values

        private Cpu.Pin mPin;

        private int mSec;

        private Timer mTimer = new Timer();

        public delegate void NewData(object sender, NewDataArgs e);

        public event NewData EventNewData;

        // to get temperature and humidity

        public float Temperature { get; internal set; }

        public float Humidity { get; internal set; }

        public DHT11(Cpu.Pin pin, int seconds = 0)

        {

            mPin = pin;

            mSec = seconds;

            if (!InitDHT((int)pin))

                throw new Exception("Error initalizing DHT11");

            mTimer.Elapsed += mTimer_Elapsed;

        }

        void mTimer_Elapsed(object sender, ElapsedEventArgs e)

        {

            if (dht11_read_val())

            {

                Temperature = getTemp();

                Humidity = getHumidity();

                if (EventNewData != null)

                    EventNewData(this, new NewDataArgs(Temperature, Humidity));

            }

        }

        public void Start()

        {

            if (mSec != 0)

            {

                mTimer.Interval = mSec * 1000;

                mTimer.Start();

            }

        }

        public void Stop()

        {

            mTimer.Stop();

        }

        public bool ReadDHT11()

        {

            return (dht11_read_val());

        }

    }

}

The way to import the library is simple, it’s like for a Windows dll, it’s just the name changing. Be very careful if you build more complex library because the type conversion as well as pointers conversion may not be strait forward, you’ll need to use marshaling:

//bool InitDHT(int pinval)

[DllImport("libDHT11.so", EntryPoint = "InitDHT")]

static extern bool InitDHT(int pinval);

This is working with any kind of already existing Linux library, the only thing you need is the header file with the definition in order to find the right entry points as well as the exact types used.

Then usage of the class is really simple:

DHT11 mDHT;

mDHT = new DHT11(Cpu.Pin.Pin_P1_18, 30);

mDHT.EventNewData += mDHT_EventNewData;

mDHT.Start();

void mDHT_EventNewData(object sender, NewDataArgs e)

{

    Console.WriteLine("Temp: " + e.Temperature + ", Hum: " + e.Humidity);

}

In our case, the DHT11 is linked to the Pin 18 on a Raspberry and the call for temperature and humidity is done every 30 seconds. The event is raised and the data can be read. You can then create an exe with Visual Studio, and run it on the RPI. Don’t forget to copy all the dll you’ll need as well as the libDHT11.so one. It is a dll so it has to be present with the exe. If not present, you’ll get an exception

Results looks like:

Temp: 23, Hum: 34

The DHT11 is very simple and the temperature and humidity is not precise, you don’t have anything after the decimal point. the DHT22 is much better, it’s very easy to adapt this code to it, the difference with DHT11 is very tinny.