Artigo
01/11/2019

Dezembro de 2018

Volume 33 – Número 12

Internet das Coisas - Desenvolvimento de IoT Rápido com o Azure IoT Central

Como um desenvolvedor de IoT, você enfrenta muitos desafios. Felizmente, as tecnologias de IoT da Microsoft não deixam você na mão. Você pode usar o Windows 10 IoT Core para desenvolver aplicativos de Plataforma Universal do Windows (UWP) para dispositivos inteligentes (bit.ly/2yJf6RJ). Você pode criar algoritmos de aprendizado de máquina (ML) graficamente com o Azure Machine Learning Studio (bit.ly/2yF2yes). Além disso, você pode escolher entre várias abordagens para criar aplicativos Web usando vários serviços de IoT do Azure ou aplicativos autodesenvolvidos do ASP.NET MVC (.NET Framework ou .NET Core).

Embora essas tecnologias ofereçam uma maneira abrangente para desenvolver soluções personalizadas de IoT, combiná-las pode ser difícil, especialmente se você não tiver nenhuma experiência anterior com programação Web ou em nuvem. Para resolver esse problema, a Microsoft criou o Azure IoT Suite (consulte meu artigo anterior em bit.ly/2yFaIU6), que foi posteriormente renomeado como aceleradores de solução de IoT do Azure (bit.ly/2pYaraX). Os aceleradores de solução fornecem uma série de aplicativos pré-configurados voltados para problemas comuns de IoT, incluindo painéis, modelos de ML, transmissão de lógica de dados e componentes programáticos que unem todas essas coisas. No entanto, os aceleradores de solução ainda são complexos. Então, para simplificar ainda mais o desenvolvimento de IoT, a Microsoft introduziu o Azure IoT Central, um serviço gerenciado baseado na nuvem que você pode usar para criar rapidamente um back-end de IoT. Este é o portal moderno, que contém os painéis e os serviços subjacentes para telemetria, processamento de dados e muito mais. Você usa esse back-end para conectar, monitorar e gerenciar seus dispositivos de IoT.

Neste artigo, mostrarei como usar o Azure IoT Central para criar a solução mostrada na Figura 1. Essa solução utiliza um aplicativo do IoT Central personalizado que representa dados de telemetria, o local do dispositivo e suas configurações, e dois indicadores chave de desempenho. Um operador pode usar esse painel para visualizar a telemetria e controlar remotamente o dispositivo por meio das configurações. Os dados de telemetria são transmitidos do aplicativo do console do .NET Core (mostrado no canto superior direito). O código-fonte completo desse aplicativo está disponível em bit.ly/2D34XnV.

Figura 1 A solução de IoT que eu criarei

Soluções e serviços de IoT do Azure

Antes de explicar como eu criei a solução de IoT, vou analisar brevemente outras abordagens possíveis para o desenvolvimento de aplicativos de IoT com o Azure IoT. Primeiro, você pode criar uma solução totalmente personalizada instanciando e configurando manualmente os serviços de IoT do Azure dedicados, conforme mostrado na Figura 2. Nesse caso, você geralmente começa com o Hub IoT, que atua como o gateway de nuvem e é usado para a comunicação bidirecional e gerenciamento de dispositivo (por exemplo, o registro de dispositivo). Os dados transmitidos de dispositivos remotos por meio do Hub IoT podem ser processados ou transformados com o Azure Stream Analytics. Você usa esse serviço para filtrar os dados que não são de telemetria ou para calcular a média de quantidades pequenas dos dados de telemetria para reduzir flutuações rápidas em suas medições. Os dados pré-processados podem então ser enviados para o painel do Power BI para visualização, mantidos no armazenamento de nuvem dedicado ou transmitidos para o Hub de Eventos para uma análise mais complexa. O Hub de Eventos pode enviar dados pré-processados para um modelo de ML para detectar anomalias ou prever tendências em seu processo monitorado. No entanto, essa abordagem pode ser demorada, principalmente porque você não tem um portal da Web pré-configurado para fornecer uma interface conveniente para seus usuários e operadores.

Figura 2 Uma solução de IoT típica: Retângulos denotam os serviços e as setas mostram o fluxo de dados entre os componentes da solução

