HoloLens (1ª geração) e Azure 313: Serviço de Hub IoT

Observação

Os tutoriais do Mixed Reality Academy foram projetados com o HoloLens (1ª geração) e os headsets imersivos de realidade misturada em mente. Dessa forma, achamos que é importante continuar disponibilizando esses tutoriais para os desenvolvedores que ainda buscam obter diretrizes para o desenvolvimento visando esses dispositivos. Esses tutoriais não serão atualizados com os conjuntos de ferramentas mais recentes nem com as interações usadas para o HoloLens 2. Eles serão mantidos para continuar funcionando nos dispositivos compatíveis. Haverá uma nova série de tutoriais que serão postados no futuro que demonstrarão como desenvolver para o HoloLens 2. Este aviso será atualizado com um link para esses tutoriais quando eles forem postados.

Resultado do curso

Neste curso, você aprenderá a implementar um Serviço de Hub IoT do Azure em uma máquina virtual que executa o sistema operacional Ubuntu 16.4. Um Aplicativo de Funções do Azure será usado para receber mensagens de sua VM do Ubuntu e armazenar o resultado em um Serviço de Tabela do Azure. Em seguida, você poderá exibir esses dados usando o Power BI no Microsoft HoloLens ou headset imersivo (VR).

O conteúdo deste curso é aplicável a dispositivos IoT Edge, embora, para a finalidade deste curso, o foco seja em um ambiente de máquina virtual, para que o acesso a um dispositivo Edge físico não seja necessário.

Ao concluir este curso, você aprenderá a:

Implante um módulo do IoT Edge em uma máquina virtual (sistema operacional Ubuntu 16), que representará seu dispositivo IoT.
Adicione um Modelo do Tensorflow da Visão Personalizada do Azure ao módulo Edge, com código que analisará as imagens armazenadas no contêiner.
Configure o módulo para enviar a mensagem de resultado da análise de volta para o Serviço de Hub IoT.
Use um Aplicativo de Funções do Azure para armazenar a mensagem em uma Tabela do Azure.
Configure o Power BI para coletar a mensagem armazenada e criar um relatório.
Visualize os dados da mensagem de IoT no Power BI.

Os Serviços que você usará incluem:

O Hub IoT do Azure é um serviço do Microsoft Azure que permite que os desenvolvedores conectem, monitorem e gerenciem ativos de IoT. Para obter mais informações, visite a página do Serviço de Hub IoT do Azure.
O Registro de Contêiner do Azure é um serviço do Microsoft Azure que permite que os desenvolvedores armazenem imagens de contêiner para vários tipos de contêineres. Para obter mais informações, visite a página do Serviço de Registro de Contêiner do Azure.
O Azure Function App é um serviço do Microsoft Azure que permite que os desenvolvedores executem pequenas partes de código, 'funções', no Azure. Isso fornece uma maneira de delegar trabalho à nuvem, em vez de ao seu aplicativo local, o que pode ter muitos benefícios. O Azure Functions dá suporte a várias linguagens de desenvolvimento, incluindo C#, F#, Node.js, Java e PHP. Para obter mais informações, visite a página do Azure Functions.
O Armazenamento do Azure: Tabelas é um serviço do Microsoft Azure que permite aos desenvolvedores armazenar dados estruturados e não SQL na nuvem, tornando-os facilmente acessíveis em qualquer lugar. O serviço possui um design sem esquema, permitindo a evolução das tabelas conforme necessário e, portanto, é muito flexível. Para obter mais informações, visite a página Tabelas do Azure

Este curso ensinará como configurar e usar o Serviço de Hub IoT e, em seguida, visualizar uma resposta fornecida por um dispositivo. Caberá a você aplicar esses conceitos a uma configuração personalizada do Serviço de Hub IoT, que você pode estar criando.

Suporte a dispositivos

Curso	HoloLens	Headsets imersivos
MR e Azure 313: Serviço de Hub IoT	✔️	✔️

Pré-requisitos

Para obter os pré-requisitos mais atualizados para desenvolver com Realidade Misturada, inclusive com o Microsoft HoloLens, visite o artigo Instalar as ferramentas .

Observação

Este tutorial foi desenvolvido para desenvolvedores que têm experiência básica com Python. Esteja ciente também de que os pré-requisitos e as instruções escritas neste documento representam o que foi testado e verificado no momento da redação (julho de 2018). Você é livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas , embora não se deva presumir que as informações deste curso corresponderão perfeitamente ao que você encontrará em softwares mais recentes do que os listados abaixo.

O seguinte hardware e software são necessários:

Windows 10 Fall Creators Update (ou posterior), Modo de Desenvolvedor habilitado

Aviso

Você não pode executar uma máquina virtual usando o Hyper-V no Windows 10 Home Edition.
SDK do Windows 10 (versão mais recente)
Um HoloLens, Modo de Desenvolvedor habilitado
Visual Studio 2017.15.4 (usado apenas para acessar o Azure Cloud Explorer)
Acesso à Internet para o Azure e para o Serviço de Hub IoT. Para obter mais informações, siga este link para a página do Serviço do Hub IoT
Um modelo de machine learning. Se você não tiver seu próprio modelo pronto para uso, poderá usar o modelo fornecido com este curso.
Software Hyper-V habilitado em seu computador de desenvolvimento do Windows 10.
Uma máquina virtual executando o Ubuntu (16.4 ou 18.4), rodando em sua máquina de desenvolvimento ou, alternativamente, você pode usar um computador separado executando o Linux (Ubuntu 16.4 ou 18.4). Você pode encontrar mais informações sobre como criar uma VM no Windows usando o Hyper-V no capítulo "Antes de começar".

Antes de começar

Configure e teste seu HoloLens. Se você precisar de suporte para configurar seu HoloLens, visite o artigo de configuração do HoloLens.
É uma boa ideia executar a Calibração e o Ajuste do Sensor ao começar a desenvolver um novo aplicativo HoloLens (às vezes, pode ajudar a executar essas tarefas para cada usuário).

Para obter ajuda sobre a calibração, siga este link para o artigo Calibração do HoloLens.

Para obter ajuda sobre o Ajuste do Sensor, siga este link para o artigo Ajuste do Sensor do HoloLens.

Configure sua máquina virtual Ubuntu usando o Hyper-V. Os recursos a seguir irão ajudá-lo com o processo.
1. Primeiro, siga este link para baixar o ISO do Ubuntu 16.04.4 LTS (Xenial Xerus). Selecione a imagem da área de trabalho do PC de 64 bits (AMD64).
2. Certifique-se de que o Hyper-V esteja habilitado em sua máquina com Windows 10. Você pode seguir este link para obter orientação sobre como instalar e habilitar o Hyper-V no Windows 10.
3. Inicie o Hyper-V e crie uma nova VM do Ubuntu. Você pode seguir este link para obter um guia passo a passo sobre como criar uma VM com o Hyper-V. Quando solicitado a "Instalar um sistema operacional a partir de um arquivo de imagem inicializável", selecione o ISO do Ubuntu que você baixou anteriormente.
Observação

