Your turn. What do you think?

Thanks a lot for watching the video. Did I miss anything that you may think which is needed in this video? Could you find this post as useful? Kindly do not forget to share me your feedback and subscribe the channel.

Kindest Regards
Sibeesh Venu

Introduction

Playing with Azure IoT DevKit MXChip is always fun, the device has many capabilities. For the past few days, I have been working with some of the capabilities of this device like Atmospheric pressure, Temperature, Humidity through its Sensors. In this Article, I will show you how you can calculate the noise level using the microphone of AZ3166 IoT Device. Now let’s start implementing the same. I hope you will like it.

Background

In our last article, we have already seen how to read the temperature, humidity, atmospheric pressure from the MXChip AZ3166 sensors and send those to our Azure IoT Hub. Here in this article let’s do the following tasks.

1. Find the Noise level using the AudioClassV2 class
2. Send the Values to our IoT Hub

Source Code

Please feel free to play around with this repository.

Using the Code

Once you have your own work space, we can open the solution in VSCode and start coding.

main.ino

This is our solution starting point, every project must have its own sketch file, usually this file will be containing at least the functions loop() and setup().

Before we get started, let’s include the header files we are going to use.

Now we can declare our constants and variables.

Now we can add the codes for the configuration, usually, you wouldn’t have to edit any codes in this section.

As I mentioned earlier, every INO file will have its own setup() and loop() function. We can modify our setup() function as below.

The function loop() will be called each 5 seconds, as I had set the INTERVAL as 5000 milliseconds.

Now we can edit our code of loop() function as below.

utility.cpp

As you can see, once we get the values from the function get_prediction (), we are passing the decibels values to our setMessage() function, which we have defined in the file utility.cpp. Inside the setMessage () function, we will add the decibels value to JSON object using the function json_object_set_number ().

You should also add the files featurizer.h and featurizer.s to get it working. You can get those files from the source code repository mentioned above.

Compile and Upload to the Device

As we have already made the needed changes, it is time to compile the Device solution and upload the same to our Device. Press F1 and select Azure IoT Device Workbench: Compile Device Code. If you ever get an error as “error: utility.h: No such file or directory”, please compile the device code again. If you are facing any unexpected errors, please delete the “.build” folder and compile again.

Once you get a message as ” [Done] Finished verify sketch – Main.ino ” in your Output window, you can upload the solution to your device. To do so, press F1 again, and select ” Azure IoT Device Workbench: Upload Device Code”. Please make sure that the device is been connected to your machine. If everything goes well, you will be getting a message as ” [Done] Uploaded the sketch: Main.ino”.

Please remember to see the GitHub repository for the full code.

Device to Cloud Messages

Now your device will be sending the Decibels data to the Azure IoT Hub. Let’s see that in the D2C Monitoring window.

Conclusion

Wow!. Now we have learned,

• How to detect the noise level in MXChip
• How to use AudioClassV2
• How to send device data to the Azure IoT Hub

Please consider reading my IoT articles here for the continuation.

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

I have got my MXChip a few days ago, and I have been playing with the same. Here in this article, we will see how we can set up our MXChip and get it working to send Temperature, Humidity, Pressure etc information to our Azure IoT Hub. Once we have received the data in our Azure IoT Hub we can do anything with that, I have already written some articles on the same topic, you can read them here. Let’s configure our IoT device now.

Background

The MXChip is a microcontroller with a bunch of sensors in it, the main advantage of this device is it is connected to Azure, which made the device to cloud and cloud to device transmission easier than ever. Here in this article, we will configure this device with the help of a tool/extension called Azure IoT Workbench in Visual Studio code. Once we are done configuring, we can change the CPP code to send the pressure information from the pressure sensor to the Azure IoT Hub.

Source Code

Please feel free to play with this repository here.

Set Up the System

Before we get started developing our device application/code, we need to set our environment first. So, please make sure that you are following this article and configure your Getting started project.

Using the Code

Once you are able to see the D2C (Device to Cloud) and C2D (Cloud to Device) data, we are good to go and write some code to get the Pressure information from the Pressure Sensor (LPS22HB).

If you open the Device code, from the Getting started tutorial, which got generated using the Azure IoT Workbench tool. You can see the files as below.

Here, the file azureconfig.json has the connection string information to your IoT Hub, Event Hub.

{
    "componentConfigs": [
        {
            "id": "e8d86334-156d-e40b-9618-a6a54bb94b25",
            "folder": "",
            "name": "",
            "dependencies": [],
            "type": "IoTHub",
            "componentInfo": {
                "values": {
                    "iotHubConnectionString": "",
                    "eventHubConnectionString": "",
                    "eventHubConnectionPath": ""
                }
            }
        }
    ]
}

The file project.code-workspace will have your Device code settings, including the Device path. Usually you wouldn’t need to check these files, as these values are automatically created when you are doing the provisioning as mentioned in the Get started tutorial.

The folder Device will have your Arduino code, here we are writing the codes in CPP (C++). If you open the solution in Visual Studio code, it will ask you open the work space, which is nothing but our Device code. Just click on Open Workspace, then we can start coding.

The Config.h file is our configuration file.

#define INTERVAL 2000

#define MESSAGE_MAX_LEN 256

#define TEMPERATURE_ALERT 30

The GetStarted.ino file contains the code for initial set up, that is, to make the device run. It contains the code for WiFi configuration, and Device to Cloud, Cloud to Device communication etc. Below is the sample code.

// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. 
// To get started please visit https://microsoft.github.io/azure-iot-developer-kit/docs/projects/connect-iot-hub?utm_source=ArduinoExtension&utm_medium=ReleaseNote&utm_campaign=VSCode
#include "AZ3166WiFi.h"
#include "AzureIotHub.h"
#include "DevKitMQTTClient.h"

#include "config.h"
#include "utility.h"
#include "SystemTickCounter.h"

static bool hasWifi = false;
int messageCount = 1;
static bool messageSending = true;
static uint64_t send_interval_ms;

//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Utilities
static void InitWifi()
{
  Screen.print(2, "Connecting...");
  
  if (WiFi.begin() == WL_CONNECTED)
  {
    IPAddress ip = WiFi.localIP();
    Screen.print(1, ip.get_address());
    hasWifi = true;
    Screen.print(2, "Running... \r\n");
  }
  else
  {
    hasWifi = false;
    Screen.print(1, "No Wi-Fi\r\n ");
  }
}

static void SendConfirmationCallback(IOTHUB_CLIENT_CONFIRMATION_RESULT result)
{
  if (result == IOTHUB_CLIENT_CONFIRMATION_OK)
  {
    blinkSendConfirmation();
  }
}

static void MessageCallback(const char* payLoad, int size)
{
  blinkLED();
  Screen.print(1, payLoad, true);
}

static void DeviceTwinCallback(DEVICE_TWIN_UPDATE_STATE updateState, const unsigned char *payLoad, int size)
{
  char *temp = (char *)malloc(size + 1);
  if (temp == NULL)
  {
    return;
  }
  memcpy(temp, payLoad, size);
  temp[size] = '\0';
  parseTwinMessage(updateState, temp);
  free(temp);
}