Em segundo lugar, você pode começar com os aceleradores de solução de IoT, que são modelos que você pode ajustar às suas necessidades. Os aceleradores de solução de IoT se baseiam nos mesmos serviços de IoT do Azure de uma solução totalmente personalizada. No entanto, os aceleradores vêm com serviços pré-configurados e código de exemplo que mostram como tirar proveito desses serviços. Nesse caso, você ainda terá algum trabalho a fazer, mas você já começa com modelos ajustáveis.

Em terceiro lugar, você pode criar rapidamente um back-end com o Azure IoT Central, no qual você recebe um aplicativo de IoT totalmente preparado. A quantidade de trabalho e as habilidades necessárias são minimizadas. Não é necessário nenhum conhecimento sobre nuvem para criar uma solução de IoT totalmente funcional, escalonável e moderna. Tudo é criado automaticamente para você com base nos mesmos serviços de IoT do Azure de uma solução totalmente personalizada ou de quando são usados aceleradores de soluções. Portanto, você pode se concentrar no desenvolvimento de suas próprias coisas sem ter que tomar conta de outras partes da sua solução de IoT. A seguir usarei o Azure IoT Central permite criar rapidamente o ponto de extremidade da nuvem.

Criar um aplicativo do IoT Central

Para criar o aplicativo do IoT Central, usei o portal do IoT Central em apps.azureiotcentral.com, que exibia o Gerenciador de Aplicativos quando entrei na minha conta da Microsoft. Esse gerenciador mostra todos os seus aplicativos, embora não haja nenhum aplicativo inicialmente, é claro. Em seguida cliquei no botão Novo Aplicativo, abrindo o criador de aplicativo IoT, que permite que você escolha uma avaliação gratuita de sete dias ou uma assinatura paga (bit.ly/2QLvk4t), bem como o modelo de aplicativo, o nome do aplicativo e a URL. Escolhi o plano Gratuito e o modelo de Aplicativo Personalizado, em seguida, defini o nome do aplicativo para aplicativo do IoT Central MSDN, que criou automaticamente a URL a seguir: msdn-iot-central-app.azureiotcentral.com. Por fim, cliquei no botão Criar e, após alguns segundos, o aplicativo estava pronto.

O aplicativo do IoT Central consiste em dois elementos importantes: o modo de exibição real e a navegação (a barra do lado esquerdo). Você pode usar a barra lateral para alternar entre os vários modos de exibição: Página Inicial, Device Explorer, Conjuntos de Dispositivos, Análise, Trabalhos, Construtor de Aplicativos e Administração. Neste artigo, eu trabalharei principalmente com os modos de exibição Device Explorer e Construtor de Aplicativos.

O aplicativo recém-criado mostra o formulário padrão da home page. Você pode personalizar esse modo de exibição clicando no botão azul Editar para ativar o modo de exibição de edição, no qual você pode adicionar vários componentes, como links, rótulos, imagens, configurações do dispositivo, mapas e assim por diante. No entanto, antes de criar um painel, você precisa dos dados de telemetria. Inicialmente, a telemetria será produzida pelo dispositivo simulado. Para adicionar um dispositivo desse tipo, você pode começar clicando no painel Criar modelo do dispositivo na Home Page padrão. Por fim, talvez você prefira usar o Construtor de Aplicativos, que permite que você escolha a opção Dispositivo Personalizado. O modelo do dispositivo define seu dispositivo, incluindo dados de telemetria, configurações, eventos e comandos remotos (bit.ly/2CjsoYH).

Modelo de Dispositivo

Não importa como você escolha criar o modelo de dispositivo, primeiro especifique o nome do modelo (aqui, estou usando MSDN-DeviceTemplate), em seguida, clique no botão Criar e o dispositivo será provisionado. O modo de exibição mostrado na Figura 3 é exibido. Use este modo de exibição para configurar vários aspectos do seu dispositivo:

Medidas: Permite especificar o tipo de dado que seu dispositivo fornecerá para a nuvem. Você também pode definir eventos e estados de dispositivo.
Configurações: Permite criar configurações específicas de dispositivo que podem ser usadas para parametrizar cada dispositivo.
Propriedades: Permite configurar propriedades do dispositivo, por exemplo, em sua localização física.
Comandos: Permite definir comandos, que podem ser enviados da nuvem para o dispositivo para atualizar seu estado.
Regras: Permite definir regras para seu dispositivo. Essas regras podem monitorar seus dados e disparar ações correspondentes.
Painel: Permite criar um painel do dispositivo. Você pode usar um painel para criar um resumo para seu dispositivo, que pode incluir gráficos de telemetria, imagens, indicadores chave de desempenho, um mapa que indica a localização do dispositivo, o estado e o histórico de eventos.

Figura 3 Um Modelo de Dispositivo

Telemetria, Configurações e Propriedades

Em seguida, defini o modelo do dispositivo. Eu criei duas medidas: temperatura e umidade, em seguida, defini uma configuração — IsTelemetryActive — que permite ao operador habilitar ou desabilitar remotamente a telemetria (no estado Ocioso na Figura 1). Se a configuração IsTelemetryActive for false, o dispositivo remoto não transmitirá nenhum dado. Por fim, o dispositivo terá uma propriedade, Localização, que contém o endereço geoespacial do dispositivo.

Para criar medidas de telemetria, primeiro clique no botão Editar Modelo. Conforme mostrado na Figura 4, o botão Nova Medida será exibido logo acima de Telemetria. Depois de clicar neste botão você recebe uma opção para escolher entre Telemetria, Estado ou Evento. Vou clicar em Telemetria, que ativa outro modo de exibição, o qual é usado para configurar a medição da temperatura da seguinte maneira (consulte a coluna do meio na Figura 4):

Nome de Exibição: Temperatura
Nome do Campo: Temperatura
Unidades: °C
Valor Mínimo: -20
Locais de valor Máximo: 2
Cor: escolha aquela que desejar

Figura 4 Configurar Telemetria

A maioria das configurações de telemetria é auto-explicativa, mas lembre-se de que o Nome do Campo é o nome usado enquanto são transmitidos os dados entre o seu dispositivo e a nuvem. Então, você usa o Nome do campo para serializar e desserializar os objetos que representam os dados de telemetria corretamente.

Definir uma medida de Umidade é muito semelhante ao que se faz para definir a Temperatura, mas use a seguinte configuração:

Nome de Exibição: Umidade
Nome do Campo: Umidade
Unidades: %
Valor Mínimo: 0)
Valor Máximo: 100
Casas Decimais: 2

Depois de preparar as medidas, você pode adicionar a configuração do dispositivo. Para fazer isso, clique na guia Configurações e verifique se você está no modo de edição. Em seguida, você verá os tipos de configuração disponíveis à direita. Escolha o Tipo de alternância e configure-o da seguinte maneira:

Nome de Exibição: A telemetria está ativa
Nome do Campo: IsTelemetryActive
Texto de exibição ATIVADO: True
Texto de exibição DESATIVADO: False

Por fim, adicione a propriedade do dispositivo: Localização. Para fazer isso, abra a guia Propriedades. A lista de tipos de propriedade disponíveis será exibida à esquerda. Essa lista é conhecida como uma biblioteca. Clique no objeto Localização. Em seguida, configure a propriedade da seguinte maneira:

Nome de Exibição: Localização do Dispositivo
Nome do Campo: Localização
Valor Inicial: Microsoft, 1 Microsoft Way, Redmond, WA 98052

Observe que o campo Valor Inicial inclui uma lista de sugestão automática, que é preenchida quando você começa a digitar.

Depois de configurar a telemetria, definir as configurações e as propriedades, agora posso preparar o painel do dispositivo, que combina todas as informações em uma interface gráfica moderna.

Criar um painel

Criar o painel é semelhante à criação de Configurações e Propriedades — primeiro você habilita o modo de edição do modelo, que abrirá uma biblioteca contendo a lista de componentes de interface do usuário disponíveis. Os componentes estão localizados no lado esquerdo do painel do Azure IoT Central. Quando você seleciona um item, ele será exibido no painel. O lado esquerdo do editor do modelo exibirá as definições configuráveis para o componente da interface do usuário, conforme mostrado na Figura 5. Continue e clique no Gráfico de Linhas. Em seguida, defina o Título para Telemetria, habilite todas as três alternâncias, defina o intervalo de tempo para Últimos 30 minutos e clique no ícone mais à direita ao lado de Umidade e Temperatura para que essas medidas sejam plotadas.

