HoloLens (prima generazione) e Azure 313: hub IoT Servizio

Articolo
03/21/2023

Nota

Le esercitazioni di Mixed Reality Academy sono state progettate in base a HoloLens (prima generazione) e ai visori VR immersive di realtà mista. Pertanto, riteniamo importante lasciarle a disposizione degli sviluppatori a cui serve ancora materiale sussidiario per lo sviluppo di questi dispositivi. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Rimarranno invariate per consentire di continuare a lavorare sui dispositivi supportati. Saranno disponibili nuove serie di esercitazioni che verranno pubblicate in futuro che mostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali esercitazioni quando vengono pubblicati.

risultato del corso

In questo corso si apprenderà come implementare un servizio hub IoT di Azure in una macchina virtuale che esegue il sistema operativo Ubuntu 16.4. Un'app per le funzioni di Azure verrà quindi usata per ricevere messaggi dalla macchina virtuale Ubuntu e archiviare il risultato all'interno di un servizio tabelle di Azure. Sarà quindi possibile visualizzare questi dati usando Power BI in Microsoft HoloLens o visore VR immersivo.

Il contenuto di questo corso è applicabile ai dispositivi IoT Edge, anche se a scopo di questo corso, lo stato attivo sarà su un ambiente di macchine virtuali, in modo che l'accesso a un dispositivo Edge fisico non sia necessario.

Completando questo corso, si apprenderà a:

Distribuire un modulo IoT Edge in una macchina virtuale (sistema operativo Ubuntu 16), che rappresenta il dispositivo IoT.
Aggiungere un modello tensorflow di Azure Visione personalizzata al modulo Edge, con codice che analizzerà le immagini archiviate nel contenitore.
Configurare il modulo per inviare nuovamente il messaggio di risultato dell'analisi al servizio hub IoT.
Usare un'app per le funzioni di Azure per archiviare il messaggio all'interno di una tabella di Azure.
Configurare Power BI per raccogliere il messaggio archiviato e creare un report.
Visualizzare i dati dei messaggi IoT all'interno di Power BI.

I servizi usati includono:

hub IoT di Azure è un servizio di Microsoft Azure che consente agli sviluppatori di connettersi, monitorare e gestire gli asset IoT. Per altre informazioni, visitare la pagina del servizio hub IoT di Azure.
Registro Azure Container è un servizio di Microsoft Azure che consente agli sviluppatori di archiviare immagini contenitore per vari tipi di contenitori. Per altre informazioni, visitare la pagina del servizio Registro Azure Container.
App per le funzioni di Azure è un servizio Di Microsoft Azure che consente agli sviluppatori di eseguire piccole parti di codice, "funzioni", in Azure. In questo modo è possibile delegare il lavoro al cloud, anziché all'applicazione locale, che può avere molti vantaggi. Funzioni di Azure supporta diversi linguaggi di sviluppo, tra cui C#, F#, Node.js, Java e PHP. Per altre informazioni, visitare la pagina Funzioni di Azure.
Archiviazione di Azure: tabelle è un servizio di Microsoft Azure, che consente agli sviluppatori di archiviare dati strutturati, non SQL nel cloud, rendendoli facilmente accessibili ovunque. Il servizio vanta una progettazione senza schema, consentendo l'evoluzione delle tabelle in base alle esigenze e quindi è molto flessibile. Per altre informazioni, visitare la pagina Tabelle di Azure

Questo corso illustra come configurare e usare il servizio hub IoT e quindi visualizzare una risposta fornita da un dispositivo. Sarà possibile applicare questi concetti a una configurazione personalizzata del servizio hub IoT, che potrebbe essere creata.

Supporto di dispositivi

Corso	HoloLens	Visori VR immersive
MR e Azure 313: Servizio Hub IoT	✔️	✔

Prerequisiti

Per i prerequisiti più aggiornati per lo sviluppo con Realtà mista, inclusi i Microsoft HoloLens, visitare l'articolo Installa gli strumenti.

Nota

Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Python. Tenere presente anche che i prerequisiti e le istruzioni scritte all'interno di questo documento rappresentano ciò che è stato testato e verificato al momento della scrittura (luglio 2018). Si è liberi di usare il software più recente, come elencato nell'articolo installa gli strumenti , anche se non dovrebbe essere considerato che le informazioni in questo corso corrisponderanno perfettamente a ciò che troverete nel software più recente rispetto a quello elencato di seguito.

Sono necessari hardware e software seguenti:

Windows 10 Fall Creators Update (o versioni successive), modalità sviluppatore abilitata

Avviso

Non è possibile eseguire una macchina virtuale usando Hyper-V in Windows 10 Home Edition.
Windows 10 SDK (versione più recente)
HoloLens, modalità sviluppatore abilitata
Visual Studio 2017.15.4 (usato solo per accedere ad Azure Cloud Explorer)
Accesso Internet per Azure e per hub IoT Servizio. Per altre informazioni, seguire questo collegamento alla pagina del servizio hub IoT
Modello di Machine Learning. Se il modello non è pronto per l'uso, è possibile usare il modello fornito con questo corso.
Software Hyper-V abilitato nel computer di sviluppo Windows 10.
Una macchina virtuale che esegue Ubuntu (16.4 o 18.4), in esecuzione nel computer di sviluppo o in alternativa è possibile usare un computer separato che esegue Linux (Ubuntu 16.4 o 18.4). È possibile trovare altre informazioni su come creare una macchina virtuale in Windows usando Hyper-V nel capitolo "Prima di iniziare".