static int  DeviceMethodCallback(const char *methodName, const unsigned char *payload, int size, unsigned char **response, int *response_size)
{
  LogInfo("Try to invoke method %s", methodName);
  const char *responseMessage = "\"Successfully invoke device method\"";
  int result = 200;

  if (strcmp(methodName, "start") == 0)
  {
    LogInfo("Start sending temperature and humidity data");
    messageSending = true;
  }
  else if (strcmp(methodName, "stop") == 0)
  {
    LogInfo("Stop sending temperature and humidity data");
    messageSending = false;
  }
  else
  {
    LogInfo("No method %s found", methodName);
    responseMessage = "\"No method found\"";
    result = 404;
  }

  *response_size = strlen(responseMessage) + 1;
  *response = (unsigned char *)strdup(responseMessage);

  return result;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Arduino sketch
void setup()
{
  Screen.init();
  Screen.print(0, "IoT DevKit");
  Screen.print(2, "Initializing...");
  
  Screen.print(3, " > Serial");
  Serial.begin(115200);

  // Initialize the WiFi module
  Screen.print(3, " > WiFi");
  hasWifi = false;
  InitWifi();
  if (!hasWifi)
  {
    return;
  }

  LogTrace("HappyPathSetup", NULL);

  Screen.print(3, " > Sensors");
  SensorInit();

  Screen.print(3, " > IoT Hub");
  DevKitMQTTClient_SetOption(OPTION_MINI_SOLUTION_NAME, "DevKit-GetStarted");
  DevKitMQTTClient_Init(true);

  DevKitMQTTClient_SetSendConfirmationCallback(SendConfirmationCallback);
  DevKitMQTTClient_SetMessageCallback(MessageCallback);
  DevKitMQTTClient_SetDeviceTwinCallback(DeviceTwinCallback);
  DevKitMQTTClient_SetDeviceMethodCallback(DeviceMethodCallback);

  send_interval_ms = SystemTickCounterRead();
}

void loop()
{
  if (hasWifi)
  {
    if (messageSending && 
        (int)(SystemTickCounterRead() - send_interval_ms) >= getInterval())
    {
      // Send teperature data
      char messagePayload[MESSAGE_MAX_LEN];

      bool temperatureAlert = readMessage(messageCount++, messagePayload);
      EVENT_INSTANCE* message = DevKitMQTTClient_Event_Generate(messagePayload, MESSAGE);
      DevKitMQTTClient_Event_AddProp(message, "temperatureAlert", temperatureAlert ? "true" : "false");
      DevKitMQTTClient_SendEventInstance(message);
      
      send_interval_ms = SystemTickCounterRead();
    }
    else
    {
      DevKitMQTTClient_Check();
    }
  }
  delay(1000);
}

Below is the content of the file utility.h.

#ifndef UTILITY_H
#define UTILITY_H

void parseTwinMessage(DEVICE_TWIN_UPDATE_STATE, const char *);
bool readMessage(int, char *);

void SensorInit(void);

void blinkLED(void);
void blinkSendConfirmation(void);
int getInterval(void);

We will be defining all these functions inside the file called utility.cpp file, and that’s where most of our codes are going to be. When you are finished the Get started the tutorial, the initial code will contain the functions which can read the temperature, humidity information from the sensor and send to the cloud. And as you have guessed, it is missing the code for reading and sending the pressure information. Here we are going to do that. Below is the initial code.

// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. 

#include "HTS221Sensor.h"
#include "AzureIotHub.h"
#include "Arduino.h"
#include "parson.h"
#include "config.h"
#include "RGB_LED.h"

#define RGB_LED_BRIGHTNESS 32

DevI2C *i2c;
HTS221Sensor *sensor;
static RGB_LED rgbLed;
static int interval = INTERVAL;
static float humidity;
static float temperature;

int getInterval()
{
    return interval;
}

void blinkLED()
{
    rgbLed.turnOff();
    rgbLed.setColor(RGB_LED_BRIGHTNESS, 0, 0);
    delay(500);
    rgbLed.turnOff();
}

void blinkSendConfirmation()
{
    rgbLed.turnOff();
    rgbLed.setColor(0, 0, RGB_LED_BRIGHTNESS);
    delay(500);
    rgbLed.turnOff();
}

void parseTwinMessage(DEVICE_TWIN_UPDATE_STATE updateState, const char *message)
{
    JSON_Value *root_value;
    root_value = json_parse_string(message);
    if (json_value_get_type(root_value) != JSONObject)
    {
        if (root_value != NULL)
        {
            json_value_free(root_value);
        }
        LogError("parse %s failed", message);
        return;
    }
    JSON_Object *root_object = json_value_get_object(root_value);

    double val = 0;
    if (updateState == DEVICE_TWIN_UPDATE_COMPLETE)
    {
        JSON_Object *desired_object = json_object_get_object(root_object, "desired");
        if (desired_object != NULL)
        {
            val = json_object_get_number(desired_object, "interval");
        }
    }
    else
    {
        val = json_object_get_number(root_object, "interval");
    }
    if (val > 500)
    {
        interval = (int)val;
        LogInfo(">>>Device twin updated: set interval to %d", interval);
    }
    json_value_free(root_value);
}

void SensorInit()
{
    i2c = new DevI2C(D14, D15);
    sensor = new HTS221Sensor(*i2c);
    sensor->init(NULL);

    humidity = -1;
    temperature = -1000;
}

float readTemperature()
{
    sensor->reset();

    float temperature = 0;
    sensor->getTemperature(&temperature);

    return temperature;
}

float readHumidity()
{
    sensor->reset();

    float humidity = 0;
    sensor->getHumidity(&humidity);

    return humidity;
}

bool readMessage(int messageId, char *payload)
{
    JSON_Value *root_value = json_value_init_object();
    JSON_Object *root_object = json_value_get_object(root_value);
    char *serialized_string = NULL;

    json_object_set_number(root_object, "messageId", messageId);

    float t = readTemperature();
    float h = readHumidity();
    bool temperatureAlert = false;
    if(t != temperature)
    {
        temperature = t;
        json_object_set_number(root_object, "temperature", temperature);
    }
    if(temperature > TEMPERATURE_ALERT)
    {
        temperatureAlert = true;
    }
    
    if(h != humidity)
    {
        humidity = h;
        json_object_set_number(root_object, "humidity", humidity);
    }
    serialized_string = json_serialize_to_string_pretty(root_value);

    snprintf(payload, MESSAGE_MAX_LEN, "%s", serialized_string);
    json_free_serialized_string(serialized_string);
    json_value_free(root_value);
    return temperatureAlert;
}

We use different sensors for different items, thus different abstract classes for different things. For example, the abstract class HTS221Sensor is used for Humidity and Temperature, and LPS22HBSensor sensor for pressure.

So let’s include the LPS22HBSensor.

#include "LPS22HBSensor.h"
#include "utility.h"

Now, create a reference of the same.

LPS22HBSensor *pSensor;
static float pressure;

Modify the SensorInit() function by initializing the class LPS22HBSensor.

void SensorInit()
{
    i2c = new DevI2C(D14, D15);
    sensor = new HTS221Sensor(*i2c);
    sensor->init(NULL);

    pSensor = new LPS22HBSensor(*i2c);
    pSensor->init(NULL);

    humidity = -1;
    temperature = -1000;
    pressure = 0;
}

Now, create a new function which can read the Pressure from the sensor.

float readPressure()
{
    float pressure = 0;
    pSensor->getPressure(&pressure);

    return pressure;
}

Now it is time to add the pressure information to the output JSON file, by using the function json_object_set_number. Modify the function readMessage with the following code.

float p = readPressure();
if (p != pressure) {
    pressure = p;
    json_object_set_number(root_object, "pressure", pressure);
}

Now, we have done coding for our device, and it is time to upload the code to the device.

Upload the Code to IoT Device

As we already have the IoT Workbench tool installed, it is super easy to upload the new code to the device. Press F1 in Visual Studio code and select ‘Azure IoT Device Workbench: Upload Device Code’. This command will compile your code, and it throws the error in the Output terminal if there are any. It does the following actions.

1. Load the configurations
2. Initialize the packages
3. Prepare your board for the upload, the Programming LED will blink at this time
4. Verify everything

If everything goes well, you should be able to see an output as below.

Global variables use 60920 bytes (23%) of dynamic memory, leaving 201224 bytes for local variables. Maximum is 262144 bytes.
Uploading...
Info : clock speed 1800 kHz
Info : STLINK v2 JTAG v31 API v2 SWIM v21 VID 0x0483 PID 0x374B
Info : using stlink api v2
Info : Target voltage: 3.307278
** Programming Started **
auto erase enabled
Info : device id = 0x30006441
Info : flash size = 1024kbytes
** Programming Finished **
** Verify Started **
target halted due to breakpoint, current mode: Thread 
xPSR: 0x61000000 pc: 0x2000002e msp: 0x200073fc
verified 578060 bytes in 1.120772s (503.681 KiB/s)
** Verified OK **
** Resetting Target **
shutdown command invoked
[Done] Uploaded the sketch: GetStarted.ino

Check the Device to Cloud Messages

Now, it is time to check the information we are passing to our Azure IoT Hub. Go to Azure IoT Hub Devices section in Visual Studio Code, and right-click on the device and select ‘Start Monitoring Device to Cloud (D2C) Message’

A new Output Terminal will get opened, where you can see the data we send to cloud.

[IoTHubMonitor] Start monitoring D2C message for [ml-pf] ...
[IoTHubMonitor] Created partition receiver [0] for consumerGroup [$Default]
[IoTHubMonitor] Created partition receiver [1] for consumerGroup [$Default]
[IoTHubMonitor] Created partition receiver [2] for consumerGroup [$Default]
[IoTHubMonitor] Created partition receiver [3] for consumerGroup [$Default]
[IoTHubMonitor] [11:16:45 AM] Message received from [ml-pf]:
{
  "body": {
    "messageId": 198,
    "temperature": 28,
    "pressure": 1007.074707
  },
  "applicationProperties": {
    "temperatureAlert": "false"
  }
}

Conclusion

Wow!. Now we have learned,

• How to use IoT Workbench tool in Visual Studio Code
• How to set up your MXChip device
• How to write C++ code for Arduino
• How to get the Pressure information from the sensor
• How to upload the new code to MXChip device
• How to perform the Device to Cloud message output.

Please consider reading my IoT articles here for the continuation.

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

The data coming from the IoT devices are to be shown in real time, if we failed to do that, then there is no point in showing it. Here in this article, we will see how we can show the real-time data from our IoT device in an Angular application using Azure SignalR service and Azure Functions. Sounds interesting? So the flow of data can be defined as IoT device -> Azure IoT Hub -> Azure Function -> Azure SignalR Service -> Angular application. Sounds interesting? Let’s start then.

Background

In our previous article, we have already created an Azure Function which pulls the Data from our IoT Hub whenever there is any new messages/events happening. If you have not read the same, please read it.

Source Code

Please feel free to fork, clone this project from GitHub here: Realtime-IoT-Device-Data-using-Azure-SignalR-and-Azure-Function-in-Angular

Real-time IoT Data Processing

We will be creating two solutions, one for Angular application and one for Azure Functions. We will also create a new Azure Signal R service in the Azure portal.

Azure SignalR Service

According to Microsoft, Azure SignalR Service is an Azure managed PaaS service to simplify the development, deployment, and management of real-time web application using SignalR, with Azure supported SLA, scaling, performance, and security. The service provides API/SDK/CLI/UI, and the rich set of code samples, templates, and demo applications.

Core features for Azure SignalR Service:

• Native ASP.NET Core SignalR development support
• ASP.NET Core SignalR backend for improved performance and stability
• Redis based backplane scaling
• Web Socket, comet, and .NET Server-Sent-Event support
• REST API support for server broadcast scenarios
• Resource Provider support for ARM Template based CLI
• Dashboard for performance and connection monitoring
• Token-based AUTH model

Let’s log in to our Azure portal and create a new Azure Signal R service. Click on the +Create a resource and search SignalR Service. Once you have created the service, go to the keys section and copy the connection string, we will be using the same in our Azure Function.

Azure Functions

As we discussed in my previous article, we will be creating an Azure Function with an IoTHubTrigger in it. You can refer to this article for the hints on how to create an Azure Function solution in Visual Studio. Please make sure that you had installed the required packages as mentioned in the image below.

Once you have created a new Function in the solution it is time to add some code.

using Microsoft.Azure.EventHubs;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.SignalRService;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Text;
using System.Threading.Tasks;
using IoTHubTrigger = Microsoft.Azure.WebJobs.EventHubTriggerAttribute;

namespace AzureFunction
{
    public static class SignalR
    {
        [FunctionName("SignalR")]
        public static async Task Run(
            [IoTHubTrigger("messages/events", Connection = "IoTHubTriggerConnection", ConsumerGroup = "ml-iot-platform-func")]EventData message,
            [SignalR(HubName = "broadcast")]IAsyncCollector<SignalRMessage> signalRMessages,
            ILogger log)
        {
            var deviceData = JsonConvert.DeserializeObject<DeviceData>(Encoding.UTF8.GetString(message.Body.Array));
            deviceData.DeviceId = Convert.ToString(message.SystemProperties["iothub-connection-device-id"]);


            log.LogInformation($"C# IoT Hub trigger function processed a message: {JsonConvert.SerializeObject(deviceData)}");
            await signalRMessages.AddAsync(new SignalRMessage()
            {
                Target = "notify",
                Arguments = new[] { JsonConvert.SerializeObject(deviceData) }
            });
        }
    }
}

As you can see we are using Microsoft.Azure.WebJobs.EventHubTriggerAttribute for pulling data from our IoT Hub. Here “messages/events” is our Event Hub Name and Connection is the IoT Hub connections string which is defined in the local.settings.json file and the ConsumerGroup is the group I have created for the Azure Function solution.

If you have noticed, we are using the HubName as “broadcast” in the SignalR attribute and “notify” as the SignalR message Target property. If you change the Target property, you may get a warning in your browser console as “Warning: No client method with the name ‘notify’ found.”. The @aspnet/signalr package is checking for the Target property ‘notify’ by default.

So, I will keep the Target property as ‘notify’. By default, the message data doesn’t contain the device id value, so we will have to get the same from SystemProperties.

 var deviceData = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(message.Body.Array));
             deviceData.DeviceId = Convert.ToString(message.SystemProperties["iothub-connection-device-id"]);

