• Artigo

Este artigo foi traduzido por máquina.

Windows Azure Insider

O Barramento de Serviço do Windows Azure e a Internet das coisas, Parte 2

Bruno Terkaly
Ricardo Villalobos

Baixe o código de exemplo

Em nossa última coluna (msdn.microsoft.com/magazine/dn574801), discutimos a atual panorama de tecnologia para computação de máquina-para-máquina (M2M), que se refere às tecnologias que interconectam dispositivos, geralmente para instrumentação industrial, sob a forma de sensores ou medidores. A proliferação de computadores minúsculos acessíveis e fácil-de-programa ampliou esse conceito que é chamado a Internet-de-coisas (IoT), abrindo as portas para cenários onde mesmo ordinários eletrodomésticos podem ser controlados ou usados como fontes de informação para gerar eventos. Desta forma, não é difícil de enviar alertas quando é hora de reabastecer a geladeira, automaticamente fecha as cortinas de janela enquanto a noite cai ou ajuste o termostato baseado os hábitos da família.

Fizemos também o caso de usar o barramento de serviços do Windows Azure para conectividade do dispositivo, como uma alternativa ao uso de uma VPN, ao tentar resolver as preocupações de endereçamento, segurança e desempenho, associadas à implantação de um grande número de sensores ou medidores. Isso está se tornando cada vez mais relevante, Considerando que, de acordo com o último relatório de inteligência de BI de Business Insider, haverá mais de 9 bilhões conexões directamente relacionadas com o IoT no ano de 2018 (read.bi/18L5cg8).

Usar um tópico ou fila de barramento de serviço designado para um dispositivo fornece uma maneira elegante de incorporar a resiliência e conectividade ocasional para muitos aplicativos. Neste artigo, nós andaremos com uma implementação hands-on do Windows Azure que ilustra esses conceitos, criando um modelo de barramento de serviço com as filas de dispositivo, implantando uma função de trabalho escuta nos serviços de nuvem, e um dispositivo de Arduino que executa comandos de programação enviada remotamente por clientes móveis, conforme mostrado no Figura 1.


Figura 1: uma arquitetura de Internet-de-coisas usando o Windows Azure Service Bus

Se você olhar para o diagrama, o componente de barramento de serviços Windows Azure torna-se o ponto central do projeto, fornecendo a autenticação, a distribuição de mensagens e a escalabilidade para oferecer suporte os vários dispositivos que serão dados a enviar ou receber comandos remotos. O barramento de serviço está disponível em todos os datacenters da Microsoft que oferecem serviços do Windows Azure, e isso é apoiado por uma infra-estrutura de armazenamento altamente redundante. Além disso, como todos os outros componentes do Windows Azure, ele oferece uma aberta e fácil de entender resto interface, juntamente com vários SDKs (Microsoft .NET Framework, Java, PHP, Ruby, entre outros) construída em cima dele.

Em nossa arquitetura proposta, dispositivos "conversar" com um aplicativo .NET em execução no Windows Azure Cloud Services, que atua como um gateway para o barramento de serviços para simplificar o processo de comunicação com sua fila de atribuído. Esta abordagem totalmente permite que qualquer um dos quatro padrões de comunicação muito descritos em nossa coluna anterior: Telemetria, inquérito, comando e notificação. Aqui, implementaremos um cenário no qual um dispositivo móvel envia um comando para outro dispositivo para executar uma ação — neste caso, transformar um LED ligado ou desligado. Um dos benefícios desta solução é que se o dispositivo estiver temporariamente off-line, ele pode pegar os comandos sempre que ele se reconecta à Internet. Você também pode configurar um tempo de expiração em uma mensagem para evitar a execução de uma tarefa em um momento inconveniente ou agendar mensagens para ser enviado em um momento específico no futuro.

Para este exemplo, usaremos o dispositivo de Arduino conhecido e bem documentado, conforme descrito em nossa coluna anterior. Para a parte de cliente móvel da prova de conceito, vamos criar um aplicativo do Windows Phone.

Aqui está o nosso cenário simples:

  1. Quando o dispositivo do Arduino é iniciado, ele envia um sinal de identificação para o aplicativo de portal em execução no Windows Azure Cloud Services. Gateway cria uma fila de barramento de serviço para o dispositivo, caso ele não existe e estabelece uma conexão TCP, pronta para enviar comandos.
  2. Um aplicativo do Windows Phone envia um comando para a fila de barramento de serviços Windows Azure atribuída para o dispositivo.
  3. A mensagem permanece na fila até que o aplicativo de gateway apanha-a e envia o comando para o dispositivo de Arduino através da conexão TCP estabelecida.
  4. O dispositivo de Arduino o LED ativa ou desativa baseado no comando.

Vejamos os passos para que isto aconteça, um por um.