O uso da Criação Rápida do Hyper-V não é sugerido.

Capítulo 1 – Recuperar o modelo de Visão Personalizada

Com este curso, você terá acesso a um modelo de Visão Personalizada pré-criado que detecta teclados e mouses a partir de imagens. Se você usar isso, vá para o Capítulo 2.

No entanto, você pode seguir estas etapas se quiser usar seu próprio modelo de Visão Personalizada:

Em seu Projeto de Visão Personalizada, vá para a guia Desempenho .

Aviso

Seu modelo deve usar um domínio compacto para exportar o modelo. Você pode alterar o domínio dos modelos nas configurações do seu projeto.
Selecione a iteração que deseja exportar e clique em Exportar. Uma lâmina aparecerá.
Na folha, clique em Arquivo do Docker.
Clique em Linux no menu suspenso e, em seguida, clique em Download.
Descompacte o conteúdo. Você o usará mais tarde neste curso.

Capítulo 2 - O Serviço de Registro de Contêiner

O Serviço de Registro de Contêiner é o repositório usado para hospedar seus contêineres.

O Serviço de Hub IoT que você criará e usará neste curso refere-se ao Serviço de Registro de Contêiner para obter os contêineres a serem implantados em seu Dispositivo de Borda.

Primeiro, siga este link para o Portal do Azure e faça logon com suas credenciais.
Vá para Criar um recurso e procure por Container Registry.
Clique em Criar.
Defina os parâmetros de configuração do serviço:
1. Insira um nome para o seu projeto, neste exemplo é chamado IoTCRegistry.
2. Escolha um grupo de recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os Serviços do Azure associados a um único projeto (por exemplo, como esses cursos) em um grupo de recursos comum).
3. Defina a localização do Serviço.
4. Defina o usuário administrador como Habilitar.
5. Defina SKU como Básico.
Clique em Criar e aguarde a criação dos Serviços.
Quando a notificação aparecer informando sobre a criação bem-sucedida do Container Registry, clique em Ir para o recurso para ser redirecionado para a página Serviço.
Na página Serviço de Registro de Contêiner, clique em Chaves de acesso.
Anote (você pode usar o Bloco de Notas) dos seguintes parâmetros:
1. Servidor de login
2. Nome de usuário
3. Senha

Capítulo 3 – O Serviço de Hub IoT

Agora você começará a criação e a configuração do Serviço de Hub IoT.

Se ainda não estiver conectado, faça logon no Portal do Azure.
Depois de fazer logon, clique em Criar um recurso no canto superior esquerdo, pesquise Hub IoT e clique em Enter.

Captura de tela que mostra a janela Tudo aberta. I O T Hub nos resultados da pesquisa e Criar um recurso no canto superior esquerdo estão circulados em vermelho.

A nova página fornecerá uma descrição do Serviço de conta de armazenamento. Na parte inferior esquerda desse prompt, clique no botão Criar para criar uma instância desse serviço.
Depois de clicar em Criar, um painel aparecerá:
1. Escolha um grupo de recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os Serviços do Azure associados a um único projeto (por exemplo, como esses cursos) em um grupo de recursos comum).
  
  Se você quiser ler mais sobre os Grupos de Recursos do Azure, siga este link sobre como gerenciar um Grupo de Recursos.
2. Selecione um local apropriado (use o mesmo local em todos os serviços criados neste curso).
3. Insira o Nome desejado para esta instância de Serviço.
Na parte inferior da página, clique em Avançar: Tamanho e escala.
Nesta página, selecione o nível de preço e escala (se esta for sua primeira instância do Serviço de Hub IoT, uma camada gratuita deverá estar disponível para você).
Clique em Revisar + Criar.
Revise suas configurações e clique em Criar.
Depois que a notificação for exibida informando sobre a criação bem-sucedida do Serviço de Hub IoT, clique em Ir para o recurso para ser redirecionado para a página Serviço.
Role o painel lateral à esquerda até ver Gerenciamento Automático de Dispositivos, clique em IoT Edge.
Na janela exibida à direita, clique em Adicionar dispositivo IoT Edge. Uma lâmina aparecerá à direita.
Na folha, forneça ao novo dispositivo uma ID de dispositivo (um nome de sua escolha). Em seguida, clique em Salvar. As chaves primárias e secundárias serão geradas automaticamente, se você tiver a opção Gerar automaticamente marcada.
Você navegará de volta para a seção Dispositivos do IoT Edge , onde seu novo dispositivo será listado. Clique no seu novo dispositivo (destacado em vermelho na imagem abaixo).
Na página Detalhes do Dispositivo exibida, faça uma cópia da Cadeia de Conexão (chave primária).
Volte para o painel à esquerda e clique em Políticas de acesso compartilhado para abri-lo.
Na página exibida, clique em iothubowner e uma folha aparecerá à direita da tela.
Anote (no Bloco de Notas) a cadeia de conexão (chave primária), para uso posterior ao definir a cadeia de conexão para o dispositivo.

Capítulo 4 - Configurando o ambiente de desenvolvimento

Para criar e implantar módulos para o Hub IoT Edge, você precisará dos seguintes componentes instalados em seu computador de desenvolvimento que executa o Windows 10:

Docker para Windows, ele solicitará que você crie uma conta para poder fazer o download.

Importante

O Docker requer Windows 10 PRO, Enterprise 14393 ou Windows Server 2016 RTM para ser executado. Se você estiver executando outras versões do Windows 10, tente instalar o Docker usando o Docker Toolbox.
Python 3.6.
Visual Studio Code (também conhecido como VS Code).

Depois de instalar o software mencionado acima, você precisará reiniciar sua máquina.

Capítulo 5 - Configurando o ambiente Ubuntu

Agora você pode configurar seu dispositivo executando o sistema operacional Ubuntu. Siga as etapas abaixo, para instalar o software necessário, para implantar seus contêineres em sua placa:

Importante

Você deve sempre preceder os comandos do terminal com sudo para executar como usuário administrador. por exemplo:

sudo docker \<option> \<command> \<argument>

Abra o Terminal Ubuntu e use o seguinte comando para instalar o pip:

[! DICA] Você pode abrir o Terminal com muita facilidade usando o atalho de teclado: Ctrl + Alt + T.
```
    sudo apt-get install python-pip
```
Ao longo deste capítulo, você pode ser solicitado, pelo Terminal, a obter permissão para usar o armazenamento do dispositivo e inserir s/n (sim ou não), digitar 'y' e pressionar a tecla Enter para aceitar.
Depois que esse comando for concluído, use o seguinte comando para instalar o curl:
```
    sudo apt install curl
```