Below is my DeviceData class.

using Newtonsoft.Json;
using System;

namespace AzureFunction
{
    public class DeviceData
    {
        [JsonProperty("messageId")]
        public string MessageId { get; set; }

        [JsonProperty("deviceId")]
        public string DeviceId { get; set; }

        [JsonProperty("temperature")]
        public string Temperature { get; set; }

        [JsonProperty("humidity")]
        public string Humidity { get; set; }

        [JsonProperty("pressure")]
        public string pressure { get; set; }

        [JsonProperty("pointInfo")]
        public string PointInfo { get; set; }

        [JsonProperty("ioTHub")]
        public string IoTHub { get; set; }

        [JsonProperty("eventEnqueuedUtcTime")]
        public DateTime EventEnqueuedUtcTime { get; set; }

        [JsonProperty("eventProcessedUtcTime")]
        public DateTime EventProcessedUtcTime { get; set; }

        [JsonProperty("partitionId")]
        public string PartitionId { get; set; }
    }
}

When you work with any client like Angular application, it is important that we need to get the token/connection from the server, so that the client can persist the connection with the server, hence the data can be pushed to the client from SignalR service. So, we will create a new Azure Function which will return the connection information with the Url and AccessToken.

using Microsoft.AspNetCore.Http;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Extensions.SignalRService;
using Microsoft.Extensions.Logging;