Etapa 1: Criar o Windows Azure Service Bus Namespace usando suas credenciais do Windows Azure (você pode solicitar uma conta de teste no bit.ly/1atsgSa), entrar no portal da Web e clique na seção de barramento de serviço (ver Figura 2). Selecione a opção criar e digite um nome para seu namespace. Em seguida, clique em informações de conexão e copiar o texto na caixa de conexão Cadeia de caracteres, que você vai precisar mais tarde.


Figura 2 Criando o Windows Azure Service Bus Namespace

Etapa 2: Criar o aplicativo de Gateway e implantar para Windows Azure Cloud Services código para o aplicativo de gateway, que recupera as mensagens da fila de barramento de serviço e retransmite os comandos para o dispositivo de Arduino, é incluído no download do código (disponível em msdn.microsoft.com/magazine/msdnmag0314). É baseado na obra de Clemens mais vasto, que gentilmente contribuiu com sua orientação e conhecimentos necessários para este artigo. Seu projeto original pode ser encontrado em bit.ly/L0uK0v.

Antes de mergulharmos no presente código, certifique-se de você ter Visual Studio 2013 instalado, juntamente com a versão 2.2 do Windows Azure SDK para .NET (bit.ly/JYXx5n). A solução inclui três diferentes projetos:

  • ArduinoListener — contém o código principal do WorkerRole.
  • ConsoleListener — a versão de console da ArduinoListener, para o local de teste.
  • MSDNArduinoListener — o projeto de implantação do Windows Azure para ArduinoListener.

Se você inspecionar os arquivos ServiceConfiguration (para nuvem e implantação local) para o projeto de MSDNArduinoListener, você verá uma configuração que armazena a seqüência de caracteres de conexão para o serviço de ônibus. Substitua seu valor com o obtido na etapa 1. O resto já está configurado para a solução de trabalho, incluindo a definição de port 10100 para receber conexões de dispositivos. Em seguida, abra o arquivo WorkerRole.cs no projeto ArduinoListener, onde se encontra o código principal.

Há quatro seções principais para analisar.

Primeiro, um TcpListener é criado, e conexões de dispositivos são aceitos:

var deviceServer = new TcpListener(deviceEP);
deviceServer.Start(10);
try
{
  do
  {
    TcpClient connection = 
      await deviceServer.AcceptTcpClientAsync();
    if (connection != null)
    {      ...

Uma vez que foi estabelecida uma conexão com o dispositivo, um NetworkStream é definido e definido como modo de escuta. A variável readBuffer conterá o valor de identificador enviado por cada dispositivo Arduino:

NetworkStream deviceConnectionStream = connection.GetStream();
var readBuffer = new byte[64];
if (await deviceConnectionStream.ReadAsync(readBuffer, 0, 4) == 4)
{
  int deviceId = 
    IPAddress.NetworkToHostOrder(BitConverter.ToInt32(readBuffer, 0));
  ...

Em seguida, uma fila é criada com base no deviceId valor (no caso não existe) e uma mensagem receptor objeto é definido (ver Figura 3). Então, o receptor de fila de dispositivo é definido para o modo assíncrono para puxar mensagens (comandos da fila). Essa fila irá armazenar comandos enviados por dispositivos móveis, tais como um Windows Phone.

Figura 3 criando uma fila

var namespaceManager = 
  NamespaceManager.CreateFromConnectionString(
    RoleEnvironment.GetConfigurationSettingValue("serviceBusConnectionString"));
if (!
namespaceManager.QueueExists(string.Format("dev{0:X8}", deviceId)))
{
  namespaceManager.CreateQueue(string.Format("dev{0:X8}", deviceId));
}
var deviceQueueReceiver = messagingFactory.CreateMessageReceiver(
  string.Format("dev{0:X8}", deviceId), ReceiveMode.PeekLock);
do
{
  BrokeredMessage message = null;
  message = await deviceQueueReceiver.ReceiveAsync();
  ...

Quando uma mensagem é recebida da fila, seu conteúdo é inspeccionado e se combina com o "ON" ou "OFF" comandos, as informações são gravadas para o fluxo de conexão estabelecido com o dispositivo (ver Figura 4).

Figura 4 exclusivamente para o fluxo de conexão

if (message != null)
{
  Stream stream = message.GetBody<Stream>();
  StreamReader reader = new StreamReader(stream);
  string command = reader.ReadToEnd();
  if (command != null)
  {
    switch (command.ToUpperInvariant())
    {
      case "ON":
        await deviceConnectionStream.WriteAsync(OnFrame, 0, 
            OnFrame.Length);
        await message.CompleteAsync();
        break;
      case "OFF":
        await deviceConnectionStream.WriteAsync(OffFrame, 0, 
            OffFrame.Length);
        await message.CompleteAsync();
        break;
    }
  }
}

Observe que a mensagem não é removida da fila (message.Complete­Async) a menos que a operação de gravação para o fluxo de conexão do dispositivo é bem sucedida. Também, a fim de manter a conexão vivo, o dispositivo deverá enviar uma pulsação de ping. Para esta prova de conceito, nós não estão esperando confirmação do dispositivo quando ele recebe a mensagem. Em um sistema de produção, no entanto, esta iria ser necessária para cumprir com o padrão de "comando".

Etapa 3: Implantar o Arduino­ouvinte Windows Azure projeto para serviços em nuvem implantar o ArduinoListener para o Windows Azure é extremamente simples. No Visual Studio 2013, botão direito do mouse sobre o MSDN­ArduinoListener de projeto e selecione a opção publicar. Você encontrará instruções específicas para o Windows Azure Application assistente de publicação na bit.ly/1iP9g2p. Após concluir o assistente, você acaba com um serviço de nuvem, localizado em xyz.cloudapp. NET. Grave este nome, como você vai precisar dele quando você criar o cliente de Arduino na próxima etapa.

Etapa 4: Programar o dispositivo Arduino para falar com o Gateway (ouvinte) Arduino dispositivos oferecem uma interface rica para a realização de operações de rede usando um simples objeto de cliente da Web. Para nosso protótipo, decidimos usar o modelo de Arduino Uno R3 (bit.ly/18ZlcM8), juntamente com sua correspondente Ethernet escudo (bit.ly/1do6eRD). Para instalar, interagir e programar o Arduino dispositivos usando Windows, siga o guia no bit.ly/1dNBi9R. Você vai acabar com um easy-to-use IDE (chamado o aplicativo Arduino), onde você pode escrever programas (chamados esboços) usando JavaScript, como mostrado na Figura 5.


Figura 5 o aplicativo Arduino

Figura 6 mostra o croqui para interagir com o ouvinte Arduino criado na etapa 3 e agora implantado no Windows Azure.

Figura 6 o código de dispositivo Arduino

#include <SPI.h>#include <Ethernet.h>#include <StopWatch.h>
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network,
// and it's optional if DHCP is enabled.
byte mac[] = { 0x90, 0xA2, 0xDA, 0x0D, 0xBC, 0xAE };
static const byte deviceId[] = { 0x00, 0x00, 0x00, 0x01 };
static const uint8_t ACK = 0x01;
static const int LED_PIN = 8;
int connected = 0;
EthernetClient client;
StopWatch stopWatch;
long pingInterval = 200000;
void setup() {  Serial.begin(9600);
  Serial.println("Initialized");
  Ethernet.begin(mac);
  pinMode(LED_PIN, OUTPUT);}
void turnLedOn(){  digitalWrite(LED_PIN, HIGH);}
void turnLedOff(){  digitalWrite(LED_PIN, LOW);}
void loop() {
        if ( connected == 0)  {
    Serial.println("Trying to connect");
    char* host = "xyz.cloudapp.
net";
    client.setTimeout(10000);
    connected = client.connect(host, 10100);
    if (connected)     {
      Serial.println(
        "Connected to port, writing deviceId and waiting for commands...");
      client.write(deviceId, sizeof(deviceId));
      stopWatch.start();
    }
    else
    {
      Serial.println("Connection unsuccessful");
      client.stop();
      stopWatch.reset();
    }
  }
  if (connected == 1)
  {
    if (stopWatch.elapsed() > pingInterval)
    {
      Serial.println("Pinging Server to keep connection alive...");
      client.write(deviceId, sizeof(deviceId));
      stopWatch.reset();
       stopWatch.start();
    }
    byte buf[16];
    int readResult = client.read(buf, 1);
    if (readResult == 0)
     {
      Serial.println("Can't find listener, disconnecting...");
      connected = 0;
      stopWatch.reset();
    }
    else if (readResult == 1)
    {
      Serial.println("Data acquired, processing...");
      switch ( buf[0] )
      {
        case 1:
          Serial.println("Command to turn led on received...");
          turnLedOn();
          break;
        case 2:
           Serial.println("Command to turn led off received...");
          turnLedOff();
          break;
      }
      stopWatch.reset();
      stopWatch.start();
    }
  }
}

Esboços para o Arduino tem duas seções principais: instalação e loop. As instruções na seção de configuração são executadas uma vez, e isto é onde as variáveis são inicializadas e conexões estabelecidas. No nosso exemplo, o cliente Ethernet e valores relacionados são definidos, é estabelecida uma conexão serial (para fins de depuração) e o pino onde o LED está ligado é inicializado como uma porta de saída.

Código na seção loop é executado constantemente, e inclui dois blocos principais baseados o status da conexão TCP entre o dispositivo de Arduino e o ouvinte em execução no Windows Azure Cloud Services: conectado ou desconectado. Quando a conexão é estabelecida pela primeira vez, um objeto do cronômetro é iniciado para controlar o tempo decorrido para a conexão. Além disso, o identificador de dispositivo é enviado para o ouvinte, para ser usado como o nome da fila onde serão armazenados as mensagens e comandos.

O bloco de código que manipula o Arduino comportamento depois de estabelecida a conexão mantém controle sobre o tempo decorrido desde que a conexão foi criada, ping o ouvinte cada 200.000 ms, para manter a conexão vivo, quando não há comandos são recebidos. Esse código também tenta ler dados do listener, colocando os dados para a matriz de buf quando chega. Se um valor de "1" for detectado, o LED é girado, se o valor for "2", o LED está desligado. O objeto do cronômetro é redefinido após cada comando.

Uma vez que o desenho foi carregado para o dispositivo, o código é executado no controlador Arduino em um loop infinito, tentando se conectar a um serviço de nuvem. Quando ligado, ele encaminha o id do dispositivo para que o serviço de nuvem sabe para qual dispositivo está falando. Em seguida, o código começa a ler a entrada do serviço de nuvem, dizendo o dispositivo se deve ligar ou desligar o LED de luz (neste caso, está ligado ao porto digital 8 do dispositivo).

Etapa 5: Criando um cliente de Windows Phone para enviar para a fila de dispositivo interagindo com o dispositivo é tão simples como enviar mensagens para a fila de dispositivo. Como mencionado no início do artigo, o barramento de serviços Windows Azure fornece uma interface de resto que lhe permite interagir com ele de várias linguagens de programação. Porque não há nenhum desenvolvedores oficiais do SDK para Windows Phone, usamos um dos exemplos da Comunidade Windows Phone, que mostra como autenticar e interagir com o serviço de ônibus usando solicitações HTTP e o objeto WebClient. O código fonte também está incluído no download de código, no Visual Studio 2013 projeto chamado MSDNArduinoClient. Figura 7 mostra a tela principal do cliente, do qual você enviar comandos para o dispositivo de Arduino.


Figura 7 Interface de cliente do Windows Phone

Criar clientes semelhantes para outros dispositivos móveis (incluindo o iOS e Android) não seria difícil, pois a maioria deles fornece bibliotecas para gerar outros comandos usando o HTTP solicitar clientes. Além disso, é possível interagir diretamente com o barramento de serviços Windows Azure usando linguagens tradicionais como Java, PHP ou Ruby, que simplifica esse processo. Estes SDKs são publicados sob uma licença open source e pode ser encontrados em github.com/WindowsAzure.

Conclusão

Construindo uma Internet -­arquitetura de coisas usando o barramento de serviços do Windows Azure para gerenciar conexões de dispositivos e serviços fornece uma maneira fácil de seguro, escala e endereço clientes simultâneo­vamente sem incorrer em dispendiosas soluções VPN, com o benefício de forma eficiente manipulação ocasionalmente desconectadas cenários. Filas ato como caixas de correio dedicadas, onde as mensagens entre os dispositivos e serviços são trocadas, apoiando os casos de uso de comunicação diferentes e padrões comumente encontrados no campo. Windows Azure fornece uma infra-estrutura confiável, geo-distribuído e robusta para implantar os serviços necessários com um alto volume de sensores interligados e metros — uma tendência que vai continuar a crescer nos próximos anos.

Bruno Terkaly é um divulgador de desenvolvedor da Microsoft. A profundidade do conhecimento vem de anos de experiência no campo, escrever código usando uma infinidade de plataformas, linguagens, frameworks, SDKs, bibliotecas e APIs. Ele passa o tempo escrevendo código, blogar e fazer apresentações ao vivo na construção de aplicativos baseados em nuvem, especificamente usando a plataforma Windows Azure. Você pode ler seu blog em blogs.msdn.com/b/brunoterkaly.

Ricardo Villalobos é arquiteto de software experiente com mais de 15 anos de experiência projetando e criando aplicativos para empresas em várias indústrias. Segurando diferentes certificações técnicas, bem como um mestrado em Administração pela Universidade de Dallas, ele trabalha como arquiteto de nuvem na equipe DPE globalmente engajados parceiros para Microsoft, ajudando as empresas em todo o mundo a implementar soluções no Windows Azure. Você pode ler seu blog em blog.ricardovillalobos.com.

Terkaly e Villalobos conjuntamente apresentar conferências da indústria em geral. Eles encorajam os leitores do Windows Azure Insider contatá-los para disponibilidade. Terkaly pode ser contatado em bterkaly@microsoft.com e Villalobos pode ser contatado em Ricardo.Villalobos@microsoft.com.

Agradecemos aos seguintes especialistas técnicos da Microsoft pela revisão deste artigo: Abhishek Lal e Clemens Vasters