Figura 5 Configurar o Gráfico

Em seguida, adicionei um Mapa ao painel, mostrando o local do dispositivo. Para criar esse mapa, escolha o componente Mapa da interface do usuário na biblioteca e configure suas propriedades. Defina o Título como Localização e, na lista de Propriedade da Localização, escolha Localização do dispositivo.

Em seguida, criei dois blocos mostrando indicadores chave de desempenho (KPIs). Esses KPIs são a temperatura média e a umidade máxima (veja a parte direita da Figura 1), calculados a partir de leituras do sensor obtidas nos últimos 30 minutos. Para criar tais blocos, você usa os componentes de KPI da biblioteca, configurando-os da seguinte maneira:

KPI de temperatura média:

Título: Temperatura média
Intervalo de tempo: Últimos 30 minutos
Tipo de medida: Telemetria
Medida: Temperatura

KPI de umidade máxima:

Título: Umidade máxima
Intervalo de tempo: Últimos 30 minutos
Tipo de medida: Telemetria
Medida: Umidade

Por fim, criei um bloco que mostra o valor real da configuração IsTelemetryActive. Para fazer isso, eu usei o componente Propriedades e Configurações da interface do usuário, que tem duas opções configuráveis: Título (uma caixa de texto) e Configurações e Propriedades (um controle de dois painéis que mostra as colunas disponíveis e selecionadas). Use a caixa de texto para definir o Título como Localização do Dispositivo e, em seguida, use o segundo controle para arrastar a Localização do Dispositivo das colunas disponíveis para as selecionadas. Depois que todos os componentes da interface do usuário estiverem prontos, posicione-os dentro do painel, conforme mostrado anteriormente na Figura 1.

Provisionar um dispositivo real

A discussão anterior confirma que, com o IoT Central, você pode criar rapidamente um painel de aparência moderna para sua solução de IoT. No entanto, até agora estávamos usando apenas o dispositivo simulado. Vamos ver agora como conectar o dispositivo real ao aplicativo do IoT Central. Você faz isso com o Device Explorer, prosseguindo conforme explicado na documentação do IoT Central (bit.ly/2Ch4gWA). Em resumo, você primeiro clica no botão Novo (localizado no painel superior), escolhe Real na lista suspensa e fornece o nome e o identificador exclusivo do seu dispositivo. Aqui, eu defini essas duas opções para o MSDN DeviceTemplate – msdn-dispositivo-id1 e msdn-dispositivo-id-1, respectivamente (veja a Figura 6).

Figura 6 Device Explorer mostrando os dispositivos simulados e os reais

Se você clicar agora no dispositivo real no Explorer, você verá que sua telemetria, configurações, propriedades e o painel são todos iguais aos do dispositivo simulado. No entanto, você ainda não tem nenhuma medida porque o dispositivo não está conectado. Além disso, no canto superior direito do modelo do dispositivo real, você verá hiperlinks adicionais: Bloquear e Conectar. Bloquear permite bloquear o dispositivo para que o aplicativo do IoT Central não aceite nenhuma solicitação do dispositivo remoto. Conectar exibe a ID do escopo e as credenciais necessárias para conectar o dispositivo à nuvem, conforme mostrado na Figura 7.

Figura 7 Conexão do Dispositivo

O IoT Central oferece suporte a duas maneiras de autorizar o seu dispositivo. Você pode usar a Assinatura de Acesso Compartilhado (SAS) ou Certificados X.509. Ambas as abordagens são descritas detalhadamente em bit.ly/2ClDv3z. No aplicativo cliente que vou desenvolver, vou usar a abordagem de SAS. Portanto, para continuar precisarei anotar a ID do escopo, a ID do dispositivo e a chave primária ou secundária exibidas na tela de conexão do dispositivo na Figura 7. Usarei a ferramenta de linha de comando dps_cstr para gerar a cadeia de conexão. (Você pode baixar a versão do Windows dessa ferramenta em bit.ly/2Cj3Ejv.) Em seguida, para obter a cadeia de conexão real, é necessário abrir a linha de comando e digitar o seguinte comando:

dps_cstr <scope_id> <device_id> <SAS Key>

Para os parâmetros mostrados na Figura 7, a ferramenta dps_cstr gerou a seguinte cadeia de conexão:

HostName=saas-iothub-28681fd2-94c7-4938-bf7e-7ae3e94a407c.azure-devices.net;DeviceId=msdn-device-id1;SharedAccessKey=nQqFzf6TvnQA+zFI4MVaSSBeZgsYSY0P7KXrl6z6oDE=

Implementar o aplicativo cliente

Para criar o aplicativo cliente, desenvolvi um aplicativo .NET Core em C# com base no modelo de Aplicativo do Console. A maior parte do código também pode ser usada sem nenhuma alteração em um aplicativo Core de IoT da UWP do Windows 10. No entanto, decidi usar o .NET Core para minimizar as cargas de trabalho necessárias para implementar o aplicativo cliente para o IoT Central.

Utilizei o Visual Studio 2017 Community Edition, começando com a caixa de diálogo Novo projeto. Escolhi o modelo de projeto de Aplicativo de Console (.NET Core 2.1), em seguida, defini o nome do aplicativo como IoTCentralClient e instalei o pacote NuGet do Microsoft.Azure.Devices.Client para me conectar rapidamente ao Hub IoT.

Em seguida, continuei com a implementação real, começando com a classe DeviceClientHelper mostrada na Figura 8.

Figura 8 A classe DeviceClientHelper

public static class DeviceClientHelper
{
  private static readonly string connectionString
    = "<your_connection_string>";
  private static DeviceClient deviceClient;
  public static DeviceClient Init()
  {
    if (deviceClient == null)
    {
      deviceClient = DeviceClient.
        CreateFromConnectionString(connectionString);
    }
    return deviceClient;
  }
}

A classe DeviceClientHelper usa o Microsoft.Azure.Devices.Client.DeviceClient para associar a conexão ao Hub IoT. Para esse fim, DeviceClient usa a cadeia de conexão gerada pela ferramenta dps_cstr. A cadeia de conexão é passada como um argumento ao método estático CreateFromConnectionString da classe DeviceClient.

Telemetria

Depois de preparar a conexão, criei a classe Data, mostrada na Figura 9, que é uma representação abstrata da telemetria que será enviada para a nuvem.

Figura 9 A classe Data

public class Data
{
  public double Temperature { get; set; }
  public double Humidity { get; set; }
  public Message ToMessage()
  {
    var dataJson = JsonConvert.SerializeObject(this);
    return new Message(Encoding.ASCII.GetBytes(dataJson));
  }
  public override string ToString()
  {
    return $"Temperature: {Temperature,6:F2}, Humidity: {Humidity,6:F2}";
  }
}

Lembre-se de que propriedades públicas da classe Data são usadas no ponto de extremidade da nuvem para desserializar corretamente os objetos enviados do seu dispositivo. Portanto, os nomes de propriedade precisam corresponder aos Nomes de Campo usados no modelo do dispositivo. Caso contrário, os dados de telemetria não serão corretamente analisados pela nuvem.

Em seguida, para desserializar o objeto de telemetria, escrevi o método ToMessage mostrado na Figura 9. Na primeira etapa, ToMessage obtém a cadeia de caracteres formatada em JSON, que representa o objeto Data. Isso é feito com JsonConvert.SerializeObject. Na segunda etapa, a cadeia de caracteres JSON é convertida em uma matriz de bytes com Encoding.ASCII.GetBytes. O resultado dessa operação é usado para instanciar a classe Microsoft.Azure.Devices.Client.Message. Em seguida, as instâncias dessa classe podem ser enviadas ao Hub IoT usando o método SendEventAsync da classe DeviceClient.

Em seguida, escrevi a classe Generator para gerar e enviar dados de telemetria. Essa classe emula um sensor real de leitura por meio da geração aleatória de valores de temperatura e umidade (consulte Data/Generator.cs no código-fonte complementar). Para esse fim, a classe Generator usa a classe System.Random para sintetizar a leitura do sensor de um determinado intervalo:

private Random randomNumberGenerator = new Random();
private double GetRandomValue(MeasurementRange measurementRange)
{
  var randomValueRescaled = randomNumberGenerator.NextDouble()
    * measurementRange.ValueRange();
  return measurementRange.Min + randomValueRescaled;
}

O intervalo de medição é representado por instâncias da classe MeasurementRange:

public class MeasurementRange
{
  public double Min { get; set; }
  public double Max { get; set; }
  public double ValueRange()
  {
    return Max - Min;
  }
}

A classe Generator tem dois campos do tipo anterior (MeasurementRange). Eles correspondem às medidas de temperatura e umidade:

private readonly MeasurementRange temperatureRange
  = new MeasurementRange() { Min = -20, Max = 60 };
private readonly MeasurementRange humidityRange
  = new MeasurementRange() { Min = 0, Max = 100 };

Observe que esses intervalos são iguais aos especificados anteriormente no modelo do dispositivo.

A classe Generator usa uma instância de DeviceClient e CancellationToken. A primeira é usada para enviar a telemetria, enquanto a segunda interromperá o loop infinito de telemetria. As instâncias reais de DeviceClient e CancellationToken são passadas por meio do construtor da classe Generator:

private DeviceClient deviceClient;
private CancellationToken cancellationToken;
public Generator(DeviceClient deviceClient,
  CancellationToken cancellationToken)
{
  Check.IsNull(deviceClient);
  Check.IsNull(cancellationToken);
  this.deviceClient = deviceClient;
  this.cancellationToken = cancellationToken;
}

A classe Check é uma classe auxiliar estática usada para verificar se os argumentos são nulos ou não (consulte o código complementar Helpers/Check.cs).

Os dados de telemetria são gerados e enviados para a nuvem dentro do loop de while implementado no método da instância TelemetryAction da classe Generator, mostrado na Figura 10.

Figura 10 O método TelemetryAction

public bool IsTelemetryActive { get; set; } = true;
private void TelemetryAction()
{
  while (!cancellationToken.IsCancellationRequested)
  {
    var telemetryData = new Data()
    {
      Temperature = GetRandomValue(temperatureRange),
      Humidity = GetRandomValue(humidityRange)
    };
    if (IsTelemetryActive)
    {
      deviceClient.SendEventAsync(telemetryData.ToMessage());
      Console.WriteLine($"Sending telemetry: {telemetryData}");
    }
    else
    {
      Console.WriteLine("Idle");
    }
      Task.Delay(delayTime).Wait();
  }
}

Observe que a telemetria é enviada para a nuvem somente quando a propriedade IsTelemetryActive for true. Essa propriedade pode ser alterada no ponto de extremidade da nuvem através da guia Configurações no aplicativo do IoT Central (Figura 4).

TelemetryAction é executado em segundo plano usando o padrão assíncrono baseado em tarefa:

public Task Start()
{
  telemetryTask = new Task(TelemetryAction);
  telemetryTask.Start();
  return telemetryTask;
}

Juntando as coisas

Com as classes DeviceClientHelper e Generator prontas, combinei-as dentro da classe Programa (consulte Program.cs no código complementar). Comecei com a implementação do método estático Program conforme mostrado na Figura 11.

Figura 11 O método Program.Main

private static CancellationTokenSource cancellationTokenSource
   = new CancellationTokenSource();
static void Main(string[] args)
{
  // Configure cancel key press handler (to stop the app)
  Console.CancelKeyPress += new ConsoleCancelEventHandler(
    CancelKeyPressHandler);
  // Connect to the cloud
  var deviceClient = DeviceClientHelper.Init();
  // Telemetry generator produces random temperature
  // and humidity, and then sends them both to the cloud
  var telemetryGenerator = new Generator(
    deviceClient, cancellationTokenSource.Token);
  // Associate handler to update device properties according to cloud requests
  deviceClient.SetDesiredPropertyUpdateCallbackAsync(
    PropertyUpdateCallback, telemetryGenerator).Wait();
  // Start telemetry
  telemetryGenerator.Start().Wait();
}