namespace AzureFunction
{
    public static class SignalRConnection
    {
        [FunctionName("SignalRConnection")]
        public static SignalRConnectionInfo Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
            [SignalRConnectionInfo(HubName = "broadcast")] SignalRConnectionInfo info,
            ILogger log) => info;
    }
}

Please make sure that you have set AuthorizationLevel.Anonymous in HttpTrigger attribute and also to use the same HubName we have used for our other Azure Function, which is SignalR.

Now we can customize our local.settings.json file.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet",
    "AzureSignalRConnectionString": "",
    "MSDEPLOY_RENAME_LOCKED_FILES": 1,
    "IoTHubTriggerConnection": ""
  },
  "Host": {
    "LocalHttpPort": 7071,
    "CORS": "*"
  }
}

Please be noted that this file if for local configuration and remember to change the connections strings here before you run the application. If you want to enable the CORS in the Azure Function in the Azure Portal, you can do that by following the steps mentioned in the image below.

Angular Client

As we have already created our Azure Functions, now it is time to create our Angular client. Let’s use Angular CLI and create a new project. Now we can add a new package @aspnet/signalr to our application which will help us to talk to our Azure SignalR service.

home.component.ts

Below is my code for home.component.ts file.

import { Component, OnInit, NgZone } from '@angular/core';
import { SignalRService } from 'src/app/services/signal-r.service';
import { StreamData } from 'src/app/models/stream.data';

@Component({
  selector: 'app-home',
  templateUrl: './home.component.html',
  styleUrls: ['./home.component.css']
})
export class HomeComponent implements OnInit {
  streamData: StreamData = new StreamData();

  constructor(private signalRService: SignalRService) {
  }

  ngOnInit() {
    this.signalRService.init();
    this.signalRService.mxChipData.subscribe(data => {
      this.streamData = JSON.parse(data);
      console.log(data);
    });
  }
}

home.component.html

We use Material card to show the Device data, so we can define our home.component.html file as preceding.

<div class="container">
  <div class="row">
    <mat-card class="example-card">
      <mat-card-header>
        <div mat-card-avatar class="example-header-image"></div>
        <mat-card-title>Real Time Values</mat-card-title>
        <mat-card-subtitle>The real time values of humidity, temprature etc...</mat-card-subtitle>
      </mat-card-header>
      <mat-card-content>
        <p>
          <label>DeviceId: </label>
          {{streamData?.deviceId}}
        </p>
        <p>
          <label>Temperature: </label>
          {{streamData?.temperature}}
        </p>
        <p>
          <label>Humidity: </label>
          {{streamData?.humidity}}
        </p>
      </mat-card-content>
    </mat-card>
  </div>
</div>

signal-r.service.ts

Now, we can create a new service which calls our Azure SignalR service.

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable, Subject } from 'rxjs';
import { SignalRConnection } from '../models/signal-r-connection.model';
import { environment } from '../../environments/environment';
import * as SignalR from '@aspnet/signalr';

@Injectable({
  providedIn: 'root'
})

export class SignalRService {
  mxChipData: Subject<string> = new Subject();
  private hubConnection: SignalR.HubConnection;

  constructor(private http: HttpClient) {
  }

  private getSignalRConnection(): Observable<SignalRConnection> {
    return this.http.get<SignalRConnection>(`${environment.baseUrl}SignalRConnection`);
  }

  init() {
    this.getSignalRConnection().subscribe(con => {
      const options = {
        accessTokenFactory: () => con.accessToken
      };

      this.hubConnection = new SignalR.HubConnectionBuilder()
        .withUrl(con.url, options)
        .configureLogging(SignalR.LogLevel.Information)
        .build();

      this.hubConnection.start().catch(error => console.error(error));

      this.hubConnection.on('notify', data => {
        this.mxChipData.next(data);
      });
    });
  }
}

As you can see, we are doing the following things in our service.

1. Get the SignalR connection information which contains Url and Access token, by calling the SignalRConnection Azure Function.
2. Create the Hub connection using SignalR.HubConnectionBuilder.
3. Start the Hub connection
4. Wire the ‘notify’ function, remember we have set this in our Azure Function SignalR.

signal-r-connection.model.ts

export class SignalRConnection {
   url: string;
   accessToken: string;
}

stream.data.ts

export class StreamData {
    messageId: string;
    deviceId: string;
    temperature: string;
    humidity: string;
    pressure: string;
    pointInfo: string;
    ioTHub: string;
    eventEnqueuedUtcTime: string;
    eventProcessedUtcTime: string;
    partitionId: string;
}

Output

Now, let’s just run our Angular application, Azure Function, and a simulated device. Please refer to this link for the information related to the Simulated device. Please feel free to connect to your IoT device, if you haven’t configured the simulated device.

References

1. Server less real-time messaging

Conclusion

Wow!. Now we have learned,

• How to connect IoT Hub and Azure Function
• What is Triggers in Azure Function
• How to connect Azure Function and Azure SignalR service
• How to post data to Azure SignalR service
• How to connect Azure SignalR service from Angular client
• How to show real time data in Angular application from IoT device

You can always ready my IoT articles here.

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

For the past few days I am playing with my MXChip and had written some articles about the same, you should be able to find those here. Here in this article, we will send some data to our Azure IoT hub and we will connect an Azure Function with our IoT Hub using IoTHubTrigger Event Hub Trigger Attribute. If you are ready, let’s do this.

Background

As I said this article is part of my IoT article series, so if you have read my previous articles on this topic, it may be easier for you to understand the concept. Before you start this article, please make sure that you had already created an Azure IoT hub and it is running. You can always send the messages to this IoT Hub either by connecting the actual device, let’s say an MXChip or using a simulating device.

IoTHubTrigger Demo

Creating an Azure Function App

I am going to create an Azure Function App in Visual Studio, if you are not sure about how we can create and publish the Azure Function, please read this section of my previous article. Let’s create a new solution now.

Once you click OK, a new Azure Function will be generated for you with some initial codes in it. Let’s edit the Function as below.

using Microsoft.Azure.EventHubs;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using System.Text;
using IoTHubTrigger = Microsoft.Azure.WebJobs.EventHubTriggerAttribute;

namespace IoTHubTrigger_Azure_Function_and_Azure_IoT_Hub
{
    public static class IoTHubFunc
    {
        [FunctionName("IoTHubData")]
        public static void Run(
            [IoTHubTrigger("messages/events", Connection = "IoTHubTriggerConnection", ConsumerGroup ="FuncGroup")]EventData message, 
            ILogger log)
        {
            log.LogInformation($"C# IoT Hub trigger function processed a message: {Encoding.UTF8.GetString(message.Body.Array)}");
        }
    }
}