Depois que pip e curl estiverem instalados, use o seguinte comando para instalar o runtime do IoT Edge, isso é necessário para implantar e controlar os módulos em sua placa:

    curl https://packages.microsoft.com/config/ubuntu/16.04/prod.list > ./microsoft-prod.list

    sudo cp ./microsoft-prod.list /etc/apt/sources.list.d/

    curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg

    sudo cp ./microsoft.gpg /etc/apt/trusted.gpg.d/

    sudo apt-get update

    sudo apt-get install moby-engine

    sudo apt-get install moby-cli

    sudo apt-get update

    sudo apt-get install iotedge

Neste ponto, você será solicitado a abrir o arquivo de configuração de runtime, para inserir a Cadeia de Conexão do Dispositivo, que você anotou (no Bloco de Notas), ao criar o Serviço de Hub IoT (na etapa 14, do Capítulo 3). Execute a seguinte linha no terminal para abrir esse arquivo:
```
    sudo nano /etc/iotedge/config.yaml
```
O arquivo config.yaml será exibido, pronto para você editar:

Aviso

Quando este arquivo é aberto, pode ser um pouco confuso. Você estará editando o texto deste arquivo, dentro do próprio Terminal .
1. Use as teclas de seta do teclado para rolar para baixo (você precisará rolar um pouco para baixo), para alcançar a linha que contém":
  
  "<ADICIONAR CADEIA DE CONEXÃO DO DISPOSITIVO AQUI".>
2. Substitua a linha, incluindo os colchetes, pela Cadeia de Conexão do Dispositivo que você anotou anteriormente.
Com a Cadeia de Conexão no lugar, no teclado, pressione as teclas Ctrl-X para salvar o arquivo. Ele solicitará que você confirme digitando Y. Em seguida, pressione a tecla Enter para confirmar. Você voltará ao Terminal normal.
Depois que todos esses comandos forem executados com êxito, você terá instalado o Tempo de Execução do IoT Edge. Depois de inicializado, o runtime será iniciado sozinho sempre que o dispositivo for ligado e ficará em segundo plano, aguardando a implantação dos módulos do Serviço de Hub IoT.
Execute a seguinte linha de comando para inicializar o Tempo de Execução do IoT Edge:
```
    sudo systemctl restart iotedge
```
Importante

Se você fizer alterações no arquivo .yaml ou na configuração acima, precisará executar a linha de reinicialização acima novamente, no Terminal.
Verifique o status do Tempo de Execução do IoT Edge executando a linha de comando a seguir. O tempo de execução deve aparecer com o status ativo (em execução) em texto verde.
```
    sudo systemctl status iotedge
```
Pressione as teclas Ctrl-C para sair da página de status. Você pode verificar se o IoT Edge Runtime está efetuando pull dos contêineres corretamente digitando o seguinte comando:
```
    sudo docker ps
```
Uma lista com dois (2) contêineres deve aparecer. Esses são os módulos padrão criados automaticamente pelo Serviço de Hub IoT (edgeAgent e edgeHub). Depois de criar e implantar seus próprios módulos, eles aparecerão nesta lista, abaixo dos padrão.

Capítulo 6 - Instalar as extensões

Importante

Os próximos capítulos (6-9) devem ser executados em sua máquina Windows 10.

Abra o VS Code.
Clique no botão Extensões (quadrado) na barra esquerda do VS Code para abrir o painel Extensões.
Pesquise e instale as seguintes extensões (conforme mostrado na imagem abaixo):
1. Azure IoT Edge
2. Kit de Ferramentas do Azure IoT
3. Docker
Depois que as extensões estiverem instaladas, feche e abra novamente o VS Code.
Com o VS Code aberto mais uma vez, navegue até Exibir>terminal integrado.
Agora você instalará o Cookiecutter. No terminal, execute o seguinte comando bash:
```
    pip install --upgrade --user cookiecutter
```
[! DICA] Se você tiver problemas com este comando:
1. Reinicie o VS Code e/ou seu computador.
2. Pode ser necessário alternar o Terminal VS Code para aquele que você está usando para instalar o Python, ou seja , o Powershell (especialmente caso o ambiente Python já tenha sido instalado em sua máquina). Com o Terminal aberto, você encontrará o menu suspenso no lado direito do Terminal.
3. Certifique-se de que o caminho de instalação do Python seja adicionado como Variável de Ambiente em sua máquina. O Cookiecutter deve fazer parte do mesmo caminho de localização. Siga este link para obter mais informações sobre variáveis de ambiente,
Depois que o Cookiecutter terminar de instalar, você deve reiniciar sua máquina, para que o Cookiecutter seja reconhecido como um comando, dentro do ambiente do seu sistema.

Capítulo 7 – Criar sua solução de contêiner

Neste ponto, você precisa criar o contêiner, com o módulo, a ser enviado para o Container Registry. Depois de enviar o contêiner por push, você usará o Serviço de Borda do Hub IoT para implantá-lo em seu dispositivo, que está executando o runtime do IoT Edge.

No VS Code, clique na paleta Exibir>comando.
Na paleta, pesquise e execute Azure IoT Edge: Nova Solução Iot Edge.
Navegue até um local onde você deseja criar sua solução. Pressione a tecla Enter para aceitar o local.
Dê um nome à sua solução. Pressione a tecla Enter para confirmar o nome fornecido.
Agora você será solicitado a escolher a estrutura de modelo para sua solução. Clique em Módulo Python. Pressione a tecla Enter para confirmar essa escolha.
Dê um nome ao seu módulo. Pressione a tecla Enter para confirmar o nome do seu módulo. Certifique-se de anotar (com o Bloco de Notas) o nome do módulo, pois ele será usado posteriormente.
Você notará que um endereço de repositório de imagens do Docker pré-criado aparecerá na paleta. Ficará assim:

localhost:5000/-O NOME DO SEU MÓDULO-.
Exclua localhost:5000 e, em seu lugar, insira o endereço do Servidor de Logon do Container Registry, que você anotou ao criar o Serviço de Container Registry (na etapa 8, do Capítulo 2). Pressione a tecla Enter para confirmar o endereço.
Neste momento, a solução contendo o template para o seu módulo Python será criada e sua estrutura será exibida na Aba Explorar, do VS Code, no lado esquerdo da tela. Se a guia Explorar não estiver aberta, você poderá abri-la clicando no botão superior, na barra à esquerda.
A última etapa deste capítulo é clicar e abrir o arquivo .env, na guia Explorar, e adicionar seu nome de usuário e senha do Container Registry. Esse arquivo é ignorado pelo git, mas ao criar o contêiner, definirá as credenciais para acessar o Serviço de Registro de Contêiner.

Capítulo 8 – Editando sua solução de contêiner