Prima di iniziare

Configurare e testare HoloLens. Se è necessario supportare la configurazione di HoloLens, assicurarsi di visitare l'articolo relativo alla configurazione di HoloLens.
È consigliabile eseguire l'ottimizzazione della calibrazione e del sensore quando si inizia a sviluppare una nuova app HoloLens (a volte può aiutare a eseguire queste attività per ogni utente).

Per informazioni sulla calibrazione, seguire questo collegamento all'articolo Di calibrazione HoloLens.

Per informazioni sull'ottimizzazione del sensore, seguire questo collegamento all'articolo Ottimizzazione del sensore HoloLens.

Configurare la macchina virtuale Ubuntu con Hyper-V. Le risorse seguenti consentono di usare il processo.
1. Per prima cosa, seguire questo collegamento per scaricare l'ISO di Ubuntu 16.04.4 LTS (Xenial Xerus). Selezionare l'immagine desktop AMD64 (PC a 64 bit).
2. Assicurarsi che Hyper-V sia abilitato nel computer Windows 10. È possibile seguire questo collegamento per istruzioni sull'installazione e l'abilitazione di Hyper-V in Windows 10.
3. Avviare Hyper-V e creare una nuova macchina virtuale Ubuntu. È possibile seguire questo collegamento per una guida dettagliata su come creare una macchina virtuale con Hyper-V. Quando richiesto di installare un sistema operativo da un file di immagine di avvio, selezionare l'ISO Ubuntu scaricato in precedenza.
Nota

L'uso di Hyper-V Quick Create non è consigliato.

Capitolo 1 - Recuperare il modello di Visione personalizzata

Con questo corso si avrà accesso a un modello di Visione personalizzata predefinito che rileva tastiere e mouse da immagini. Se si usa questa operazione, passare al capitolo 2.

È tuttavia possibile seguire questa procedura se si desidera usare il proprio modello di Visione personalizzata:

Nel Visione personalizzata Progetto passare alla scheda Prestazioni.

Avviso

Il modello deve usare un dominio compatto per esportare il modello. È possibile modificare il dominio dei modelli nelle impostazioni per il progetto.
Selezionare l'iterazione da esportare e fare clic su Esporta. Verrà visualizzato un pannello.
Nel pannello fare clic su File Docker.
Fare clic su Linux nel menu a discesa e quindi fare clic su Scarica.
Decomprimere il contenuto. Lo userai più avanti in questo corso.

Capitolo 2 - Servizio Registro contenitori

Il servizio Registro Container è il repository usato per ospitare i contenitori.

Il servizio hub IoT che verrà compilato e usato in questo corso fa riferimento al servizio Registro Contenitori per ottenere i contenitori da distribuire nel dispositivo perimetrale.

Per prima cosa, seguire questo collegamento al portale di Azure e accedere con le credenziali.
Passare a Crea una risorsa e cercare Registro Contenitori.
Fare clic su Crea.
Impostare i parametri di installazione del servizio:
1. Inserire un nome per il progetto. In questo esempio viene chiamato IoTCRegistry.
2. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, il provisioning e la gestione, la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto ,ad esempio questi corsi, in un gruppo di risorse comune.
3. Impostare la posizione del servizio.
4. Impostare Amministrazione'utente su Abilita.
5. Impostare SKU su Basic.
Fare clic su Crea e attendere la creazione dei servizi.
Quando viene visualizzata la notifica che informa dell'esito positivo della creazione del Registro Container, fare clic su Vai alla risorsa per essere reindirizzata alla pagina Servizio.
Nella pagina Servizio Registro Container fare clic su Chiavi di accesso.
Prendere nota (è possibile usare il Blocco note) dei parametri seguenti:
1. Server di accesso
2. Nome utente
3. Password

Capitolo 3 - Servizio di hub IoT

A questo punto si inizierà la creazione e la configurazione del servizio hub IoT.

Se non è già stato eseguito l'accesso, accedere al portale di Azure.
Dopo aver eseguito l'accesso, fare clic su Crea una risorsa nell'angolo in alto a sinistra e cercare hub IoT e fare clic su Invio.

Screenshot che mostra la finestra Tutto aperta. L'hub I O T nei risultati della ricerca e Crea una risorsa nell'angolo superiore sinistro è in rosso.