Here the IoTHubTriggerConnection is the connection string we are providing in the local.settings.json file. The consumer group will come into the play if you have many applications which need to be receiving the data from your IoT Hub. Below is the class definition of EventHubTriggerAttribute.

public sealed class EventHubTriggerAttribute : Attribute
    {
        public EventHubTriggerAttribute(string eventHubName);

        public string EventHubName { get; }
        public string ConsumerGroup { get; set; }
        public string Connection { get; set; }
    }

Send data to the Azure IoT Hub

As I mentioned earlier, there are two ways you can send the data to the Azure IoT Hub.

1. Using a device, for example, MXChip
2. Simulated device

Once the data is been sending, you can see the message received count in Azure IoT Hub in the overview section.

Run the Azure Function

So, the IoT Hub is started receiving the messages from the device, and now we can use our Azure Function to pull the data from the IoT hub with the help of IoT hub Trigger. Run your Function App, Simulated Device application and see the output.

As you can see in the output, our Azure Function app is receiving the data from Azure IoT hub instantly. Now you can perform any actions with this data. I will leave that to you.

Conclusion

Wow!. Now we have learned,

• Usage of Azure IoT Hub Trigger in Azure Function
• Creating Azure Function App
• See the Data from Azure IoT Hub in the Azure Function App

You can always ready my IoT articles here.

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

For the last few days, I am playing with my Azure IoT Dev Kit MXChip. In this article, we are going to see how we can set up an Azure Function as an Output job topology of an Azure Stream Analytics job. Isn’t that sound interesting? In our previous articles, we have already seen what is an Azure Stream Analytics Job and How can we create in by using the portal and Visual Studio. If you haven’t read those articles, I strongly recommend you to read. Let’s jump on to this article now.

Background

As I have mentioned earlier, in this article we will be, 

1. using our existing Azure Stream Analytics job.
2. creating a new Azure Function App.
3. setting up the newly created Azure function as an output job topology of the stream analytics job.
4. monitoring the data coming to the Azure Function from the stream analytics job.

Play with Azure Function

Yeah, we are going to play with it. Let’s go and create one then.

Creating an Azure Function

To create an Azure Function application, you need to login to your Azure portal and click on the Create a resource icon, and then you can search for the ” Function App”. 

In the next screen, provide the following information. 

1. App Name
2. Subscription
3. Resource Group
4. OS
5. Hosting plan
6. Location 
7. Runtime stack
8. Storage
9. Application Insights

Here the consumption plan hosting plan allows you to pay per execution, and the App service plan allows you to have a predefined capacity. For the runtime stack, we will use .NET, however, you are free to use anything you wish. 

Once you have created the same, you should be able to see it under the Function Apps section. 

Creating an Azure Function Solution and Function

Now let’s go to our Visual Studio and create a new solution for our Azure Function. 

Now you can right click on your newly created project and add a new HttpTrigger Function. We will keep the Access Rights to Anonymous for now. I have named my function as “GetData”. For now, let’s just get the data from our Stream Analytics job and just check the length. 

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

namespace ml.IoTPlatform.AzureFunctions
{
    public static class GetData
    {
        [FunctionName("GetData")]
        public static async Task<HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post")]HttpRequestMessage req,
            ILogger log)
        {
            log.LogInformation($"GetData function triggered with Uri {req.RequestUri}");

            string content = await req.Content.ReadAsStringAsync();
            log.LogInformation($"String content is {content}");
            dynamic data = JsonConvert.DeserializeObject(content);

            log.LogInformation($"Data count is {data?.Count}");

            if (data?.ToString()?.Length > 262144)
            {
                return new HttpResponseMessage(HttpStatusCode.RequestEntityTooLarge);
            }

            return req.CreateResponse(HttpStatusCode.OK, "Success");
        }
    }
}

As you can see we are not doing nothing much for now, we are just receiving the data as HttpRequestMessage and we are reading the content as req.Content.ReadAsStringAsync() and then deserialize the object. If you are not doing this step, you may get an error as “No MediaTypeFormatter is available to read an object of type ‘Object’ from content with media type ‘application/octet-stream’.“

We are also checking the entity length, and if it is too large we are sending a HttpResponseMessage with status code 413. 

Publish the Azure Function App

To publish your Azure Function app, just right click on your project and click Publish and then set up your publish target by choosing the existing Azure Function App, remember we have created on earlier? Once you publish the same, you can go into your Function App and see your Function. You can also test the same with some dummy data. 

There are probabilities to get an error as “Web Deploy cannot modify the file on the destination because it is locked by an external process” when you try to publish your Function App from Visual Studio, while your Function App is running, to fix this you can see my answer here. 

Azure Stream Analytics Job

Let’s go back to our Azure Stream Analytics now as we have already configured our Azure Function App successfully. 

Configure Azure Function Output

In my previous article, we had created an Azure Stream Analytics job solution using Visual Studio, let’s open that solution now and configure the new output for Azure Function. 

While configuring the Azure Function Output, please make sure that you are selecting the existing azure function app.

Update the Script

We should also do some changes in our Script.asaql file to support our newly created output. 

WITH BasicOutput AS 
(
SELECT    
    messageId,
    deviceId,
    temperature,
    humidity,
    pressure,
    pointInfo,
    IoTHub,
    MAX(EventEnqueuedUtcTime) AS EventEnqueuedUtcTime,
    EventProcessedUtcTime,
    PartitionId    
FROM
    Input TIMESTAMP By EventEnqueuedUtcTime
    GROUP BY TUMBLINGWINDOW(second, 10), 
    messageId, 
    deviceId,
    temperature,
    humidity,
    pressure,
    pointInfo,
    IoTHub,
    EventEnqueuedUtcTime,
    EventProcessedUtcTime,
    PartitionId
)

SELECT * INTO SQLServerOutput FROM BasicOutput
SELECT * INTO AzureFunctionOutput FROM BasicOutput

Updating the TLS Version

Once that is done, just click the button Submit to Azure, if you have any doubts in this section, read my previous posts on this topic. Now let’s log in to the portal again and see all the outputs, inputs, and the query is been published or not.

Cool!. Well done, it seems like it is published. Now if you click on the AzureFunctionOutput, you may get a warning as “Please make sure that the Minimum TLS version is set to 1.0 on your Azure Functions before you start your ASA job“. I would rather treat this as an error instead of a warning because without making this changes our Azure Stream Analytics job will not write to our Azure Function. So this is very important, I spent many hours in this and finally found this was the root cause of my issue, you can see my answer about this here.

So just go to your Azure Function App and click on Platform Features -> SSL -> Minimum TLS Version

There is a saying that developers don’t care about warning but only the errors, in some cases it is true. Hm, I was just kidding. 

Output

Once you are done everything mentioned, you are good to go and start your Stream Analytics job, please make sure that your MXChip is connected to a power source so that the device can start sending the data. 

Checking the SQL Server Output

Now let’s login to our SQL Server Database and run the below query to make sure that we are getting the data from the device.