Agora você concluirá a solução de contêiner, atualizando os seguintes arquivos:

main.py script python.
requirements.txt.
deployment.template.json.
Dockerfile.amd64

Em seguida, você criará a pasta images , usada pelo script python para verificar se há imagens correspondentes ao seu modelo de Visão Personalizada. Por fim, você adicionará o arquivo labels.txt, para ajudar a ler seu modelo, e o arquivo model.pb, que é seu modelo.

Com o VS Code aberto, navegue até a pasta do módulo e procure o script chamado main.py. Clique duas vezes para abri-lo.

Exclua o conteúdo do arquivo e insira o seguinte código:

# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE file in the project root for
# full license information.

import random
import sched, time
import sys
import iothub_client
from iothub_client import IoTHubModuleClient, IoTHubClientError, IoTHubTransportProvider
from iothub_client import IoTHubMessage, IoTHubMessageDispositionResult, IoTHubError
import json
import os
import tensorflow as tf
import os
from PIL import Image
import numpy as np
import cv2

# messageTimeout - the maximum time in milliseconds until a message times out.
# The timeout period starts at IoTHubModuleClient.send_event_async.
# By default, messages do not expire.
MESSAGE_TIMEOUT = 10000

# global counters
RECEIVE_CALLBACKS = 0
SEND_CALLBACKS = 0

TEMPERATURE_THRESHOLD = 25
TWIN_CALLBACKS = 0

# Choose HTTP, AMQP or MQTT as transport protocol.  Currently only MQTT is supported.
PROTOCOL = IoTHubTransportProvider.MQTT


# Callback received when the message that we're forwarding is processed.
def send_confirmation_callback(message, result, user_context):
    global SEND_CALLBACKS
    print ( "Confirmation[%d] received for message with result = %s" % (user_context, result) )
    map_properties = message.properties()
    key_value_pair = map_properties.get_internals()
    print ( "    Properties: %s" % key_value_pair )
    SEND_CALLBACKS += 1
    print ( "    Total calls confirmed: %d" % SEND_CALLBACKS )


def convert_to_opencv(image):
    # RGB -> BGR conversion is performed as well.
    r,g,b = np.array(image).T
    opencv_image = np.array([b,g,r]).transpose()
    return opencv_image

def crop_center(img,cropx,cropy):
    h, w = img.shape[:2]
    startx = w//2-(cropx//2)
    starty = h//2-(cropy//2)
    return img[starty:starty+cropy, startx:startx+cropx]