Primeiro, o método Program.Main conecta um manipulador de eventos ao evento Console.CancelKeyPress para interromper o loop de telemetria (usando o token de cancelamento) e fecha o aplicativo:

private static void CancelKeyPressHandler(object sender,
  ConsoleCancelEventArgs e)
{
  if (e.SpecialKey == ConsoleSpecialKey.ControlC)
  {
    cancellationTokenSource.Cancel();
    Environment.Exit(0);
  }
}

Em seguida, o método Main se conecta ao Hub IoT usando o método estático Init de DeviceClientHelper. Init retorna uma instância da classe DeviceClient, que é então passada para o construtor da classe Generator.

O método SetDesiredPropertyUpdateCallbackAsync da instância da classe DeviceClient agora é usado para definir o retorno de chamada que é invocado quando o operador altera as configurações do dispositivo no ponto de extremidade da nuvem. Esse retorno de chamada, PropertyUpdateCallback (veja a Figura 12), é fornecido com uma instância da classe Microsoft.Azure.Devices.Shared.TwinCollection. Este objeto representa a coleção de configurações do dispositivo. Em particular, o indexador de classe pode ser usado para ler os valores das configurações selecionadas. Identifique configurações específicas usando seus respectivos Nomes de Campo, configurados no ponto de extremidade da nuvem. Na Figura 12, mostro como ler o valor da configuração IsTelemetryActive e como usá-lo para atualizar a propriedade correspondente da instância da classe Generator.

Figura 12 PropertyUpdateCallback

private static readonly string telemetryActivePropertyName =
  "IsTelemetryActive";
private static readonly string propertyValue = "value";
private static Task PropertyUpdateCallback(
  TwinCollection desiredProperties, object userContext)
{
  if (desiredProperties.Contains(telemetryActivePropertyName))
  {
    var telemetryGenerator = userContext as Generator;
    telemetryGenerator.IsTelemetryActive =
      desiredProperties[telemetryActivePropertyName][propertyValue];
  }
  return Task.CompletedTask;
}

Por fim, o método Main inicia a telemetria invocando o método Start da instância da classe Generator.

Para testar o aplicativo cliente, você precisa executá-lo. Se a cadeia de conexão for válida, o aplicativo vai se conectar ao Hub IoT e iniciar a transmissão dos dados de telemetria. Cada medida sintetizada será impressa no console e, em seguida, você verá essas medidas no painel da nuvem (consulte novamente a Figura 1). Também é possível alterar remotamente IsTelemetryActive para desabilitar temporariamente a telemetria. Para fazer isso, abra a guia Configurações do seu aplicativo do Azure IoT Central, mude a alternância e clique no botão Atualizar. Nesse caso, o aplicativo cliente imprime a cadeia de caracteres Ociosa, em vez dos dados de telemetria real.

Conclusão

Neste artigo, mostrei como criar rapidamente um aplicativo Web personalizado, totalmente funcional e com uma aparência moderna para uma solução de IoT usando o Azure IoT Central. Também demonstrei como criar um modelo de dispositivo e como usá-lo para apresentar dados de telemetria, a localização do dispositivo e os KPIs. Em seguida, desenvolvi um aplicativo cliente em C# e o conectei para transmitir dados de telemetria para a nuvem. Por fim, mostrei como responder a alterações de configuração do dispositivo solicitadas por meio do aplicativo do IoT Central. Você pode usar tudo isso para desenvolver rapidamente painéis Web modernos para suas soluções de IoT sem nenhum conhecimento anterior sobre programação Web ou nuvem.

Dawid Borycki é engenheiro de software, pesquisador em biomédica, autor e conferencista. Ele gosta de aprender novas tecnologias para experimentação de software e protótipos. Borycki é autor de dois livros da Microsoft Press: “Programming for Mixed Reality” (2018) e “Programming for the Internet of Things” (2017).

Agradecemos Bruno Sonnino, especialista técnico da Microsoft, pela revisão deste artigo
Bruno Sonnino é MVP da Microsoft em desenvolvimento de Windows. Ele é desenvolvedor, consultor, autor e instrutor há mais de 20 anos e é apaixonado por desenvolvimento de software.

Discuta esse artigo no fórum do MSDN Magazine