SELECT TOP (1000) [Id]
      ,[messageId]
      ,[deviceId]
      ,[temperature]
      ,[humidity]
      ,[pressure]
      ,[pointInfo]
      ,[IoTHub]
      ,[EventEnqueuedUtcTime]
      ,[EventProcessedUtcTime]
      ,[PartitionId]
  FROM [dbo].[StreamData] order by [EventEnqueuedUtcTime] desc

Checking Azure Function Output 

To check the Azure Function Output, we can go back to our Azure Function and click on the Function and use the Monitor option.

Please be noted that you can always check your Azure Stream Analytics job Activity Log if you found something is not working. 

Conclusion

In this article, we have learned how to,

1. work with an Azure Stream Analytics job
2. create an Azure Function App
3. create Azure Function App solution in Visual Studio
4. write an HttpTrigger function and publish the same to the Azure Function App
5. set up the Azure Function App as an output job topology of Azure Stream Analytics job
6. Use the created package in another solution

In our next article, we will see how you can send this Azure Function Output data to an Azure SignalR service and then get the same data in an Angular Application. I can’t wait to write my next article. 

Your turn. What do you think?

Thanks a lot for reading. I will come back with another post on the same topic very soon. Did I miss anything that you may think which is needed? Could you find this post as useful? Kindly do not forget to share me your feedback.

You can always see my IoT articles here. 

Kindest Regards
Sibeesh Venu

Introduction

Creating an Azure Stream Analytics job and working with them is always a fun. And what if there is a tool which helps you create a stream solution in Visual Studio so that you don’t want to go over the browser and do some manual button clicks? That’s where the Azure Data Lake and Stream Analytics Tool extension come into the play. In my previous post, we have already discussed what is an Azure Stream Analytics job and how can we work with the same, if you haven’t read the same, please read it. Now let’s go and use the extension.

Background

Recently, I started working with Azure IoT Device Kit, which is a wonderful micro controller board, it can send a lot of information like temperature, humidity to the Azure cloud, as it has a lot of inbuilt sensors. Now in this article, we will create a Visual Studio solution for our Stream Analytics Job so that the same can be moved to a source control and can be easily managed. 

Please be noted that the Extension we are going to use is not yet supported with Visual Studio 2019, and if you try to create the same in VS2019, you will get an error as the version of Visual Studio is not supported

The extension is not supported in VS2019

Setting up the Environment

I am assuming that you have a valid Azure Subscription and you have access to create the resouces in it. 

Modify Visual Studio with Required Workloads

Let’s go to our Visual Studio installer and modify the workloads now.

Once the workloads are modified, make sure that the extension is available in your Extensions, you can do that by going to Tools -> Extension menu.

Creating a New Stream Analytics Project

Once the Extension is enabled, you should be able to create a new Azure Stream Analytics Application.

The new project will be containing the below files.

1. Input.json
2. Output.json
3. JobConfig.json
4. Script.asaql

To configure your subscription, please make sure that you have added your Subscription in the Server Explorer.

The Input.json file is the replica of your Input job topology, double click on the file will give you the configuration page to configure the details. 

The Output.json file is your output job topology, you can have as many outputs you need. In my case it is just one, SQL Server Database. 

You can always configure your job using the JobConfig.json file. When you configure the Job, you need to be sure about the values you are providing and what are the needs of them. 

Data Locale is your locale input. The option Output Error Handling is for handling the situation when the events fail to be written to the output, you can select either Drop or Retry. The Late Arrival Tolerance Window is the timeframe which you can wait for the event to reach the IoT hub, the time difference is between the event timestamp and the system time. 

And the Script.asaql is the file where you need to add your custom query which gets data from the input and send it to the output. 

SELECT
    messageId,
    deviceId,
    temperature,
    humidity,
    pressure,
    pointInfo,
    IoTHub,
    EventEnqueuedUtcTime,
    EventProcessedUtcTime,
    PartitionId
INTO
    streamoutputs
FROM
    streaminputs

Once everything is done, you are ready to submit the same to the Azure. You can either create a new job or use the existing one. 

When you submit, you can see that a new Stream Analytics view will get opened and the job will be starting automatically. You can always see the blobs created under your container by going to the cloud explorer. 

Now just right click on your solution and select “Add solution to Source Control and then push the same to your git repository. Once you have added the solution to the source control, your team members can easily update the Input and Output configuration and have a history of the same. 

Conclusion

In this article, we have learned how to,

1. set up the Visual Studio for using Data Lake and Stream Analytics tool
2. use the Data Lake and Stream Analytics tool
3. configure the Input for Stream Analytics
4. configure the Stream Analytics Job
5. Use the created package in another solution

Your turn. What do you think?

Thanks a lot for reading. I will come back with another post on the same topic very soon. Did I miss anything that you may think which is needed? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

The capability of an Azure Stream Analytics Job is a lot, here in this post we are going to discuss a few of them. An Azure Stream Analytics is basically an engine which processes the events. These events are coming from the devices we have configured, it can be an Azure IoT Dev Kit (MXChip) or a Raspberry Pi and many more. The stream analytics job has two vital parts

• Input source
• Output source

The input source is the source of your streaming data, in my case, it is my IoT Hub. And the output source is the output what you are configuring. I had configured the output to save the data to an Azure SQL database. Let’s just stop the introduction part now and start creating our own Stream Analytics. 

Background

I recently got my MXChip (Azure Iot Dev Kit) and I was surprised with the capabilities that device can do. It has a lot of sensors within the device, like temperature, humidity, pressure, magnetometer, security etc. Then I thought it is time to play with the same. So the basic idea here was to,

1. Configure the device to send the data to the IoT Hub
2. Select the IoT Hub as a stream input
3. Send the output to an SQL Server database

In this article, we are going to concentrate on how to create a Stream Analytics Job and how you can configure the same to save the stream data to the SQL Server database. 

Prerequisites

To do the wonderful things, we always need some prerequisites.  

1. Azure Subscription
2. MXChip Azure IoT Dev Kit 
3. An active IoT Hubows Driver Kit (WDK) 10
4. IoT Core ADK Add-Ons
5. Windows 10 IoT Core Packages
6. The Raspberry Pi BSP
7. Custom FFU image we have created

Creating the Azure Stream Analytics Job

Login to your Azure Portal and click on the Create a resource, and then search for the “Stream Analytics job”. 

Once you clicked on the Create button, it is time to specify the details of your job.

1. Job Name
2. Subscription
3. Resource Group
4. Location
5. Hosting Environment

I would strongly recommend you to select the same resource group of your IoT Hub for the Stream Analytics Job as well so that you can easily delete the resources when there are not needed. Once the deployment is successful you can go to the resource overview and see the details.

Configure Inputs

In the left menu, you can see a section called Job topology, that’s where we are going to work. Basically, we will be setting the Inputs and Outputs and then we will be writing a query which can take the inputs and send the values to the configured output. Click on the Inputs label and click on Add stream input and then select the IoT Hub.

In the next screen, you will have options to select the existing IoT hub and to create a new IoT Hub. As I have already created an IoT hub, I would select the existing one.

Please be noted that you are allowed to use special characters in the Input alias field, but if you use such, please make sure to include the same inside [] in the query, which we will be creating later. 

About the special characters in Input alias field

Once you are successfully configured the Inputs, then we can go ahead and configure the outputs.

Configure Outputs

Click on the Outputs from the Job topology section and click Add, and then select SQL Database.

You can either create a new Database or select the one you had already created. I used the existing database and table. 

Configure the Query