La nuova pagina fornirà una descrizione del servizio account di archiviazione . Nella parte inferiore sinistra di questa richiesta fare clic sul pulsante Crea per creare un'istanza del servizio.
Dopo aver fatto clic su Crea, verrà visualizzato un pannello:
1. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, effettuare il provisioning e gestire la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto ,ad esempio questi corsi, in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, seguire questo collegamento su come gestire un gruppo di risorse.
2. Selezionare un percorso appropriato (usare la stessa posizione in tutti i servizi creati in questo corso).
3. Inserire il nome desiderato per questa istanza del servizio.
Nella parte inferiore della pagina fare clic su Avanti: Dimensioni e scala.
In questa pagina selezionare il piano tariffario e il piano di scalabilità ( se si tratta della prima istanza del servizio di hub IoT, dovrebbe essere disponibile un livello gratuito).
Fare clic su Rivedi e crea.
Rivedere le impostazioni e fare clic su Crea.
Quando la notifica viene visualizzata per informare l'utente della corretta creazione del servizio hub IoT, fare clic su Vai alla risorsa per essere reindirizzata alla pagina Servizio.
Scorrere il pannello laterale a sinistra fino a visualizzare Gestione dispositivi automatico, facendo clic su IoT Edge.
Nella finestra visualizzata a destra fare clic su Aggiungi IoT Edge dispositivo. Verrà visualizzato un pannello a destra.
Nel pannello specificare il nuovo dispositivo un ID dispositivo (un nome di propria scelta). Fare quindi clic su Salva. Le chiavi primarie e secondarie verranno generate automaticamente, se la generazione automatica è selezionata.
Si tornerà alla sezione IoT Edge Dispositivi, in cui verrà elencato il nuovo dispositivo. Fare clic sul nuovo dispositivo (evidenziato in rosso nell'immagine seguente).
Nella pagina Dettagli dispositivo visualizzata prendere una copia della stringa di connessione (chiave primaria).
Indietro al pannello a sinistra e fare clic su Criteri di accesso condiviso per aprirlo.
Nella pagina visualizzata fare clic su iothubowner e verrà visualizzato un pannello a destra della schermata.
Prendere nota (nel Blocco note) della stringa di connessione (chiave primaria), per usarla successivamente quando si imposta la stringa di connessione sul dispositivo.

Capitolo 4 - Configurazione dell'ambiente di sviluppo

Per creare e distribuire moduli per hub IoT Edge, sono necessari i componenti seguenti installati nel computer di sviluppo che esegue Windows 10:

Docker per Windows richiederà di creare un account per poter scaricare.

Importante

Per eseguire Docker è necessario Windows 10 PRO, Enterprise 14393 o Windows Server 2016 RTM. Se si eseguono altre versioni di Windows 10, è possibile provare a installare Docker usando la casella degli strumenti Docker.
Python 3.6.
Visual Studio Code (noto anche come VS Code).

Dopo aver installato il software indicato in precedenza, sarà necessario riavviare il computer.

Capitolo 5 - Configurazione dell'ambiente Ubuntu

È ora possibile passare alla configurazione del dispositivo che esegue il sistema operativo Ubuntu. Seguire questa procedura per installare il software necessario per distribuire i contenitori nella scheda:

Importante

È sempre necessario precedere i comandi del terminale con sudo per l'esecuzione come utente amministratore. Ad esempio:

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

Aprire il terminale Ubuntu e usare il comando seguente per installare pip:

[! HINT] È possibile aprire terminale molto facilmente tramite la scelta rapida da tastiera: CTRL+ALT+T.
```
    sudo apt-get install python-pip
```
In questo capitolo potrebbe essere richiesto, dal terminale, l'autorizzazione per usare l'archiviazione del dispositivo e per l'input di y/n (sì o no), digitare "y" e quindi premere INVIO per accettare.
Al termine del comando, usare il comando seguente per installare curl:
```
    sudo apt install curl
```

Dopo aver installato pip e curl, usare il comando seguente per installare il runtime IoT Edge, necessario per distribuire e controllare i moduli nella scheda:

    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

A questo punto verrà richiesto di aprire il file di configurazione di runtime, per inserire la stringa di connessione del dispositivo annotata (nel Blocco note), durante la creazione del servizio hub IoT (al passaggio 14 del capitolo 3). Eseguire la riga seguente nel terminale per aprire il file:
```
    sudo nano /etc/iotedge/config.yaml
```
Verrà visualizzato il file config.yaml , pronto per la modifica:

Avviso

Quando si apre questo file, potrebbe risultare un po' confuso. Il file verrà modificato in testo, all'interno del terminale stesso.
1. Usare i tasti di direzione sulla tastiera per scorrere verso il basso (è necessario scorrere verso il basso un po'), per raggiungere la riga contenente":
  
  "<AGGIUNGI STRINGA DI CONNESSIONE DEL DISPOSITIVO QUI>".
2. Sostituire la riga, incluse le parentesi quadre, con la stringa di connessione del dispositivo annotata in precedenza.
Con la stringa di connessione sul posto, sulla tastiera premere i tasti CTRL-X per salvare il file. Verrà chiesto di confermare digitando Y. Premere quindi INVIO per confermare. Si tornerà al normale Terminale.
Dopo aver eseguito tutti questi comandi, sarà installato il runtime di IoT Edge. Una volta inizializzato, il runtime verrà avviato autonomamente ogni volta che il dispositivo viene acceso e si troverà in background, in attesa che i moduli vengano distribuiti dal servizio hub IoT.
Eseguire la riga di comando seguente per inizializzare il runtime di IoT Edge:
```
    sudo systemctl restart iotedge
```
Importante

Se si apportano modifiche al file con estensione yaml o all'installazione precedente, sarà necessario eseguire nuovamente la riga di riavvio precedente all'interno del terminale.
Controllare lo stato di IoT Edge runtime eseguendo la riga di comando seguente. Il runtime dovrebbe essere visualizzato con lo stato attivo (in esecuzione) in testo verde.
```
    sudo systemctl status iotedge
```
Premere i tasti CTRL+C per uscire dalla pagina di stato. È possibile verificare che il runtime di IoT Edge stia eseguendo correttamente il pull dei contenitori digitando il comando seguente:
```
    sudo docker ps
```
Verrà visualizzato un elenco con due contenitori (2). Si tratta dei moduli predefiniti creati automaticamente dal servizio hub IoT (edgeAgent e edgeHub). Dopo aver creato e distribuito i propri moduli, questi verranno visualizzati in questo elenco, sotto quelli predefiniti.

Capitolo 6 - Installare le estensioni

Importante

I successivi capitoli (6-9) devono essere eseguiti sul computer Windows 10.

Aprire VS Code.
Fare clic sul pulsante Estensioni (quadrato) sulla barra sinistra di VS Code per aprire il pannello Estensioni.
Cercare e installare le estensioni seguenti (come illustrato nell'immagine seguente):
1. Azure IoT Edge
2. Azure IoT Toolkit
3. Docker
Dopo aver installato le estensioni, chiudere e riaprire VS Code.
Con VS Code aperto ancora una volta, passare a Visualizza>terminale integrato.
Ora installerai Cookiecutter. Nel terminale eseguire il comando bash seguente:
```
    pip install --upgrade --user cookiecutter
```
[! HINT] Se si verificano problemi con questo comando:
1. Riavviare VS Code e/o il computer.
2. Potrebbe essere necessario passare il terminale di VS Code a quello usato per installare Python, ad esempio PowerShell (soprattutto nel caso in cui l'ambiente Python sia già installato nel computer). Con il terminale aperto, troverai il menu a discesa sul lato destro del terminale.
3. Assicurarsi che il percorso di installazione di Python venga aggiunto come Variabile di ambiente nel computer. Cookiecutter deve far parte dello stesso percorso. Per altre informazioni sulle variabili di ambiente, seguire questo collegamento.
Al termine dell'installazione di Cookiecutter , è necessario riavviare il computer, in modo che Cookiecutter venga riconosciuto come comando, all'interno dell'ambiente del sistema.

Capitolo 7: Creare la soluzione contenitore

A questo punto, è necessario creare il contenitore, con il modulo , di cui eseguire il push nel Registro Contenitori. Dopo aver eseguito il push del contenitore, si userà il servizio edge di hub IoT per distribuirlo nel dispositivo, che esegue il runtime IoT Edge.

In VISUAL Studio Code fare clic sulriquadro comandiVisualizza>.
Nella tavolozza cercare ed eseguire Azure IoT Edge: Nuova soluzione Iot Edge.
Passare a un percorso in cui si vuole creare la soluzione. Premere INVIO per accettare la posizione.
Assegnare un nome alla soluzione. Premere INVIO per confermare il nome specificato.
Verrà ora richiesto di scegliere il framework del modello per la soluzione. Fare clic su Modulo Python. Premere INVIO per confermare questa scelta.
Assegnare un nome al modulo. Premere INVIO per confermare il nome del modulo. Assicurarsi di prendere nota (con il Blocco note) del nome del modulo, come viene usato in un secondo momento.
Si noterà che nella tavolozza verrà visualizzato un indirizzo del repository di immagini Docker predefinito. Sarà simile al seguente:

localhost:5000/-IL NOME DEL MODULO.LOCALHOST:5000/-THE NAME OF YOUR MODULE-.
Eliminare localhost:5000 e al suo posto inserire l'indirizzo del server di accessodel Registro Container, annotato durante la creazione del servizio Registro Contenitori (nel passaggio 8 del capitolo 2). Premere INVIO per confermare l'indirizzo.
A questo punto, verrà creata la soluzione contenente il modello per il modulo Python e la relativa struttura verrà visualizzata nella scheda Esplora di VISUAL Studio Code sul lato sinistro della schermata. Se la scheda Esplora non è aperta, è possibile aprirla facendo clic sul pulsante più in alto, nella barra a sinistra.
L'ultimo passaggio per questo capitolo consiste nel fare clic e aprire il file con estensione env all'interno della scheda Esplora e aggiungere il nome utente e la passworddel Registro Container. Questo file viene ignorato da Git, ma durante la compilazione del contenitore, imposterà le credenziali per accedere al servizio Registro Container.

Capitolo 8 - Modifica della soluzione contenitore

La soluzione contenitore verrà completata aggiornando i file seguenti:

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

Si creerà quindi la cartella images, usata dallo script Python per verificare la presenza di immagini corrispondenti al modello di Visione personalizzata. Infine, si aggiungerà il file labels.txt , per leggere il modello e il file model.pb , ovvero il modello.

Con VS Code aperto, passare alla cartella del modulo e cercare lo script denominato main.py. Fare doppio clic per aprirlo.

Eliminare il contenuto del file e inserire il codice seguente:

# 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)

Aprire il file denominato requirements.txte sostituirlo con quanto segue:

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

Aprire il file denominato deployment.template.json e sostituirlo seguendo le linee guida seguenti:
1. Poiché si avrà una struttura JSON univoca e personalizzata, sarà necessario modificarla manualmente anziché copiare un esempio. Per semplificare questa operazione, usare l'immagine seguente come guida.
2. Aree che avranno un aspetto diverso da quello dell'utente, ma che non è consigliabile modificare sono evidenziate in giallo.
3. Le sezioni che è necessario eliminare sono un rosso evidenziato.
4. Prestare attenzione a eliminare le parentesi quadre corrette e rimuovere anche le virgole.
5. Il codice JSON completato avrà un aspetto simile all'immagine seguente( tuttavia, con le differenze univoche: nome utente/password/nome modulo/riferimenti al modulo):

Aprire il file denominato Dockerfile.amd64 e sostituirlo con quanto segue:

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" ]

Fare clic con il pulsante destro del mouse sulla cartella sottostante i moduli (il nome specificato in precedenza sarà il nome specificato in precedenza; nell'esempio è denominato pythonmodule) e fare clic su Nuova cartella. Assegnare un nome alle immagini della cartella.
All'interno della cartella aggiungere alcune immagini contenenti mouse o tastiera. Queste saranno le immagini che verranno analizzate dal modello Tensorflow.

Avviso

Se si usa un modello personalizzato, sarà necessario modificarlo in modo da riflettere i propri dati dei modelli.
Sarà ora necessario recuperare i filelabels.txt e model.pb dalla cartella del modello, che in precedenza è stata scaricata (o creata dal proprio servizio di Visione personalizzata), nel capitolo 1. Dopo aver creato i file, inserirli all'interno della soluzione, insieme agli altri file. Il risultato finale dovrebbe essere simile all'immagine seguente:

Capitolo 9 - Creare un pacchetto della soluzione come contenitore

È ora possibile "creare il pacchetto" dei file come contenitore ed eseguirne il push nel Registro Azure Container. In VS Code aprire il terminale integrato (Visualizza>terminale integrato o CTRL+`) e usare la riga seguente per accedere a Docker (sostituire i valori del comando con le credenziali del Registro Azure Container (Registro Azure Container)):
```
    docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Fare clic con il pulsante destro del mouse sul file deployment.template.json e scegliere Compila IoT Edge soluzione. Questo processo di compilazione richiede molto tempo (a seconda del dispositivo), quindi è possibile prepararsi ad attendere. Al termine del processo di compilazione, verrà creato un file deployment.json all'interno di una nuova cartella denominata config.
Aprire di nuovo il riquadro comandi e cercare Azure: Accedi. Seguire le istruzioni usando le credenziali dell'account di Azure; VS Code offre un'opzione per copiare e aprire il codice del dispositivo che sarà presto necessario e aprire il Web browser predefinito. Quando richiesto, incollare il codice del dispositivo per autenticare il computer.
Dopo aver eseguito l'accesso, nella parte inferiore del pannello Esplora, verrà visualizzata una nuova sezione denominata dispositivi hub IoT di Azure. Fare clic su questa sezione per espanderla.
Se il dispositivo non è qui, è necessario fare clic con il pulsante destro del mouse su dispositivi hub IoT di Azure e quindi scegliere Imposta hub IoT stringa di connessione. Si noterà quindi che il riquadro comandi (nella parte superiore di VS Code), richiederà di immettere la stringa di connessione. Si tratta della stringa di connessione annotata alla fine del capitolo 3. Premere INVIO , dopo aver copiato la stringa.
Il dispositivo deve caricare e visualizzare. Fare clic con il pulsante destro del mouse sul nome del dispositivo e quindi scegliere Crea distribuzione per singolo dispositivo.
Verrà visualizzato un prompt Esplora file, in cui è possibile passare alla cartella di configurazione e quindi selezionare il file deployment.json. Con tale file selezionato, fare clic sul pulsante Seleziona manifesto distribuzione edge .
A questo punto è stato fornito al servizio di hub IoT il manifesto per la distribuzione del contenitore, come modulo, dall'Registro Azure Container, distribuirlo in modo efficace nel dispositivo.
Per visualizzare i messaggi inviati dal dispositivo all'hub IoT, fare di nuovo clic con il pulsante destro del mouse sul nome del dispositivo nella sezione Dispositivi di hub IoT di Azure, nel pannello Esplora risorse e fare clic su Avvia monitoraggio messaggio D2C. I messaggi inviati dal dispositivo devono essere visualizzati nel terminale VS. Essere paziente, perché potrebbe richiedere qualche tempo. Vedere il capitolo successivo per il debug e verificare se la distribuzione è riuscita.

Questo modulo eseguirà ora l'iterazione tra le immagini nella cartella immagini e analizzarle, con ogni iterazione. Questo è ovviamente solo una dimostrazione di come ottenere il modello di Machine Learning di base per funzionare in un ambiente del dispositivo IoT Edge.

Per espandere la funzionalità di questo esempio, è possibile procedere in diversi modi. Un modo può essere incluso un codice nel contenitore, che acquisisce foto da una webcam connessa al dispositivo e salva le immagini nella cartella immagini.

Un altro modo potrebbe copiare le immagini dal dispositivo IoT nel contenitore. Un modo pratico per eseguire questo comando nel terminale del dispositivo IoT (forse una piccola app potrebbe eseguire il processo, se si vuole automatizzare il processo). È possibile testare questo comando eseguendolo manualmente dal percorso della cartella in cui vengono archiviati i file:

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

Capitolo 10 - Debug del runtime di IoT Edge

Di seguito è riportato un elenco di righe di comando e suggerimenti per consentire di monitorare e eseguire il debug dell'attività di messaggistica del runtime di IoT Edge dal dispositivo Ubuntu.

Controllare lo stato di IoT Edge runtime eseguendo la riga di comando seguente:
```
    sudo systemctl status iotedge
```
Nota

Ricordarsi di premere CTRL + C per completare la visualizzazione dello stato.
Elencare i contenitori attualmente distribuiti. Se il servizio hub IoT ha distribuito correttamente i contenitori, verranno visualizzati eseguendo la riga di comando seguente:
```
    sudo iotedge list
```
Oppure
```
    sudo docker ps
```
Nota

L'esempio precedente è un buon modo per verificare se il modulo è stato distribuito correttamente, come verrà visualizzato nell'elenco; in caso contrario, verrà visualizzato soloedgeHub e edgeAgent.
Per visualizzare i log di codice di un contenitore, eseguire la riga di comando seguente:
```
    journalctl -u iotedge
```

Comandi utili per gestire il runtime di IoT Edge:

Per eliminare tutti i contenitori nell'host:

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

Per arrestare il runtime di IoT Edge:
```
    sudo systemctl stop iotedge
```

Capitolo 11 - Creare servizio tabelle

Tornare al portale di Azure, in cui si creerà un servizio tabelle di Azure creando una risorsa di archiviazione.

Se non è già stato eseguito l'accesso, accedere al portale di Azure.
Dopo aver eseguito l'accesso, fare clic su Crea una risorsa, nell'angolo in alto a sinistra e cercare l'account di archiviazione e premere INVIO per avviare la ricerca.
Dopo aver visualizzato, fare clic su Account di archiviazione: BLOB, file, tabella, coda dall'elenco.
La nuova pagina fornisce una descrizione del servizio account di archiviazione . Nella parte inferiore sinistra del prompt fare clic sul pulsante Crea per creare un'istanza di questo servizio.
Dopo aver fatto clic su Crea, verrà visualizzato un pannello:
1. Inserire il nome desiderato per questa istanza del servizio (deve essere tutto minuscolo).
2. Per Modello di distribuzione fare clic su Resource Manager.
3. Per Tipo di account, usando il menu a discesa, fare clic su Archiviazione (utilizzo generico v1).
4. Fare clic su Una posizione appropriata.
5. Per il menu a discesa Replica, fare clic su Archiviazione con ridondanza geografica di lettura (RA-GRS).
6. Per Prestazioni fare clic su Standard.
7. Nella sezione Trasferimento sicuro obbligatorio fare clic su Disabilitato.
8. Dal menu a discesa Sottoscrizione fare clic su una sottoscrizione appropriata.
9. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, il provisioning e la gestione, la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio questi corsi) in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, seguire questo collegamento su come gestire un gruppo di risorse.
10. Lasciare disabilitate le reti virtuali, se si tratta di un'opzione.
11. Fare clic su Crea.
Dopo aver fatto clic su Crea, sarà necessario attendere che il servizio venga creato, potrebbe richiedere un minuto.
Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio. Fare clic sulle notifiche per esplorare la nuova istanza del servizio.
Fare clic sul pulsante Vai alla risorsa nella notifica e verrà visualizzata la pagina di panoramica della nuova istanza del servizio di archiviazione.
Nella pagina di panoramica fare clic su Tabelle sul lato destro.
Il pannello a destra verrà modificato per visualizzare le informazioni sul servizio tabelle , in cui è necessario aggiungere una nuova tabella. Fare clic sul pulsante + Tabella nell'angolo superiore sinistro.
Verrà visualizzata una nuova pagina, in cui è necessario immettere un nome tabella. Questo è il nome che si userà per fare riferimento ai dati dell'applicazione nei capitoli successivi (creazione di app per le funzioni e Power BI). Inserire IoTMessages come nome (è possibile scegliere il proprio, solo ricordarlo quando usato più avanti in questo documento) e fare clic su OK.
Dopo aver creato la nuova tabella, sarà possibile visualizzarla all'interno della pagina servizio tabelle (in basso).
Fare clic su Chiavi di accesso e prendere una copia del nome e della chiavedell'account di archiviazione (usando il blocco note), si useranno questi valori più avanti in questo corso, quando si crea l'app per le funzioni di Azure.
Usando di nuovo il pannello a sinistra, scorrere fino alla sezione Serviziotabelle e fare clic su Tabelle (o Sfoglia tabelle, nei portali più recenti) e prendere una copia dell'URL tabella (usando il blocco note). Questo valore verrà usato più avanti in questo corso, quando si collega la tabella all'applicazione Power BI .

Capitolo 12 - Completamento della tabella di Azure

Ora che l'account di archiviazione del servizio tabelle è stato configurato, è ora di aggiungere dati a esso, che verranno usati per archiviare e recuperare informazioni. La modifica delle tabelle può essere eseguita tramite Visual Studio.

Aprire Visual Studio (non Visual Studio Code).
Dal menu fare clic su Visualizza>Cloud Explorer.
Cloud Explorer verrà aperto come elemento ancorato (essere paziente, perché il caricamento potrebbe richiedere tempo).
Avviso

Se la sottoscrizione usata per creare gli account di archiviazione non è visibile, assicurarsi di avere:
- Accesso allo stesso account usato per il portale di Azure.
- È stata selezionata la sottoscrizione dalla pagina Gestione account (potrebbe essere necessario applicare un filtro dalle impostazioni dell'account):
Verranno visualizzati i servizi cloud di Azure. Trovare Account di archiviazione e fare clic sulla freccia a sinistra di tale account per espandere gli account.
Una volta espansa, l'account di archiviazione appena creato dovrebbe essere disponibile. Fare clic sulla freccia a sinistra della risorsa di archiviazione e quindi, una volta espansa, trovare Tabelle e fare clic sulla freccia accanto a questa per visualizzare la tabella creata nell'ultimo capitolo. Fare doppio clic sulla tabella.
La tabella verrà aperta al centro della finestra di Visual Studio. Fare clic sull'icona della tabella con il + segno più.
Verrà visualizzata una finestra che richiede di aggiungere un'entità. Verrà creata una sola entità, anche se avrà tre proprietà. Si noterà che PartitionKey e RowKey sono già disponibili, perché vengono usati dalla tabella per trovare i dati.
Aggiornare i valori seguenti:
- Nome: PartitionKey, Valore: PK_IoTMessages
- Nome: RowKey, Value: RK_1_IoTMessages
Fare quindi clic su Aggiungi proprietà (in basso a sinistra della finestra Aggiungi entità ) e aggiungere la proprietà seguente:
- MessageContent, come stringa, lasciare vuoto Il valore.
La tabella deve corrispondere a quella nell'immagine seguente:

Nota

Il motivo per cui l'entità ha il numero 1 nella chiave di riga è perché potrebbe essere necessario aggiungere altri messaggi, se si desidera sperimentare ulteriormente questo corso.
Al termine, fare clic su OK . La tabella è ora pronta per essere usata.

Capitolo 13 : Creare un'app per le funzioni di Azure

È ora possibile creare un'app per le funzioni di Azure, che verrà chiamata dal servizio hub IoT per archiviare i messaggi del dispositivo IoT Edge nel servizio tabelle creato nel capitolo precedente.

Prima di tutto, è necessario creare un file che consentirà alla funzione di Azure di caricare le librerie necessarie.

Aprire il Blocco note (premere il tasto Windows e digitare blocco note).
Con Blocco note aperto, inserire la struttura JSON sottostante. Al termine, salvarlo sul desktop come project.json. Questo file definisce le librerie che verrà usata dalla funzione. Se è stato usato NuGet, avrà un aspetto familiare.

Avviso

È importante che la denominazione sia corretta; assicurarsi che non abbia un'estensione di file .txt . Per informazioni di riferimento, vedere di seguito:
```
{
"frameworks": {
    "net46":{
    "dependencies": {
        "WindowsAzure.Storage": "9.2.0"
    }
    }
}
}
```
Accedere al portale di Azure.
Dopo aver eseguito l'accesso, fare clic su Crea una risorsa nell'angolo in alto a sinistra e cercare App per le funzioni e premere INVIO per eseguire la ricerca. Fare clic su App per le funzioni nei risultati per aprire un nuovo pannello.
Il nuovo pannello fornirà una descrizione del servizio app per le funzioni. Nella parte inferiore sinistra di questo pannello fare clic sul pulsante Crea per creare un'associazione con questo servizio.
Dopo aver fatto clic su Crea, compilare quanto segue:
1. Per Nome app inserire il nome desiderato per questa istanza del servizio.
2. Selezionare una Sottoscrizione.
3. Selezionare il piano tariffario appropriato, se questa è la prima volta che si crea una funzione servizio app, dovrebbe essere disponibile un livello gratuito.
4. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, il provisioning e la gestione, la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto ,ad esempio questi corsi, in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, seguire questo collegamento su come gestire un gruppo di risorse.
5. Per il sistema operativo, fare clic su Windows, come indicato nella piattaforma desiderata.
6. Selezionare un piano di hosting (questa esercitazione usa un piano a consumo).
7. Selezionare un percorso (scegliere la stessa posizione dello spazio di archiviazione creato nel passaggio precedente)
8. Per la sezione Archiviazione è necessario selezionare il servizio di archiviazione creato nel passaggio precedente.
9. Non sarà necessario Application Insights in questa app, quindi è possibile lasciarlo disattivato.
10. Fare clic su Crea.
Dopo aver fatto clic su Crea, è necessario attendere che il servizio venga creato, l'operazione potrebbe richiedere un minuto.
Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio.
Fare clic sulla notifica al termine della distribuzione (completata).
Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio.
Nel lato sinistro del nuovo pannello fare clic sull'icona + (più) accanto a Funzioni per creare una nuova funzione.
All'interno del pannello centrale verrà visualizzata la finestra Di creazione della funzione . Scorrere verso il basso verso il basso e fare clic su Funzione personalizzata.
Scorrere verso il basso la pagina successiva fino a trovare hub IoT (Hub eventi) e quindi fare clic su di esso.
Nel pannello hub IoT (Hub eventi) impostare Il linguaggio su C# e quindi fare clic su nuovo.
Nella finestra visualizzata assicurarsi che hub IoT sia selezionato e che il nome del campo hub IoT corrisponda al nome del servizio hub IoT creato in precedenza (nel passaggio 8 del capitolo 3). Fare quindi clic sul pulsante Seleziona .
Nel pannello hub IoT (Hub eventi) fare clic su Crea.
Si verrà reindirizzati all'editor di funzioni.

Eliminare tutto il codice in esso contenuto e sostituirlo con quanto segue:

#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; }   
}

Modificare le variabili seguenti in modo che corrispondano ai valori appropriati (valori di tabella e archiviazione , rispettivamente dal passaggio 11 e 13 del capitolo 11), che saranno disponibili nell'account di archiviazione:
- tableName, con il nome della tabella che si trova nell'account di archiviazione.
- tableURL, con l'URL della tabella che si trova nell'account di archiviazione.
- storageAccountName, con il nome del valore corrispondente al nome dell'account di archiviazione .
- storageAccountKey, con la chiave ottenuta nel servizio di archiviazione creata in precedenza.
Con il codice sul posto, fare clic su Salva.
Fare quindi clic sull'icona < (freccia) sul lato destro della pagina.
Un pannello scorrerà da destra. In tale pannello fare clic su Carica e verrà visualizzato un visualizzatore file .
Passare a e fare clic sul file project.json creato in precedenza nel Blocco note e quindi sul pulsante Apri . Questo file definisce le librerie che verranno usate dalla funzione.
Quando il file è stato caricato, verrà visualizzato nel pannello a destra. Facendo clic su di esso, verrà aperto nell'editor di funzioni . Deve essere esattamente uguale all'immagine successiva.
A questo punto è consigliabile testare la funzionalità della funzione per archiviare il messaggio nella tabella. Sul lato superiore destro della finestra fare clic su Test.
Inserire un messaggio nel corpo della richiesta, come illustrato nell'immagine precedente e fare clic su Esegui.
La funzione verrà eseguita, visualizzando lo stato del risultato (si noterà lo stato verde 202 Accettato, sopra la finestra Output , che significa che è stata una chiamata riuscita):

Capitolo 14 - Visualizzare i messaggi attivi

Se si apre Visual Studio (non Visual Studio Code), è possibile visualizzare il risultato del messaggio di test, perché verrà archiviato nell'area stringa MessageContent .

Screenshot che mostra la scheda Tabella messaggi I O T aperta in Microsoft Visual Studio.

Con il servizio tabelle e l'app per le funzioni sul posto, i messaggi del dispositivo Ubuntu verranno visualizzati nella tabella IoTMessages . Se non è già in esecuzione, avviare di nuovo il dispositivo e sarà possibile visualizzare i messaggi dei risultati dal dispositivo e il modulo, all'interno della tabella, tramite Visual Studio Cloud Explorer.

visualizzare i dati

Capitolo 15 - Installazione di Power BI

Per visualizzare i dati dal dispositivo IOT, si configura Power BI (versione desktop), per raccogliere i dati dal servizio tabelle appena creato. La versione di HoloLens di Power BI userà quindi tali dati per visualizzare il risultato.

Aprire il Microsoft Store in Windows 10 e cercare Power BI Desktop.
Scaricare l'applicazione. Al termine del download, aprirlo.
Accedere a Power BI con l'account Microsoft 365. È possibile che venga reindirizzato a un browser per iscriversi. Dopo aver effettuato l'iscrizione, tornare all'app Power BI e accedere di nuovo.
Fare clic su Recupera dati e quindi fare clic su Altro....
Fare clic su Azure, Archiviazione tabelle di Azure, quindi fare clic su Connetti.
Verrà richiesto di inserire l'URL tabella raccolto in precedenza (nel passaggio 13 del capitolo 11), durante la creazione del servizio tabelle. Dopo aver inserito l'URL, eliminare la parte del percorso che fa riferimento alla tabella "sottocartella" (ovvero IoTMessages, in questo corso). Il risultato finale deve essere visualizzato nell'immagine seguente. Fare quindi clic su OK.
Verrà richiesto di inserire la chiave di archiviazione annotata (nel passaggio 11 del capitolo 11) in precedenza durante la creazione dell'archiviazione tabelle. Fare quindi clic su Connetti.
Verrà visualizzato un pannello di navigazione , selezionare la casella accanto alla tabella e fare clic su Carica.
La tabella è stata ora caricata in Power BI, ma richiede una query per visualizzare i valori in esso contenuti. A tale scopo, fare clic con il pulsante destro del mouse sul nome della tabella che si trova nel pannello FIELDS sul lato destro della schermata. Fare quindi clic su Modifica query.
Un editor di Power Query aprirà come nuova finestra, visualizzando la tabella. Fare clic sulla parola Record nella colonna Contenuto della tabella per visualizzare il contenuto archiviato.
Fare clic su In Tabella, nella parte superiore sinistra della finestra.
Fare clic su Chiudi & Applica.
Al termine del caricamento della query, all'interno del pannello FIELDS, sul lato destro della schermata, selezionare le caselle corrispondenti ai parametri Nome e Valore per visualizzare il contenuto della colonna MessageContent .
Fare clic sull'icona del disco blu nella parte superiore sinistra della finestra per salvare il lavoro in una cartella di propria scelta.
È ora possibile fare clic sul pulsante Pubblica per caricare la tabella nell'area di lavoro. Quando richiesto, fare clic su Area di lavoro personale e fare clic su Seleziona. Attendere che venga visualizzato il risultato positivo dell'invio.

Avviso

Il capitolo seguente è Specifico di HoloLens. Power BI non è attualmente disponibile come applicazione immersiva, ma è possibile eseguire la versione desktop nel portale di Windows Mixed Reality (aka Cliff House), tramite l'app Desktop.

Capitolo 16 - Visualizzare i dati di Power BI in HoloLens

In HoloLens accedere a Microsoft Store toccando l'icona nell'elenco delle applicazioni.
Cercare e scaricare l'applicazione Power BI .
Avviare Power BI dall'elenco delle applicazioni.
Power BI potrebbe chiedere di accedere all'account Microsoft 365.
Una volta all'interno dell'app, l'area di lavoro deve essere visualizzata per impostazione predefinita, come illustrato nell'immagine seguente. In caso contrario, fare clic sull'icona dell'area di lavoro a sinistra della finestra.

L'applicazione hub IoT completata

Congratulazioni, è stato creato correttamente un servizio hub IoT, con un dispositivo Virtual Machine Edge simulato. Il dispositivo può comunicare i risultati di un modello di Machine Learning a un servizio tabelle di Azure, facilitato da un'app per le funzioni di Azure, che viene letto in Power BI e visualizzato all'interno di un Microsoft HoloLens.

Visualizzazione Holo Lens che mostra la pagina Microsoft Power B I.

Esercizi aggiuntivi

Esercizio 1

Espandere la struttura di messaggistica archiviata nella tabella e visualizzarla come grafico. È possibile raccogliere più dati e archiviarlo nella stessa tabella, da visualizzare in un secondo momento.

Esercizio 2

Creare un modulo "acquisizione fotocamera" aggiuntivo da distribuire nella scheda IoT, in modo da poter acquisire immagini tramite la fotocamera da analizzare.