title	description	services	documentationcenter	author	manager	editor	ms.assetid	ms.service	ms.devlang	ms.topic	ms.tgt_pltfrm	ms.workload	ms.date	ms.author
Device firmware update with Azure IoT Hub (.NET/Node) \| Microsoft Docs	How to use device management on Azure IoT Hub to initiate a device firmware update. You use the Azure IoT device SDK for Node.js to implement a simulated device app and the Azure IoT service SDK for .NET to implement a service app that triggers the firmware update.	iot-hub	.net	juanjperez	timlt		70b84258-bc9f-43b1-b7cf-de1bb715f2cf	iot-hub	multiple	article	na	na	11/17/2016	juanpere

Use device management to initiate a device firmware update (.NET/Node)

[!INCLUDE iot-hub-selector-firmware-update]

Introduction

In the Get started with device management tutorial, you saw how to use the device twin and direct methods primitives to remotely reboot a device. This tutorial uses the same IoT Hub primitives and shows you how to do an end-to-end simulated firmware update. This pattern is used in the firmware update implementation for the Raspberry Pi device implementation sample.

This tutorial shows you how to:

Create a .NET console app that calls the firmwareUpdate direct method in the simulated device app through your IoT hub.
Create a simulated device app that implements a firmwareUpdate direct method which goes through a multi-stage process that waits to download the firmware image, downloads the firmware image, and finally applies the firmware image. Throughout executing each stage the device uses the reported properties to update progress.