Once you click the label Query on the left pan, you will be given an editor where you can write your queries. I am using the below query. 

SELECT
    messageId,
    deviceId,
    temperature,
    humidity,
    pressure,
    pointInfo,
    IoTHub,
    EventEnqueuedUtcTime,
    EventProcessedUtcTime,
    PartitionId
INTO
    streamoutputs
FROM
    streaminputs

As you can see that I am just selecting the fields I may need and saving the same to our stream outputs. You can always select all the fields by using the select * query, but the problem with that is, you will have to set up the table columns in the same order of the stream data. Otherwise, you may get an error as below.

Encountered error trying to write 1 event(s): Failed to locate column ‘IoTHub’ at position 6 in the output event

Stream analytics query error

If there are any errors, you can see that in the Output details.

Run the Stream Analytics Job and See the Data in the Database

As we have already done the initial set up, we can now start our Stream Analytics Job, please make sure that the IoT Hub is running and the device is sending data to the IoT Hub. If everything is working as expected, you will be able to see the data in the SQL server database. You can either connect your MXChip device to the network and test this or use the custom simulator app. 

If you are using the Simulator console application, make sure that you are giving the device id, key and the IoT hub uri correctly, otherwise you will get an unauthorized error as explained here. 

Test the Stream Analytics Job Inside the Portal

You also have an option to test the functionality in the portal itself. The only thing you will have to do is to prepare the sample input data. I have prepared the sample JSON data as follows. 

[
  {
    "deviceId": "test-device",
    "humidity": 77.699449415178719,
    "pointInfo": "This is a normal message.",
    "temperature": 32.506656929620846
  },
  {
    "deviceId": "test-device",
    "temperature": 52.506656929620846,
    "humidity": 17.699449415178719,
    "pointInfo": "This is a normal message."
  },
  {
    "deviceId": "test-device",
    "temperature": 42.506656929620846,
    "humidity": 57.699449415178719,
    "pointInfo": "This is a normal message."
  }
]

Now we can go to the Query section and upload the sample data file for our inputs. 

In the next window, you can select the JSON option and upload your JSON file. 

Click the Test button, and now you should be able to see the output as below.

Conclusion

Wow!. Now we have learned,

• What is Azure Stream Analytics Job
• how to create Azure Stream Analytics Job
• how to add Inputs to the Azure Stream Analytics
• how to add Outputs to the Azure Stream Analytics
• how to add custom Query in Azure Stream Analytics
• how to Test the Stream Analytics Query with sample data

You can always ready my IoT articles here.

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

In my previous article, we have seen how to create a basic FFU image which can be flashed to SD cards. Today, we will see how we can package our application and add this to our existing IoT Core OS image. Doesn’t it sound good? If you haven’t read my previous articles on the same topic, I strongly recommend you to read so that we can make sure that we both are in the same boat. For now, let’s just start doing some amazing things. Let’s just start then.

Background

Wow, that’s cool that you have your own FFU image in your SD card now, to make it more custom you may need to add your own application to it so that the same can be run in as many Raspberry Pi device as can, well that’s called Provisioning right? In this article,

1. we will see how we can create an APPX package of a UWP application
2. how the APPX package can be added to our FFU image

Let’s start doing the PowerShell commands now then.

Prerequisites

To do the wonderful things, we always need some prerequisites.  You can always see all the prerequisites from here. But, in this part, we are going to be needed only the preceding tools.

1. Windows Assessment and Deployment Kit (Windows ADK)
2. Windows Driver Kit (WDK) 10
3. IoT Core ADK Add-Ons
4. Windows 10 IoT Core Packages
5. The Raspberry Pi BSP
6. Custom FFU image we have created

Creating the UWP APPX

For now, I am going to use the Microsoft HelloWorld application, which is already available in the GitHub. Let’s just clone that application and build the same. If you are getting an error as “Error Cannot resolve Assembly or Windows Metadata file ‘Windows.Foundation.UniversalApiContract.winmd'”, please make sure that you had set the target version in the application section, you can always see my detailed answer here in StackOverflow.

Now let’s just right click on the project and click on Store – > Create App Packages.

Create APPX Menu

Now select the option “I want to create packages for sideloading” and click next. In the next screen, you can always automatically increment your application version. In the Generate app bundle option, select Never. And click Create. Now the app will get built and the APPX file will be generated for you.

Create APP Package

Adding APPX to the Existing FFU

As we have our own package and FFU image ready, we can go ahead and add this package to our FFU now. To do that open the IoTCorePShell, if you are not sure about how to open this, please check my previous article. Now let’s create a package for our app.

newappxpkg "C:\Users\SibeeshVenu\source\repos\Windows-iotcore-samples.git\Samples\HelloWorld\CS\AppPackages\HelloWorld_1.0.0.0_ARM_Test\HelloWorld_1.0.0.0_ARM.appx" fga Appx.HelloWorld

Please be noted that the “fga” is an indication that your application is a foreground application, if your application is a background application, you should use “bgt” instead of “fga”.

Please make sure that your FFU image has at least one Foreground application in it. You will always see the blue spinning dots after connecting the monitor to the Raspberry Pi if you have only background application in your image.  So you should consider having a registered fgt as well in your image.

You will not be able to understand what exactly happens if there any problems if you have only a background application in your image. Trust me, I had spent many hours looking at the blue screen hoping that my application will show up there.

The above command will create a new folder in your workspace, in our case it is at C:\OEE\Source-arm\Packages\Appx.HelloWorld. It will also copy the appx files and its dependencies from the folder we are specifying in the command and generates a customizations.xml file as well as a package xml file that is used to build the package.

newappxpkg output

This will also create a new entry as follows in the OEMFM.xml file.

<PackageFile Path="%PKGBLD_DIR%" Name="%OEM_NAME%.Appx.HelloWorld.cab">
        <FeatureIDs>
          <FeatureID>APPX_HELLOWORLD</FeatureID>
        </FeatureIDs>
      </PackageFile>

Now let’s just build our package.

PS C:\OEE>buildpkg Appx.HelloWorld
Processing Appx.HelloWorld.wm.xml
True
IoTCorePShell arm 10.0.0.0 Test

Now you should be able to see your package.cab file in the build directory C:\OEE\Build\arm\pkgs.  Let’s add the feature APPX_HELLOWORLD to our product OEEIoTCore now.

PS C:\OEE>addfid OEEIoTCore Test APPX_HELLOWORLD -OEM
IoTCorePShell arm 10.0.0.0 Test

You can also remove any feature from any product by using “removefid” command. As we have added our feature, now it is time to build our image.

PS C:\OEE>buildimage OEEIoTCore Test

Please be noted that this may take some time, and once it is done, you will be getting an output as below.

buildimage

The new image will be available in your build folder (C:\OEE\Build\arm\OEEIoTCore\Test). Now you can write this FFU image with your application as mentioned in my previous article.

Now that our OS is flashed and it is time to connect the SD card to the Raspberry Pi. Once that is done, you can see that your application is running in your device portal.

Custom Package in Device Portal

Now let’s add a background application and follow the same procedure.

PS C:\OEE>newappxpkg "C:\Users\SibeeshVenu\SourceCode\OEE\ml.OEE.Pi.Windows\ml.OEE.Pi.Windows.BeaconDetector\AppPackages\ml.OEE.Pi.Windows.BeaconDetector_1.0.3.0_ARM_Test\ml.OEE.Pi.Windows.BeaconDetector_1.0.3.0_ARM.appx" bgt Appx.Beacon