def resize_down_to_1600_max_dim(image):
    h, w = image.shape[:2]
    if (h < 1600 and w < 1600):
        return image

    new_size = (1600 * w // h, 1600) if (h > w) else (1600, 1600 * h // w)
    return cv2.resize(image, new_size, interpolation = cv2.INTER_LINEAR)

def resize_to_256_square(image):
    h, w = image.shape[:2]
    return cv2.resize(image, (256, 256), interpolation = cv2.INTER_LINEAR)

def update_orientation(image):
    exif_orientation_tag = 0x0112
    if hasattr(image, '_getexif'):
        exif = image._getexif()
        if (exif != None and exif_orientation_tag in exif):
            orientation = exif.get(exif_orientation_tag, 1)
            # orientation is 1 based, shift to zero based and flip/transpose based on 0-based values
            orientation -= 1
            if orientation >= 4:
                image = image.transpose(Image.TRANSPOSE)
            if orientation == 2 or orientation == 3 or orientation == 6 or orientation == 7:
                image = image.transpose(Image.FLIP_TOP_BOTTOM)
            if orientation == 1 or orientation == 2 or orientation == 5 or orientation == 6:
                image = image.transpose(Image.FLIP_LEFT_RIGHT)
    return image


def analyse(hubManager):

    messages_sent = 0;

    while True:
        #def send_message():
        print ("Load the model into the project")
        # These names are part of the model and cannot be changed.
        output_layer = 'loss:0'
        input_node = 'Placeholder:0'

        graph_def = tf.GraphDef()
        labels = []

        labels_filename = "labels.txt"
        filename = "model.pb"

        # Import the TF graph
        with tf.gfile.FastGFile(filename, 'rb') as f:
            graph_def.ParseFromString(f.read())
            tf.import_graph_def(graph_def, name='')

        # Create a list of labels
        with open(labels_filename, 'rt') as lf:
            for l in lf:
                labels.append(l.strip())
        print ("Model loaded into the project")

        results_dic = dict()

        # create the JSON to be sent as a message
        json_message = ''

        # Iterate through images 
        print ("List of images to analyse:")
        for file in os.listdir('images'):
            print(file)

            image = Image.open("images/" + file)

            # Update orientation based on EXIF tags, if the file has orientation info.
            image = update_orientation(image)

            # Convert to OpenCV format
            image = convert_to_opencv(image)

            # If the image has either w or h greater than 1600 we resize it down respecting
            # aspect ratio such that the largest dimension is 1600
            image = resize_down_to_1600_max_dim(image)

            # We next get the largest center square
            h, w = image.shape[:2]
            min_dim = min(w,h)
            max_square_image = crop_center(image, min_dim, min_dim)

            # Resize that square down to 256x256
            augmented_image = resize_to_256_square(max_square_image)

            # The compact models have a network size of 227x227, the model requires this size.
            network_input_size = 227

            # Crop the center for the specified network_input_Size
            augmented_image = crop_center(augmented_image, network_input_size, network_input_size)

            try:
                with tf.Session() as sess:     
                    prob_tensor = sess.graph.get_tensor_by_name(output_layer)
                    predictions, = sess.run(prob_tensor, {input_node: [augmented_image] })
            except Exception as identifier:
                print ("Identifier error: ", identifier)

            print ("Print the highest probability label")
            highest_probability_index = np.argmax(predictions)
            print('FINAL RESULT! Classified as: ' + labels[highest_probability_index])

            l = labels[highest_probability_index]

            results_dic[file] = l

            # Or you can print out all of the results mapping labels to probabilities.
            label_index = 0
            for p in predictions:
                truncated_probablity = np.float64(round(p,8))
                print (labels[label_index], truncated_probablity)
                label_index += 1

        print("Results dictionary")
        print(results_dic)

        json_message = json.dumps(results_dic)
        print("Json result")
        print(json_message)

        # Initialize a new message
        message = IoTHubMessage(bytearray(json_message, 'utf8'))

        hubManager.send_event_to_output("output1", message, 0)

        messages_sent += 1
        print("Message sent! - Total: " + str(messages_sent))      
        print('----------------------------')

        # This is the wait time before repeating the analysis
        # Currently set to 10 seconds
        time.sleep(10)


class HubManager(object):

    def __init__(
            self,
            protocol=IoTHubTransportProvider.MQTT):
        self.client_protocol = protocol
        self.client = IoTHubModuleClient()
        self.client.create_from_environment(protocol)

        # set the time until a message times out
        self.client.set_option("messageTimeout", MESSAGE_TIMEOUT)

    # Forwards the message received onto the next stage in the process.
    def forward_event_to_output(self, outputQueueName, event, send_context):
        self.client.send_event_async(
            outputQueueName, event, send_confirmation_callback, send_context)

    def send_event_to_output(self, outputQueueName, event, send_context):
        self.client.send_event_async(outputQueueName, event, send_confirmation_callback, send_context)

def main(protocol):
    try:
        hub_manager = HubManager(protocol)
        analyse(hub_manager)
        while True:
            time.sleep(1)

    except IoTHubError as iothub_error:
        print ( "Unexpected error %s from IoTHub" % iothub_error )
        return
    except KeyboardInterrupt:
        print ( "IoTHubModuleClient sample stopped" )

if __name__ == '__main__':
    main(PROTOCOL)

Abra o arquivo chamado requirements.txt e substitua seu conteúdo pelo seguinte:

azure-iothub-device-client==1.4.0.0b3
opencv-python==3.3.1.11
tensorflow==1.8.0
pillow==5.1.0

Abra o arquivo chamado deployment.template.json e substitua seu conteúdo seguindo a diretriz abaixo:
1. Como você terá sua própria estrutura JSON exclusiva, precisará editá-la manualmente (em vez de copiar um exemplo). Para facilitar, use a imagem abaixo como guia.
2. As áreas que parecerão diferentes das suas, mas que você NÃO deve alterar, são destacadas em amarelo.
3. As seções que você precisa excluir são destacadas em vermelho.
4. Tenha cuidado para excluir os colchetes corretos e também remover as vírgulas.
5. O JSON preenchido deve se parecer com a seguinte imagem (embora, com suas diferenças exclusivas: nome de usuário/senha/nome do módulo/referências de módulo):

Abra o arquivo chamado Dockerfile.amd64 e substitua seu conteúdo pelo seguinte:

FROM ubuntu:xenial

WORKDIR /app

RUN apt-get update && \
    apt-get install -y --no-install-recommends libcurl4-openssl-dev python-pip libboost-python-dev && \
    rm -rf /var/lib/apt/lists/* 
RUN pip install --upgrade pip
RUN pip install setuptools

COPY requirements.txt ./
RUN pip install -r requirements.txt

RUN pip install pillow
RUN pip install numpy

RUN apt-get update && apt-get install -y \ 
    pkg-config \
    python-dev \ 
    python-opencv \ 
    libopencv-dev \ 
    libav-tools  \ 
    libjpeg-dev \ 
    libpng-dev \ 
    libtiff-dev \ 
    libjasper-dev \ 
    python-numpy \ 
    python-pycurl \ 
    python-opencv


RUN pip install opencv-python
RUN pip install tensorflow
RUN pip install --upgrade tensorflow

COPY . .

RUN useradd -ms /bin/bash moduleuser
USER moduleuser

CMD [ "python", "-u", "./main.py" ]

Clique com o botão direito do mouse na pasta abaixo dos módulos (ela terá o nome que você forneceu anteriormente; no exemplo mais abaixo, é chamado pythonmodule) e clique em Nova pasta. Nomeie as imagens da pasta.
Dentro da pasta, adicione algumas imagens contendo mouse ou teclado. Essas serão as imagens que serão analisadas pelo modelo do Tensorflow.

Aviso

Se você estiver usando seu próprio modelo, precisará alterá-lo para refletir os dados de seus próprios modelos.
Agora você precisará recuperar os arquivos labels.txt e model.pb da pasta model, que você baixou anteriormente (ou criou de seu próprio Serviço de Visão Personalizada), no Capítulo 1. Depois de ter os arquivos, coloque-os em sua solução, ao lado dos outros arquivos. O resultado final deve ficar parecido com a imagem abaixo:

Capítulo 9 - Empacote a solução como um recipiente

Agora você está pronto para "empacotar" seus arquivos como um contêiner e enviá-los por push para o Registro de Contêiner do Azure. No VS Code, abra o Terminal Integrado (Exibir>Terminal Integrado ou Ctrl`+) e use a seguinte linha para fazer logon no Docker (substitua os valores do comando pelas credenciais do ACR (Registro de Contêiner do Azure)):
```
    docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Clique com o botão direito do mouse no deployment.template.json de arquivos e clique em Criar Solução IoT Edge. Esse processo de compilação leva algum tempo (dependendo do seu dispositivo), portanto, esteja preparado para esperar. Após a conclusão do processo de compilação, um arquivo deployment.json terá sido criado dentro de uma nova pasta chamada config.
Abra a Paleta de Comandos novamente e pesquise Azure: Entrar. Siga os prompts usando as credenciais da sua Conta do Azure; O VS Code fornecerá uma opção para Copiar e Abrir, que copiará o código do dispositivo que você precisará em breve e abrirá seu navegador da Web padrão. Quando solicitado, cole o código do dispositivo para autenticar sua máquina.
Depois de entrar, você notará, na parte inferior do painel Explorar, uma nova seção chamada Dispositivos do Hub IoT do Azure. Clique nesta seção para expandi-la.
Se o dispositivo não estiver aqui, você precisará clicar com o botão direito do mouse em Dispositivos do Hub IoT do Azure e clicar em Definir Cadeia de Conexão do Hub IoT. Em seguida, você verá que a Paleta de Comandos (na parte superior do VS Code) solicitará que você insira sua Cadeia de Conexão. Essa é a cadeia de conexão que você anotou no final do Capítulo 3. Pressione a tecla Enter , depois de copiar a string.
Seu dispositivo deve carregar e aparecer. Clique com o botão direito do mouse no nome do dispositivo e clique em Criar Implantação para Dispositivo Único.
Você receberá um prompt do File Explorer , onde poderá navegar até a pasta de configuração e selecionar o arquivo deployment.json . Com esse ficheiro selecionado, clique no botão Selecionar manifesto de implementação do Edge (Select Edge Deployment Manifest ).
Neste ponto, você forneceu ao Serviço de Hub IoT o manifesto para que ele implante o contêiner, como um módulo, do Registro de Contêiner do Azure, implantando-o efetivamente em seu dispositivo.
Para exibir as mensagens enviadas do seu dispositivo para o Hub IoT, clique com o botão direito do mouse novamente no nome do dispositivo na seção Dispositivos do Hub IoT do Azure, no painel Explorer, e clique em Iniciar Monitoramento da Mensagem D2C. As mensagens enviadas do seu dispositivo devem aparecer no VS Terminal. Seja paciente, pois isso pode levar algum tempo. Consulte o próximo capítulo para depuração e verificação se a implantação foi bem-sucedida.

Este módulo agora iterará entre as imagens na pasta de imagens e as analisará, a cada iteração. Obviamente, isso é apenas uma demonstração de como fazer com que o modelo básico de aprendizado de máquina funcione em um ambiente de dispositivo IoT Edge.

Para expandir a funcionalidade deste exemplo, você pode proceder de várias maneiras. Uma maneira pode ser incluir algum código no contêiner, que captura fotos de uma webcam conectada ao dispositivo e salva as imagens na pasta de imagens.

Outra maneira pode ser copiar as imagens do dispositivo IoT para o contêiner. Uma maneira prática de fazer isso é executar o seguinte comando no terminal do dispositivo IoT (talvez um pequeno aplicativo possa fazer o trabalho, se você quiser automatizar o processo). Você pode testar esse comando executando-o manualmente no local da pasta onde seus arquivos estão armazenados:

    sudo docker cp <filename> <modulename>:/app/images/<a name of your choice>

Capítulo 10 – Depurando o runtime do IoT Edge

Veja a seguir uma lista de linhas de comando e dicas para ajudá-lo a monitorar e depurar a atividade de mensagens do Tempo de Execução do IoT Edge em seu dispositivo Ubuntu.

Verifique o status do Tempo de Execução do IoT Edge executando a seguinte linha de comando:
```
    sudo systemctl status iotedge
```
Observação

Lembre-se de pressionar Ctrl + C para terminar de visualizar o status.
Liste os contêineres que estão implantados no momento. Se o Serviço de Hub IoT tiver implantado os contêineres com êxito, eles serão exibidos executando a seguinte linha de comando:
```
    sudo iotedge list
```
Ou
```
    sudo docker ps
```
Observação

O acima é uma boa maneira de verificar se o módulo foi implantado com sucesso, pois ele aparecerá na lista; caso contrário, você verá apenas o edgeHub e o edgeAgent.
Para exibir os logs de código de um contêiner, execute a seguinte linha de comando:
```
    journalctl -u iotedge
```

Comandos úteis para gerenciar o IoT Edge Runtime:

Para excluir todos os contêineres no host:

    sudo docker rm -f $(sudo docker ps -aq)

Para interromper o Tempo de Execução do IoT Edge:
```
    sudo systemctl stop iotedge
```

Capítulo 11 – Criar serviço de tabela

Navegue de volta para o Portal do Azure, onde você criará um Serviço de Tabelas do Azure, criando um recurso de armazenamento.

Se ainda não estiver conectado, faça logon no Portal do Azure.
Uma vez logado, clique em Criar um recurso, no canto superior esquerdo, e procure por Conta de armazenamento, e pressione a tecla Enter , para iniciar a pesquisa.
Depois de aparecer, clique em Conta de armazenamento - blob, arquivo, tabela, fila na lista.
A nova página fornecerá uma descrição do Serviço de conta de armazenamento. Na parte inferior esquerda desse prompt, clique no botão Criar para criar uma instância desse serviço.
Depois de clicar em Criar, um painel aparecerá:
1. Insira o Nome desejado para esta instância de serviço (deve estar todo em minúsculas).
2. Em Modelo de implantação, clique em Gerenciador de recursos.
3. Para Tipo de conta, usando o menu suspenso, clique em Armazenamento (uso geral v1).
4. Clique em um local apropriado.
5. No menu suspenso Replicação, clique em RA-GRS (armazenamento com redundância geográfica com acesso de leitura).
6. Em Desempenho, clique em Padrão.
7. Na seção Transferência segura necessária, clique em Desativado.
8. No menu suspenso Assinatura , clique em uma assinatura apropriada.
9. Escolha um grupo de recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os Serviços do Azure associados a um único projeto (por exemplo, como esses cursos) em um grupo de recursos comum).
  
  Se você quiser ler mais sobre os Grupos de Recursos do Azure, siga este link sobre como gerenciar um Grupo de Recursos.
10. Deixe as redes virtuais como Desabilitadas, se essa for uma opção para você.
11. Clique em Criar.
Depois de clicar em Criar, você terá que esperar que o Serviço seja criado, isso pode levar um minuto.
Uma notificação será exibida no Portal assim que a instância de serviço for criada. Clique nas notificações para explorar sua nova instância de serviço.
Clique no botão Ir para o recurso na notificação e você será levado para a nova página de visão geral da instância do Serviço de Armazenamento.
Na página de visão geral, no lado direito, clique em Tabelas.
O painel à direita mudará para mostrar as informações do Serviço de Tabela, em que você precisa adicionar uma nova tabela. Faça isso clicando no botão + Tabela no canto superior esquerdo.
Uma nova página será mostrada, na qual você precisa inserir um nome de tabela. Esse é o nome que você usará para se referir aos dados em seu aplicativo em capítulos posteriores (criando o Aplicativo de Funções e o Power BI). Insira IoTMessages como o nome (você pode escolher o seu próprio, lembre-se dele quando usado posteriormente neste documento) e clique em OK.
Depois que a nova tabela for criada, você poderá vê-la na página Serviço de Tabela (na parte inferior).
Agora clique em Chaves de acesso e faça uma cópia do nome e da chave da conta de armazenamento (usando o Bloco de Notas), você usará esses valores posteriormente neste curso, ao criar o Aplicativo de Funções do Azure.
Usando o painel à esquerda novamente, role até a seção Serviço de Tabela e clique em Tabelas (ou Procurar Tabelas, em Portais mais recentes) e faça uma cópia da URL da Tabela (usando o Bloco de Notas). Você usará esse valor posteriormente neste curso, ao vincular sua tabela ao aplicativo do Power BI .

Capítulo 12 – Concluindo a Tabela do Azure

Agora que sua conta de armazenamento do Serviço Tabela foi configurada, é hora de adicionar dados a ela, que serão usados para armazenar e recuperar informações. A edição de suas tabelas pode ser feita através do Visual Studio.

Abra o Visual Studio (não o Visual Studio Code).
No menu, clique em Exibir>Cloud Explorer.
O Cloud Explorer será aberto como um item encaixado (seja paciente, pois o carregamento pode levar tempo).
Aviso

Se a assinatura usada para criar suas Contas de Armazenamento não estiver visível, verifique se você tem:
- Conectado à mesma conta que você usou para o Portal do Azure.
- Selecionou sua assinatura na página Gerenciamento de conta (talvez seja necessário aplicar um filtro nas configurações da sua conta):
Seus serviços de nuvem do Azure serão mostrados. Encontre Contas de Armazenamento e clique na seta à esquerda para expandir suas contas.
Depois de expandida, sua conta de armazenamento recém-criada deve estar disponível. Clique na seta à esquerda do seu armazenamento e, quando ela for expandida, encontre Tabelas e clique na seta ao lado dela, para revelar a Tabela que você criou no último Capítulo. Clique duas vezes na tabela.
Sua tabela será aberta no centro da janela do Visual Studio. Clique no ícone da tabela com o + (mais) nele.
Uma janela aparecerá solicitando que você adicione entidade. Você criará apenas uma entidade, embora ela tenha três propriedades. Você observará que PartitionKey e RowKey já são fornecidos, pois são usados pela tabela para localizar seus dados.
Atualize os seguintes valores:
- Nome: PartitionKey, Valor: PK_IoTMessages
- Nome: RowKey, Valor: RK_1_IoTMessages
Em seguida, clique em Adicionar propriedade (no canto inferior esquerdo da janela Adicionar entidade ) e adicione a seguinte propriedade:
- MessageContent, como uma cadeia de caracteres, deixe o Valor vazio.
Sua tabela deve corresponder à da imagem abaixo:

Observação

A razão pela qual a entidade tem o número 1 na chave de linha é porque você pode querer adicionar mais mensagens, caso deseje experimentar mais este curso.
Clique em OK quando tiver terminado. Sua tabela agora está pronta para ser usada.

Capítulo 13 – Criar um aplicativo de funções do Azure

Agora é hora de criar um Aplicativo de Funções do Azure, que será chamado pelo Serviço de Hub IoT para armazenar as mensagens do dispositivo IoT Edge no Serviço de Tabela, que você criou no capítulo anterior.

Primeiro, você precisa criar um arquivo que permita que sua função do Azure carregue as bibliotecas necessárias.

Abra o Bloco de Notas (pressione a tecla Windows e digite bloco de notas).
Com o Bloco de Notas aberto, insira a estrutura JSON abaixo nele. Depois de fazer isso, salve-o em sua área de trabalho como project.json. Esse arquivo define as bibliotecas que sua função usará. Se você tiver usado o NuGet, ele parecerá familiar.

Aviso

É importante que a nomenclatura esteja correta; certifique-se de que NÃO tenha uma extensão de arquivo .txt . Veja abaixo para referência:
```
{
"frameworks": {
    "net46":{
    "dependencies": {
        "WindowsAzure.Storage": "9.2.0"
    }
    }
}
}
```
Faça logon no Portal do Azure.
Depois de fazer logon, clique em Criar um recurso no canto superior esquerdo, pesquise Aplicativo de Funções e pressione a tecla Enter para pesquisar. Clique em Aplicativo de Funções nos resultados para abrir um novo painel.
O novo painel fornecerá uma descrição do Serviço de Aplicativo de Funções. Na parte inferior esquerda deste painel, clique no botão Criar para criar uma associação com este Serviço.
Depois de clicar em Criar, preencha o seguinte:
1. Em Nome do aplicativo, insira o nome desejado para essa instância de serviço.
2. Selecione uma Assinatura.
3. Selecione o tipo de preço apropriado para você, se esta for a primeira vez que cria um Serviço de Aplicativo de Funções, uma camada gratuita deverá estar disponível para você.
4. Escolha um grupo de recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os Serviços do Azure associados a um único projeto (por exemplo, como esses cursos) em um grupo de recursos comum).
  
  Se você quiser ler mais sobre os Grupos de Recursos do Azure, siga este link sobre como gerenciar um Grupo de Recursos.
5. Para SO, clique em Windows, pois essa é a plataforma pretendida.
6. Selecione um Plano de Hospedagem (este tutorial está usando um Plano de Consumo.
7. Selecione um local (escolha o mesmo local do armazenamento que você criou na etapa anterior)
8. Para a seção Armazenamento , você deve selecionar o Serviço de Armazenamento criado na etapa anterior.
9. Você não precisará do Application Insights neste aplicativo, portanto, sinta-se à vontade para deixá-lo desativado.
10. Clique em Criar.
Depois de clicar em Criar, você terá que esperar que o Serviço seja criado, isso pode levar um minuto.
Uma notificação será exibida no Portal assim que a instância de serviço for criada.
Clique na notificação, assim que a implantação for bem-sucedida (concluída).
Clique no botão Ir para o recurso na notificação para explorar sua nova instância de serviço.
No lado esquerdo do novo painel, clique no + ícone (mais) ao lado de Funções para criar uma nova função.
No painel central, a janela de criação de função aparecerá. Role para baixo e clique em Função personalizada.
Role para baixo na próxima página até encontrar o Hub IoT (Hub de Eventos) e clique nele.
Na folha Hub IoT (Hub de Eventos), defina o Idioma como C# e clique em novo.
Na janela exibida, verifique se o Hub IoT está selecionado e se o nome do campo Hub IoT corresponde ao nome do Serviço do Hub IoT que você criou anteriormente (na etapa 8, do Capítulo 3). Em seguida, clique no botão Selecionar .
De volta à folha Hub IoT (Hub de Eventos), clique em Criar.
Você será redirecionado para o editor de funções.

Exclua todo o código nele e substitua-o pelo seguinte:

#r "Microsoft.WindowsAzure.Storage"
#r "NewtonSoft.Json"

using System;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Table;
using Newtonsoft.Json;
using System.Threading.Tasks;

public static async Task Run(string myIoTHubMessage, TraceWriter log)
{
    log.Info($"C# IoT Hub trigger function processed a message: {myIoTHubMessage}");

    //RowKey of the table object to be changed
    string tableName = "IoTMessages";
    string tableURL = "https://iothubmrstorage.table.core.windows.net/IoTMessages";

    // If you did not name your Storage Service as suggested in the course, change the name here with the one you chose.
    string storageAccountName = "iotedgestor"; 

    string storageAccountKey = "<Insert your Storage Key here>";   

    string partitionKey = "PK_IoTMessages";
    string rowKey = "RK_1_IoTMessages";

    Microsoft.WindowsAzure.Storage.Auth.StorageCredentials storageCredentials =
        new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(storageAccountName, storageAccountKey);

    CloudStorageAccount storageAccount = new CloudStorageAccount(storageCredentials, true);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.CreateCloudTableClient();

    // Get a reference to a table named "IoTMessages"
    CloudTable messageTable = tableClient.GetTableReference(tableName);

    //Retrieve the table object by its RowKey
    TableOperation operation = TableOperation.Retrieve<MessageEntity>(partitionKey, rowKey);
    TableResult result = await messageTable.ExecuteAsync(operation);

    //Create a MessageEntity so to set its parameters
    MessageEntity messageEntity = (MessageEntity)result.Result;

    messageEntity.MessageContent = myIoTHubMessage;
    messageEntity.PartitionKey = partitionKey;
    messageEntity.RowKey = rowKey;

    //Replace the table appropriate table Entity with the value of the MessageEntity Ccass structure.
    operation = TableOperation.Replace(messageEntity);

    // Execute the insert operation.
    await messageTable.ExecuteAsync(operation);
}

// This MessageEntity structure which will represent a Table Entity
public class MessageEntity : TableEntity
{
    public string Type { get; set; }
    public string MessageContent { get; set; }   
}

Altere as seguintes variáveis, para que correspondam aos valores apropriados (valores de Tabela e Armazenamento , das etapas 11 e 13, respectivamente, do Capítulo 11), que você encontrará em sua Conta de Armazenamento:
- tableName, com o nome da Tabela localizada na Conta de Armazenamento.
- tableURL, com a URL da Tabela localizada na Conta de Armazenamento.
- storageAccountName, com o nome do valor correspondente ao nome da sua Conta de Armazenamento.
- storageAccountKey, com a chave obtida no Serviço de Armazenamento criado anteriormente.
Com o código no lugar, clique em Salvar.
Em seguida, clique no < ícone (seta), no lado direito da página.
Um painel deslizará pela direita. Nesse painel, clique em Carregar e um Navegador de Arquivos aparecerá.
Navegue até o arquivo project.json e clique nele que você criou no Bloco de Notas anteriormente e clique no botão Abrir . Esse arquivo define as bibliotecas que sua função usará.
Quando o arquivo for carregado, ele aparecerá no painel à direita. Clicar nele irá abri-lo no Editor de funções . Deve ser exatamente igual à próxima imagem.
Neste ponto, seria bom testar a capacidade de sua função de armazenar a mensagem em sua tabela. No canto superior direito da janela, clique em Testar.
Insira uma mensagem no corpo da solicitação, conforme mostrado na imagem acima, e clique em Executar.
A função será executada, exibindo o status do resultado (você notará o status verde 202 Aceito, acima da janela Saída, o que significa que foi uma chamada bem-sucedida):

Capítulo 14 - Ver mensagens ativas

Se você abrir o Visual Studio (não o Visual Studio Code), poderá visualizar o resultado da mensagem de teste, pois ele será armazenado na área de cadeia de caracteres MessageContent .

Captura de tela que mostra a guia Tabela de Mensagens I O T aberta no Microsoft Visual Studio.

Com o Serviço de Tabela e o Aplicativo de Funções em vigor, as mensagens do dispositivo Ubuntu aparecerão na Tabela IoTMessages . Se ainda não estiver em execução, inicie o dispositivo novamente e você poderá ver as mensagens de resultado do dispositivo e do módulo, dentro da tabela, usando o Visual Studio Cloud Explorer.

Visualizar dados

Capítulo 15 – Instalação do Power BI

Para visualizar os dados do seu dispositivo IOT, você configurará o Power BI (versão desktop) para coletar os dados do Serviço de Tabela, que você acabou de criar. A versão do HoloLens do Power BI usará esses dados para visualizar o resultado.

Abra a Microsoft Store no Windows 10 e procure por Power BI Desktop.
Baixe o aplicativo. Assim que terminar o download, abra-o.
Faça logon no Power BI com sua conta do Microsoft 365. Você pode ser redirecionado para um navegador para se inscrever. Depois de se inscrever, volte para o aplicativo do Power BI e entre novamente.
Clique em Obter dados e, em seguida, clique em Mais....
Clique em Azure, Armazenamento de Tabelas do Azure e clique em Conectar.
Você será solicitado a inserir a URL da Tabela coletada anteriormente (na etapa 13 do Capítulo 11) ao criar o Serviço de Tabela. Após inserir a URL, exclua a parte do caminho referente à "subpasta" da Tabela (que era IoTMessages, neste curso). O resultado final deve ser o exibido na imagem abaixo. Em seguida, clique em OK.
Você será solicitado a inserir a Chave de Armazenamento que anotou (na etapa 11 do Capítulo 11) anteriormente ao criar seu Armazenamento de Tabelas. Em seguida, clique em Conectar.
Um Painel de Navegação será exibido, marque a caixa ao lado de sua Tabela e clique em Carregar.
Sua tabela agora foi carregada no Power BI, mas requer uma consulta para exibir os valores nela. Para fazer isso, clique com o botão direito do mouse no nome da tabela localizada no painel CAMPOS no lado direito da tela. Em seguida, clique em Editar consulta.
Um Editor do Power Query será aberto como uma nova janela, exibindo sua tabela. Clique na palavra Gravar na coluna Conteúdo da tabela para visualizar o conteúdo armazenado.
Clique em Na tabela, no canto superior esquerdo da janela.
Clique em Fechar e Aplicar.
Uma vez finalizada a carga da consulta, dentro do painel CAMPOS, no lado direito da tela, marque as caixas correspondentes aos parâmetros Nome e Valor, para visualizar o conteúdo da coluna MessageContent .
Clique no ícone de disco azul no canto superior esquerdo da janela para salvar seu trabalho em uma pasta de sua escolha.
Agora você pode clicar no botão Publicar para carregar sua tabela em seu espaço de trabalho. Quando solicitado, clique em Meu espaço de trabalho e clique em Selecionar. Aguarde até que ele exiba o resultado bem-sucedido do envio.

Aviso

O capítulo a seguir é específico do HoloLens. No momento, o Power BI não está disponível como um aplicativo imersivo, no entanto, você pode executar a versão da área de trabalho no Portal do Windows Mixed Reality (também conhecido como Cliff House), por meio do aplicativo da área de trabalho.

Capítulo 16 – Exibir dados do Power BI no HoloLens

Em seu HoloLens, faça logon na Microsoft Store, tocando em seu ícone na lista de aplicativos.
Pesquise e baixe o aplicativo do Power BI .
Inicie o Power BI na lista de aplicativos.
O Power BI pode solicitar que você faça logon em sua conta do Microsoft 365.
Uma vez dentro do aplicativo, o espaço de trabalho deve ser exibido por padrão, conforme mostrado na imagem abaixo. Se isso não acontecer, basta clicar no ícone do espaço de trabalho no lado esquerdo da janela.

Seu aplicativo Hub IoT terminou

Parabéns, você criou com êxito um Serviço de Hub IoT, com um dispositivo de Borda de Máquina Virtual simulado. Seu dispositivo pode comunicar os resultados de um modelo de aprendizado de máquina a um Serviço de Tabela do Azure, facilitado por um Aplicativo de Funções do Azure, que é lido no Power BI e visualizado em um Microsoft HoloLens.

Tela do Holo Lens que mostra a página do Microsoft Power BI.

Exercícios de bônus

Exercício 1

Expanda a estrutura de mensagens armazenada na tabela e exiba-a como um gráfico. Talvez você queira coletar mais dados e armazená-los na mesma tabela, para serem exibidos posteriormente.

Exercício 2

Crie um módulo adicional de "captura de câmera" a ser implantado na placa IoT, para que ele possa capturar imagens através da câmera a ser analisada.

Comentários

Esta página foi útil?

Last updated on 2024-07-04