At the end of this tutorial, you have a Node.js console device app and a .NET (C#) console back-end app:

dmpatterns_fwupdate_service.js, which calls a direct method in the simulated device app, displays the response, and periodically (every 500ms) displays the updated reported properties.

TriggerFWUpdate, which connects to your IoT hub with the device identity created earlier, receives a firmwareUpdate direct method, runs through a multi-state process to simulate a firmware update including: waiting for the image download, downloading the new image, and finally applying the image.

To complete this tutorial, you need the following:

Microsoft Visual Studio 2015.
Node.js version 0.12.x or later,
Prepare your development environment describes how to install Node.js for this tutorial on either Windows or Linux.
An active Azure account. (If you don't have an account, you can create a free account in just a couple of minutes.)

Follow the Get started with device management article to create your IoT hub and get your IoT Hub connection string.

[!INCLUDE iot-hub-get-started-create-hub]

[!INCLUDE iot-hub-get-started-create-device-identity]

Trigger a remote firmware update on the device using a direct method

In this section, you create a .NET console app (using C#) that initiates a remote firmware update on a device using a direct method and uses device twin queries to periodically get the status of the active firmware update on that device.

In Visual Studio, add a Visual C# Windows Classic Desktop project to the current solution by using the Console Application project template. Name the project TriggerFWUpdate.
In Solution Explorer, right-click the TriggerFWUpdate project, and then click Manage NuGet Packages.
In the NuGet Package Manager window, select Browse, search for microsoft.azure.devices, select Install to install the Microsoft.Azure.Devices package, and accept the terms of use. This procedure downloads, installs, and adds a reference to the Azure IoT service SDK NuGet package and its dependencies.
Add the following using statements at the top of the Program.cs file:
```
 using Microsoft.Azure.Devices;
```

Add the following fields to the Program class. Replace the multiple placeholder value with the IoT Hub connection string for the hub that you created in the previous section.

 static RegistryManager registryManager;
 static string connString = "{iot hub connection string}";
 static ServiceClient client;
 static JobClient jobClient;
 static string targetDevice = "{deviceIdForTargetDevice}";

Add the following method to the Program class:

 public static async Task QueryTwinFWUpdateReported()
 {
     Twin twin = await registryManager.GetTwinAsync(targetDevice);
     Console.WriteLine(twin.Properties.Reported.ToJson());
 }

Add the following method to the Program class:

 public static async Task StartFirmwareUpdate()
 {
     client = ServiceClient.CreateFromConnectionString(connString);
     CloudToDeviceMethod method = new CloudToDeviceMethod("firmwareUpdate");
     method.ResponseTimeout = TimeSpan.FromSeconds(30);
     method.SetPayloadJson(
         @"{
             fwPackageUri : 'https://someurl'
         }");

     CloudToDeviceMethodResult result = await client.InvokeDeviceMethodAsync(targetDevice, method);

     Console.WriteLine("Invoked firmware update on device.");
 }

Finally, add the following lines to the Main method:

 registryManager = RegistryManager.CreateFromConnectionString(connString);
 StartFirmwareUpdate().Wait();
 QueryTwinFWUpdateReported().Wait();
 Console.WriteLine("Press ENTER to exit.");
 Console.ReadLine();

Build the solution.

Create a simulated device app

In this section, you will

Create a Node.js console app that responds to a direct method called by the cloud
Trigger a simulated firmware update
Use the reported properties to enable device twin queries to identify devices and when they last completed a firmware update

Create a new empty folder called manageddevice. In the manageddevice folder, create a package.json file using the following command at your command prompt. Accept all the defaults:
```
npm init
```
At your command prompt in the manageddevice folder, run the following command to install the azure-iot-device Device SDK package and azure-iot-device-mqtt package:
```
npm install azure-iot-device azure-iot-device-mqtt --save
```
Using a text editor, create a new dmpatterns_fwupdate_device.js file in the manageddevice folder.

Add the following 'require' statements at the start of the dmpatterns_fwupdate_device.js file:

'use strict';

var Client = require('azure-iot-device').Client;
var Protocol = require('azure-iot-device-mqtt').Mqtt;

Add a connectionString variable and use it to create a Client instance.

var connectionString = 'HostName={youriothostname};DeviceId=myDeviceId;SharedAccessKey={yourdevicekey}';
var client = Client.fromConnectionString(connectionString, Protocol);

Add the following function which is used to update reported properties

var reportFWUpdateThroughTwin = function(twin, firmwareUpdateValue) {
  var patch = {
      iothubDM : {
        firmwareUpdate : firmwareUpdateValue
      }
  };

  twin.properties.reported.update(patch, function(err) {
    if (err) throw err;
    console.log('twin state reported')
  });
};

Add the following functions which simulates the download and apply of the firmware image.

var simulateDownloadImage = function(imageUrl, callback) {
  var error = null;
  var image = "[fake image data]";

  console.log("Downloading image from " + imageUrl);

  callback(error, image);
}

var simulateApplyImage = function(imageData, callback) {
  var error = null;

  if (!imageData) {
    error = {message: 'Apply image failed because of missing image data.'};
  }

  callback(error);
}

Add the following function which updates the firmware update status through the reported properties to waiting to download. Typically, devices are informed of an avaiable update and an administrator defined policy causes the device to start downloading and applying the update. This is where the logic to enable that policy would run. For simplicity, we're delaying for 4 seconds and proceeding to download the firmware image.
```
var waitToDownload = function(twin, fwPackageUriVal, callback) {
  var now = new Date();

  reportFWUpdateThroughTwin(twin, {
    fwPackageUri: fwPackageUriVal,
    status: 'waiting',
    error : null,
    startedWaitingTime : now.toISOString()
  });
  setTimeout(callback, 4000);
};
```

Add the following function which updates the firmware update status through the reported properties to downloading the firmware image. It follows up by simulating a firmware download and finally updates the firmware update status to inform of either a download success or failure.

var downloadImage = function(twin, fwPackageUriVal, callback) {
  var now = new Date();   

  reportFWUpdateThroughTwin(twin, {
    status: 'downloading',
  });

  setTimeout(function() {
    // Simulate download
    simulateDownloadImage(fwPackageUriVal, function(err, image) {

      if (err)
      {
        reportFWUpdateThroughTwin(twin, {
          status: 'downloadfailed',
          error: {
            code: error_code,
            message: error_message,
          }
        });
      }
      else {        
        reportFWUpdateThroughTwin(twin, {
          status: 'downloadComplete',
          downloadCompleteTime: now.toISOString(),
        });

        setTimeout(function() { callback(image); }, 4000);   
      }
    });

  }, 4000);
}

Add the following function which updates the firmware update status through the reported properties to applying the firmware image. It follows up by simulating a applying of the firmware image and finally updates the firmware update status to inform of either a apply success or failure.

var applyImage = function(twin, imageData, callback) {
  var now = new Date();   

  reportFWUpdateThroughTwin(twin, {
    status: 'applying',
    startedApplyingImage : now.toISOString()
  });

  setTimeout(function() {

    // Simulate apply firmware image
    simulateApplyImage(imageData, function(err) {
      if (err) {
        reportFWUpdateThroughTwin(twin, {
          status: 'applyFailed',
          error: {
            code: err.error_code,
            message: err.error_message,
          }
        });
      } else { 
        reportFWUpdateThroughTwin(twin, {
          status: 'applyComplete',
          lastFirmwareUpdate: now.toISOString()
        });    

      }
    });

    setTimeout(callback, 4000);

  }, 4000);
}

Add the following functoin which handle the firmwareUpdate method and initiate the multi-stage firmware update process.

var onFirmwareUpdate = function(request, response) {

  // Respond the cloud app for the direct method
  response.send(200, 'FirmwareUpdate started', function(err) {
    if (!err) {
      console.error('An error occured when sending a method response:\n' + err.toString());
    } else {
      console.log('Response to method \'' + request.methodName + '\' sent successfully.');
    }
  });

  // Get the parameter from the body of the method request
  var fwPackageUri = JSON.parse(request.payload).fwPackageUri;

  // Obtain the device twin
  client.getTwin(function(err, twin) {
    if (err) {
      console.error('Could not get device twin.');
    } else {
      console.log('Device twin acquired.');

      // Start the multi-stage firmware update
      waitToDownload(twin, fwPackageUri, function() {
        downloadImage(twin, fwPackageUri, function(imageData) {
          applyImage(twin, imageData, function() {});    
        });  
      });

    }
  });
}

Finally, add the following code which connects to your IoT hub as a device,

client.open(function(err) {
  if (err) {
    console.error('Could not connect to IotHub client');
  }  else {
    console.log('Client connected to IoT Hub.  Waiting for firmwareUpdate direct method.');
  }

  client.onDeviceMethod('firmwareUpdate', onFirmwareUpdate(request, response));
});

Note

To keep things simple, this tutorial does not implement any retry policy. In production code, you should implement retry policies (such as an exponential backoff), as suggested in the MSDN article Transient Fault Handling.

Run the apps

You are now ready to run the apps.

At the command prompt in the manageddevice folder, run the following command to begin listening for the reboot direct method.
```
node dmpatterns_fwupdate_device.js
```
Run the C# console app TriggerFWUpdate- right click on the TriggerFWUpdate project, select Debug and Start new instance.
You see the device response to the direct method in the console.

Next steps

In this tutorial, you used a direct method to trigger a remote firmware update on a device and periodically used the reported properties to understand the progress of the firmware update process.

To learn how to extend your IoT solution and schedule method calls on multiple devices, see the Schedule and broadcast jobs tutorial.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

iot-hub-csharp-node-firmware-update.md

iot-hub-csharp-node-firmware-update.md

Use device management to initiate a device firmware update (.NET/Node)

Introduction

Trigger a remote firmware update on the device using a direct method

Create a simulated device app

Run the apps

Next steps

Files

iot-hub-csharp-node-firmware-update.md

Latest commit

History

iot-hub-csharp-node-firmware-update.md

File metadata and controls

Use device management to initiate a device firmware update (.NET/Node)

Introduction

Trigger a remote firmware update on the device using a direct method

Create a simulated device app

Run the apps

Next steps