I am sure you will be able to see your background application in your device portal, once you had followed the steps correctly.

Background Application in IoT Device Portal

Conclusion

Wow!. Now we have learned,

• how we can generate APPX package of our UWP application
• how to add the new feature to the existing IoT Core FFU image
• how to write the same to an SD card
• how to manage the new application in Device Portal

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu

Introduction

In my previous article, we have seen how to Set Up Your Raspberry PI with Microsoft Windows 10 IoT Core. Yes, we were successful in flashing the Microsoft Windows 10 IoT Core OS to our Raspberry PI, but let’s try something very handy this time. The main topic we are going to discuss here in this article is SD Card Provisioning. I understand that you have one Raspberry PI with a working OS in it, whether it is a Microsoft IoT  OS or Raspbian. And you might also have an application which runs in your Raspberry Pi. That’s good. But what if you have 100 Raspberry PI and you need to set up your Raspberry PIs for a production environment? Did you get the difficulties in your mind? In this article, we are going to start a series of articles on SD Card Provisioning. For now, let’s just start doing some amazing things. Let’s just start then.

Background

Yeah, I am glad that you have a Raspberry PI with Windows 10 IoT core OS. While setting up your OS, you might have downloaded the IoT Dashboard and flashed the IoT OS to your SD card manually. As I mentioned in the Introduction, this is not a normal scenario when you want to connect multiple (let’s say 100) Raspberry PIs. Flashing the OS by using the Dashboard application might not be a good idea in this case. What should we do then? That’s where PowerShell come into the play. Yes, we are going to try out some PowerShell commands to do all those mentioned jobs for us.

Prerequisites

To do the wonderful things, we always need some prerequisites.  You can always see all the prerequisites from here. But, in this part, we are going to be needed only the preceding tools.

1. Windows Assessment and Deployment Kit (Windows ADK)
2. Windows Driver Kit (WDK) 10
3. IoT Core ADK Add-Ons
4. Windows 10 IoT Core Packages
5. The Raspberry Pi BSP

Creating the Base Windows IoT FFU Image

I assume that you had already gone through the Prerequisites and followed the instructions. If not, please check again.

Create a Workspace

To get started here, please go to the cloned location of the repository iot-adk-addonkit, where you will find a Windows Command Script IoTCorePShell.cmd. Double click on the same file will open a PowerShell with administrative privilege. Now, this is where the game starts. Once it opens it will do some initial process for us.

Running IoTCorePShell.cmd

Now let’s create a workspace now.

New-IoTWorkspace C:\Workspacefolder oemname arm
(or) new-ws C:\workspacefolder oemname arm

new-ws command

Now we have created a workspace successfully. Please be noted that the BSPPKG_DIR is “C:\Program Files (x86)\Windows Kits\10\MSPackages\retail\arm\fre”. I strongly recommend you to check that folder whether you have contents in it or not if there is no content you might haven’t installed the packages mentioned in the prerequisites.

Build BSP

Now it is time to think about the BSP aka Board Support Package. As we already know that we are using Raspberry PI, we can directly download the RPi_BSP.zip file from the GitHub release page. Then you can perform the below commands.

Import-IoTBSP RPi2 C:\Downloads\RPi_BSP.zip
(or) importbsp RPi2 C:\Downloads\RPi_BSP.zip
buildpkg RPi2

If everything is right, you should see an output as below.

Import Raspberry BSP

Build Packages

Once you have created the workspace and extracted the BSP, it is time to build all of our packages.

New-IoTCabPackage All
(or) buildpkg all

If you miss this step before you go to the next step, you will get an error as follows when you build your image.

info: Trying to load file 'C:\OEEWorkspace\Build\arm\InputFMs\OEMFMFileList.xml' as a FM file list ... fatal error : Error: Missing package: C:\OEEWorkspace\Build\arm\pkgs\test.OEM.Sample.cab
info: Trying to load file 'C:\OEEWorkspace\Build\arm\InputFMs\RPi2FMFileList.xml' as a FM file list ... fatal error : Error: Missing package: 

You will also end up in the similar GitHub issue. Trust me, finding the root cause of this issue took me some hours and at the end, I answered my findings here in StackOverflow.

Building all the packages

Once the build is successful, you should be able to see the cab files in your workspace location, in my case, it is C:\OEE\Build\arm\pkgs.

Create a Product

Now let’s create a new Product, consider this as the device for which we are building an image for. We will be using the BSP we have extracted for this step.

Add-IoTProduct ProductA RPi2
(or) newproduct MyProductA RPi2

You will be asked the Manufacturer Name (OEM Name), Family, SKU, BaseboardManufacturer, and BaseboardProduct. You can get the BaseProductName from your Workspace location, in my case C:\OEE\Source-arm\BSP. You can see the sample command here in the preceding image.

Creating a new Product

The command shown in the image will generate a new Product in the Workspace location C:\OEE\Source-arm\Products\OEEIoTCore.

Add-IoTProduct Output

Build the Image

We are almost done, let’s eject all the removable devices from the system and then run the below command.

New-IoTFFUImage <product name> Test
(or)buildimage <product name> Test

This command will give you the FFU image with your base image.

Building Image and Generate FFU File

You can also see the logs in your workspace location in the build folder. The generated FFU image(Flash.ffu) will be available at C:\OEE\Build\arm\OEEIoTCore\Test folder.

Writing/Flashing the FFU Image to SD Card

Wow!, now we have a fully functional FFU image and the only thing pending is to write some bat commands to flash it to SD card, you can use the DISM. Let’s create a text file called format.txt and write some commands as preceding.

select disk 1
clean
create partition primary
select partition 1
active
format fs=fat32 quick
assign
exit

As you can see that we are selecting the disk 1, considering the fact that only one removable disk is been connected to your machine.  Then we format the disk. This format.txt file will be used in our bat file write.bat.

echo off
REM Start formatting
diskpart /s format.txt >log.txt

REM Start flashing
dism.exe /Apply-Image /ImageFile:Flash.ffu /ApplyDrive:\\.\PhysicalDrive1 /SkipPlatformCheck /Quiet

ECHO Finish

The logs will be added to the file called log.txt. The command ImageFile:Flash.ffu is the place where we assign our FFU image. Now let’s just go to the folder where these three files are been placed and open a command prompt in administrative power.

• write.bat
• format.txt
• flash.ffu

Flash IoT Core by Commands

Connect SD Card to Raspberry PI and then Raspberry PI to the Network

Now that our OS is flashed and it is time to connect the SD card to the Raspberry PI and connect a monitor, mouse, keyboard, ethernet to the Raspberry PI. You will see the default IoT core application running. You can also check in the device portal using the IoT Dashboard application, if you are not sure how, please read my previous post.

Conclusion

Wow!. Now we have learned,

• how we can generate the IoT core FFU image using PowerShell
• how to write the same to an SD card.

Is that all? No, in the next article we will learn

• how we can add our app package to this FFU image which can be used in many Raspberry PI
• how to generate the FFU image on demand with some chained PowerShell commands.
• how to use other mechanisms to write the FFU image to the disk

Your turn. What do you think?

Thanks a lot for reading. Did I miss anything that you may think which is needed in this article? Could you find this post as useful? Kindly do not forget to share me your feedback.

Kindest Regards
Sibeesh Venu