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

Nota

Le esercitazioni di Realtà mista Academy sono state progettate tenendo presente HoloLens (prima generazione) e Realtà mista visori vr immersive. Di conseguenza, riteniamo importante lasciare in vigore queste esercitazioni per gli sviluppatori che sono ancora alla ricerca di indicazioni per lo sviluppo di tali dispositivi. Queste esercitazioni non vengono aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Vengono mantenuti per continuare a lavorare sui dispositivi supportati. Ci sarà una nuova serie di esercitazioni che verranno pubblicate in futuro che dimostrano come sviluppare per HoloLens 2. Questa notifica viene aggiornata con un collegamento a tali esercitazioni quando vengono pubblicate.

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. Viene quindi usata un'app per le funzioni Azure per ricevere messaggi dalla macchina virtuale Ubuntu e archiviare il risultato all'interno di un servizio tabelle Azure. È quindi possibile visualizzare questi dati usando Power BI in visore vr (VR) Microsoft HoloLens o immersive.

Il contenuto di questo corso è applicabile ai dispositivi IoT Edge. Anche se in questo corso, l'attenzione si concentra su un ambiente di macchina virtuale, 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 (Ubuntu 16 OS), che rappresenta il dispositivo IoT.
Aggiungere un modello tensorflow Azure Visione personalizzata al modulo Edge, con codice che analizza le immagini archiviate nel contenitore.
Configurare il modulo per inviare nuovamente il messaggio dei risultati dell'analisi al servizio hub IoT.
Usare un'app per le funzioni Azure per archiviare il messaggio all'interno di una tabella Azure.
Configurare Power BI per raccogliere il messaggio archiviato e creare un report.
Visualizzare i dati dei messaggi IoT in Power BI.

I servizi che verranno usati includono:

hub IoT di Azure è un servizio 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 microsoft Azure, che consente agli sviluppatori di archiviare immagini di contenitori, per vari tipi di contenitori. Per altre informazioni, visitare la pagina del servizio Registro Azure Container.
Azure App per le funzioni è un servizio microsoft Azure, che consente agli sviluppatori di eseguire piccole parti di codice, "funzioni", in Azure. Offre un modo per 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 Azure: le tabelle sono un servizio microsoft Azure, che consente agli sviluppatori di archiviare dati strutturati e non SQL nel cloud, rendendoli facilmente accessibili ovunque. Il servizio vanta una progettazione senza schema, che consente l'evoluzione delle tabelle in base alle esigenze e pertanto è flessibile. Per altre informazioni, visitare la pagina Azure Tabelle

Questo corso illustra come configurare e usare il servizio hub IoT e quindi visualizzare una risposta fornita da un dispositivo. Spetta all'utente applicare questi concetti a una configurazione personalizzata del servizio hub IoT, che potrebbe essere in esecuzione.

Supporto dei 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, incluso il Microsoft HoloLens, vedere l'articolo Installare gli strumenti.

Nota

Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Python. Anche i prerequisiti e le istruzioni scritte all'interno di questo documento rappresentano ciò che viene testato e verificato al momento della scrittura (luglio 2018). È possibile usare il software più recente, come indicato nell'articolo installare gli strumenti , anche se non si dovrebbe presumere che le informazioni contenute in questo corso corrispondano perfettamente a quelle disponibili nel software più recente rispetto a quelle elencate di seguito.

Sono necessari l'hardware e il 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 alla Azure Cloud Explorer)
Accesso a Internet per Azure e per il servizio hub IoT. Per altre informazioni, seguire questo collegamento alla pagina del servizio hub IoT
Modello di Machine Learning. Se non si ha il proprio modello 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). Altre informazioni su come creare una macchina virtuale in Windows usando Hyper-V sono disponibili nel capitolo "Prima di iniziare".

Prima di iniziare

Configurare e testare HoloLens. Se hai bisogno del supporto per la configurazione di HoloLens, assicurati di visitare l'articolo Configurazione di HoloLens.
È consigliabile eseguire calibrazione e ottimizzazione dei sensori quando si inizia a sviluppare una nuova app HoloLens (a volte può essere utile per eseguire tali attività per ogni utente).

Per informazioni sulla calibrazione, seguire questo collegamento all'articolo Calibrazione holoLens.

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

Configurare la macchina virtuale Ubuntu usando Hyper-V. Le risorse seguenti consentono di eseguire il processo.
1. Per prima cosa, seguire questo collegamento per scaricare l'ISO Ubuntu 16.04.4 LTS (Xenial Xerus). Selezionare l'immagine desktop del PC a 64 bit (AMD64).
2. Verificare che Hyper-V sia abilitato nel computer Windows 10. È possibile seguire questo collegamento per indicazioni 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 viene richiesto di "Installare un sistema operativo da un file di immagine avviabile", selezionare l'ISO Ubuntu scaricato in precedenza.
Nota

L'uso della creazione rapida di Hyper-V non è consigliato.

Capitolo 1 - Recuperare il modello di Visione personalizzata

Con questo corso è possibile accedere a un modello di Visione personalizzata predefinito che rileva tastiere e mouse dalle immagini. Se lo si usa, passare al capitolo 2.

Tuttavia, è possibile seguire questa procedura se si vuole usare un modello di Visione personalizzata personalizzato:

Nel progetto Visione personalizzata passare alla scheda Prestazioni.

Avviso

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

Capitolo 2 - Servizio Registro Contenitori

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

Il servizio hub IoT compilato e usato in questo corso si riferisce al servizio Registro contenitori per ottenere i contenitori da distribuire nel dispositivo Edge.

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 denominato IoTCRegistry.
2. 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 Azure. È consigliabile mantenere tutti i servizi 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.
Dopo che la notifica viene visualizzata per informare l'utente della corretta creazione del Registro Contenitori, fare clic su Vai alla risorsa per essere reindirizzato alla pagina Del servizio.
Nella pagina Servizio Registro contenitori fare clic su Chiavi di accesso.
Prendere nota (è possibile usare il Blocco note) dei parametri seguenti:
1. Server di accesso
2. Username
3. Password

Capitolo 3 - Il servizio hub IoT

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

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

Screenshot che mostra la finestra Tutto aperta. I O T Hub nei risultati della ricerca e Crea una risorsa nell'angolo in alto a sinistra sono cerchiati in rosso.

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, viene 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 Azure. È consigliabile mantenere tutti i servizi Azure associati a un singolo progetto ,ad esempio questi corsi, in un gruppo di risorse comune.
  
  Per altre informazioni su Azure gruppi di risorse, 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 l'istanza del servizio.
Nella parte inferiore della pagina fare clic su Avanti: Dimensioni e scala.
In questa pagina selezionare il piano tariffario e di scalabilità (se si tratta della prima istanza del servizio hub IoT, dovrebbe essere disponibile un livello gratuito.
Fare clic su Rivedi e crea.
Esaminare le impostazioni e fare clic su Crea.
Dopo che la notifica viene visualizzata per informare l'utente della corretta creazione del servizio hub IoT, fare clic su Vai alla risorsa per essere reindirizzati alla pagina Del servizio.
Scorrere il pannello laterale a sinistra finché non viene visualizzata la Gestione dispositivi automatica, facendo clic su IoT Edge.
Nella finestra visualizzata a destra fare clic su Aggiungi IoT Edge dispositivo. A destra viene visualizzato un pannello.
Nel pannello specificare al nuovo dispositivo un ID dispositivo (un nome di propria scelta). Fare quindi clic su Salva. Le chiavi primarie e secondarie vengono generate automaticamente se la generazione automatica è stata selezionata.
Tornare alla sezione IoT Edge Dispositivi, in cui è elencato il nuovo dispositivo. Fare clic sul nuovo dispositivo (descritto in rosso nell'immagine seguente).
Nella pagina Dettagli dispositivo visualizzata accettare una copia della stringa di connessione (chiave primaria).
Per aprirlo, tornare al pannello a sinistra e fare clic su Criteri di accesso condiviso.
Nella pagina visualizzata fare clic su iothubowner e a destra dello schermo viene visualizzato un pannello.
Prendere nota (nel Blocco note) della stringa di connessione (chiave primaria) per usarla in un secondo momento 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 in esecuzione Windows 10:

Docker per Windows, ti chiede di creare un account per poter scaricare.

Importante

Docker richiede l'esecuzione di 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

A questo punto è possibile passare alla configurazione del dispositivo che esegue il sistema operativo Ubuntu. Seguire la procedura per installare il software necessario per distribuire i contenitori nella scheda:

Importante

È consigliabile anteporre sempre i comandi del terminale con sudo per l'esecuzione come utente amministratore. Cioè:

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

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

[! HINT] È possibile aprire terminale molto facilmente usando i tasti di scelta rapida: CTRL + ALT + T.
```
    sudo apt-get install python-pip
```
In questo capitolo, il Terminale potrebbe richiedere l'autorizzazione per l'uso dell'archiviazione del dispositivo e per l'immissione 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 di IoT Edge, è necessario 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 viene richiesto di aprire il file di configurazione di runtime, di 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 sul terminale per aprire il file:
```
    sudo nano /etc/iotedge/config.yaml
```
Viene visualizzato il file config.yaml , pronto per la modifica:

Avviso

Quando questo file viene aperto, potrebbe creare confusione. Si sta modificando il testo di questo file, all'interno del terminale stesso.
1. Usare i tasti di direzione sulla tastiera per scorrere verso il basso (è necessario scorrere verso il basso), per raggiungere la linea 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.
Dopo aver inserito la stringa di connessione, premere i tasti CTRL-X per salvare il file. Viene richiesto di confermare digitando Y. Premere quindi INVIO per confermare. Si torna al terminale normale.
Dopo aver eseguito tutti questi comandi, sarà stato installato il runtime di IoT Edge. Dopo l'inizializzazione, il runtime viene avviato autonomamente ogni volta che il dispositivo viene alimentato e si siede in background, in attesa della distribuzione dei moduli 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 yaml o al programma di installazione precedente, è necessario eseguire di nuovo il comando della riga di riavvio, all'interno del terminale.
Controllare lo stato 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 eservi correttamente i contenitori digitando il comando seguente:
```
    sudo docker ps
```
Verrà visualizzato un elenco con due (2) contenitori. Si tratta dei moduli predefiniti creati automaticamente dal servizio hub IoT (edgeAgent e edgeHub). Dopo aver creato e distribuito moduli personalizzati, questi vengono visualizzati in questo elenco, sotto quelli predefiniti.

Capitolo 6 - Installare le estensioni

Importante

I capitoli successivi (6-9) devono essere eseguiti nel 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 possibile installare Cookiecutter. Nel terminale eseguire il comando bash seguente:
```
    pip install --upgrade --user cookiecutter
```
[! HINT] In caso di problemi con questo comando:
1. Riavviare VS Code e/o il computer.
2. Potrebbe essere necessario passare da Vs Code Terminal a quello usato per installare Python, ad esempio PowerShell (soprattutto nel caso in cui l'ambiente Python fosse già installato nel computer). Con il Terminale aperto, troverai il menu a discesa sul lato destro del Terminale.
3. Verificare che il percorso di installazione di Python sia stato 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, per eseguire il push nel Registro Contenitori. Dopo aver eseguito il push del contenitore, usare il servizio hub IoT Edge per distribuirlo nel dispositivo, che esegue il runtime IoT Edge.

In Visual Studio Code fare clic su Visualizza>riquadro comandi.
Nella tavolozza cercare ed eseguire Azure IoT Edge: Nuova soluzione Iot Edge.
Individuare una posizione 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.
A questo momento viene 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 verrà usato in seguito.
Si noterà che nella tavolozza viene visualizzato un indirizzo predefinito del repository di immagini Docker . L'aspetto è simile al seguente:

localhost:5000/-NOME DEL MODULO-.
Eliminare localhost:5000 e inserire al suo posto l'indirizzo del server di accesso del Registro Contenitori, annotato durante la creazione del servizio Registro Contenitori (nel passaggio 8 del capitolo 2). Premere INVIO per confermare l'indirizzo.
A questo punto, viene creata la soluzione contenente il modello per il modulo Python e la relativa struttura viene visualizzata nella scheda Esplora di VS Code sul lato sinistro dello schermo. 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 dall'interno della scheda Esplora e aggiungere il nome utente e la password del Registro Contenitori. Questo file viene ignorato da git, ma quando si compila il contenitore, imposta le credenziali per accedere al servizio Registro Contenitori.

Capitolo 8 - Modifica della soluzione contenitore

È ora possibile completare la soluzione contenitore aggiornando i file seguenti:

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

Creare quindi la cartella images, usata dallo script Python per verificare la corrispondenza delle immagini con il modello di Visione personalizzata. Infine, si aggiunge il file labels.txt , per facilitare la lettura del modello, e il file model.pb , che è il modello.

Con Visual Studio 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 sostituire il relativo contenuto 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 sostituirne il contenuto seguendo le linee guida:
1. Poiché si ha una struttura JSON personalizzata, univoca, è necessario modificarla manualmente (anziché copiare un esempio). Per semplificare la procedura, usare l'immagine seguente come guida.
2. Le aree che hanno un aspetto diverso dal tuo, 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 dovrebbe essere simile all'immagine seguente(con le differenze univoche: riferimenti a nome utente/password/nome modulo/modulo):

Aprire il file denominato Dockerfile.amd64 e sostituirlo con il contenuto seguente:

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 sotto i moduli (il nome specificato in precedenza, nell'esempio più in basso, si chiama 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 sono le immagini analizzate dal modello Tensorflow.

Avviso

Se si usa un modello personalizzato, è necessario modificarlo per riflettere i dati dei propri modelli.
È ora necessario recuperare i file labels.txt e model.pb dalla cartella del modello precedentemente scaricata (o creata dal proprio servizio 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 un pacchetto" dei file come contenitore ed eseguirne il push nel Registro Azure Container. All'interno di 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 (ACR):Within VS Code, open the Integrated Terminal (View>Integrated Terminal or CTRL+`) and use the following line to login to Docker (sostituire i valori del comando con le credenziali del Registro Azure Container (ACR)):
```
    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 soluzione IoT Edge. Questo processo di compilazione richiede molto tempo (a seconda del dispositivo), quindi preparati ad attendere. Al termine del processo di compilazione, viene 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 richieste usando le credenziali dell'account Azure; Vs Code offre un'opzione per Copiare e aprire, che copia 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, si noterà sul lato inferiore del pannello Esplora, una nuova sezione denominata hub IoT di Azure Dispositivi. Fare clic su questa sezione per espanderla.
Se il dispositivo non è presente, è 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 nota quindi che il riquadro comandi (nella parte superiore di VS Code) richiede di immettere la stringa di connessione. Questa è la stringa di connessione annotata alla fine del capitolo 3. Premere INVIO dopo aver copiato la stringa.
Il dispositivo deve essere caricato e visualizzato. Fare clic con il pulsante destro del mouse sul nome del dispositivo e quindi scegliere Crea distribuzione per un singolo dispositivo.
Viene visualizzato un prompt Esplora file, in cui è possibile passare alla cartella config e quindi selezionare il file deployment.json. Con il file selezionato, fare clic sul pulsante Seleziona manifesto distribuzione Edge .
A questo punto, è stato fornito al servizio hub IoT il manifesto per distribuire il contenitore, come modulo, dal Registro Azure Container, distribuendolo in modo efficace nel dispositivo.
Per visualizzare i messaggi inviati dal dispositivo al hub IoT, fare di nuovo clic con il pulsante destro del mouse sul nome del dispositivo nella sezione hub IoT di Azure Dispositivi, nel pannello Esplora risorse e fare clic su Avvia monitoraggio messaggio D2C. I messaggi inviati dal dispositivo dovrebbero essere visualizzati nel terminale vs. Sii paziente, perché potrebbe richiedere del tempo. Vedere il capitolo successivo per il debug e il controllo dell'esito positivo della distribuzione.

Questo modulo esegue ora l'iterazione tra le immagini nella cartella images e le analizza, a ogni iterazione. Questa è solo una dimostrazione di come far funzionare il modello di Machine Learning di base in un ambiente di dispositivo IoT Edge.

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

Un altro modo potrebbe essere la copia delle immagini dal dispositivo IoT nel contenitore. Un modo pratico per eseguire questo comando consiste nell'eseguire il comando seguente nel terminale del dispositivo IoT (forse una piccola app potrebbe eseguire il processo, se si desidera automatizzare il processo). È possibile testare questo comando eseguendolo manualmente dal percorso della cartella in cui sono 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 sono riportati un elenco di righe di comando e suggerimenti che consentono di monitorare ed eseguire il debug dell'attività di messaggistica del runtime di IoT Edge dal dispositivo Ubuntu.

Controllare lo stato 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, questi vengono visualizzati eseguendo la riga di comando seguente:
```
    sudo iotedge list
```
Oppure
```
    sudo docker ps
```
Nota

L'esecuzione dei comandi è un buon modo per verificare se il modulo viene distribuito correttamente, come viene visualizzato nell'elenco; In caso contrario, vengono visualizzati soloedgeHub e edgeAgent.
Per visualizzare i log del 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 un servizio tabelle

Tornare al portale di Azure, in cui si crea un servizio tabelle 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, cercare Account di archiviazione e premere INVIO per avviare la ricerca.
Una volta 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, viene visualizzato un pannello:
1. Inserire il nome desiderato per questa istanza del servizio (deve essere tutto in lettere minuscole).
2. Per Modello di distribuzione fare clic su Gestione risorse.
3. Per Tipo di account, usando il menu a discesa, fare clic su Archiviazione (utilizzo generico v1).For Account kind, using the dropdown menu, click Storage (General Purpose v1).
4. Fare clic su un percorso appropriato.
5. Per il menu a discesa Replica fare clic su Archiviazione con ridondanza geografica e accesso in lettura.
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, effettuare il provisioning e gestire la fatturazione per una raccolta di asset Azure. È consigliabile mantenere tutti i servizi Azure associati a un singolo progetto ,ad esempio questi corsi, in un gruppo di risorse comune.
  
  Per altre informazioni su Azure gruppi di risorse, seguire questo collegamento su come gestire un gruppo di risorse.
10. Lasciare Le reti virtualidisabilitate, se si tratta di un'opzione.
11. Fare clic su Crea.
Dopo aver fatto clic su Crea, è necessario attendere la creazione del servizio, potrebbe essere necessario un minuto.
Una notifica viene 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 passare alla pagina di panoramica della nuova istanza del servizio di archiviazione.
Dalla pagina di panoramica, a destra, fare clic su Tabelle.
Il pannello a destra cambia per visualizzare le informazioni sul servizio tabelle , in cui è necessario aggiungere una nuova tabella. Fare clic sul pulsante + Tabella nell'angolo superiore sinistro.
Viene visualizzata una nuova pagina, in cui è necessario immettere un nome di tabella. Questo è il nome usato per fare riferimento ai dati nell'applicazione nei capitoli successivi (creazione di app per le funzioni e Power BI). Inserire IoTMessages come nome (è possibile sceglierne uno personalizzato, ricordarlo quando viene usato più avanti in questo documento) e fare clic su OK.
Dopo aver creato la nuova tabella, è possibile visualizzarla nella pagina Servizio tabelle (nella parte inferiore).
A questo punto, fare clic su Chiavi di accesso e prendere una copia del nome e della chiavedell'account di archiviazione (usando il Blocco note), usare questi valori più avanti in questo corso, quando si crea l'app per le funzioni Azure.
Usando di nuovo il pannello a sinistra, scorrere fino alla sezione Servizio tabelle e fare clic su Tabelle (o Sfoglia tabelle, nei portali più recenti) e copiare l'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 Azure

Ora che l'account di archiviazione del servizio tabelle è configurato, è il momento di aggiungervi dati, che possono essere 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 si apre come elemento ancorato (sii paziente, perché il caricamento potrebbe richiedere tempo).
Avviso

Se la sottoscrizione usata per creare gli account di archiviazione non è visibile, assicurarsi di avere:
- È stato eseguito l'accesso allo stesso account usato per il portale di Azure.
- La sottoscrizione è stata selezionata nella pagina Gestione account (potrebbe essere necessario applicare un filtro dalle impostazioni dell'account):
Vengono visualizzati i servizi cloud Azure. Trovare account di archiviazione e fare clic sulla freccia a sinistra di tale account per espandere gli account.
Una volta espanso, l'account di archiviazione appena creato dovrebbe essere disponibile. Fare clic sulla freccia a sinistra della risorsa di archiviazione, quindi, una volta espansa, trovare Tabelle e fare clic sulla freccia accanto, per visualizzare la tabella creata nell'ultimo capitolo. Fare doppio clic sulla tabella.
La tabella viene aperta al centro della finestra di Visual Studio. Fare clic sull'icona della tabella con il + segno più.
Viene visualizzata una finestra che richiede di aggiungere entità. Si crea una sola entità, anche se ha tre proprietà. Si noti che PartitionKey e RowKey sono già disponibili, in quanto vengono usati dalla tabella per trovare i dati.
Aggiornare i valori seguenti:
- Nome: PartitionKey, Valore: PK_IoTMessages
- Nome: RowKey, Valore: RK_1_IoTMessages
Fare quindi clic su Aggiungi proprietà (in basso a sinistra nella finestra Aggiungi entità ) e aggiungere la proprietà seguente:
- MessageContent, come stringa, lasciare il valore vuoto.
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 con questo corso.
Al termine, fare clic su OK . La tabella è ora pronta per l'uso.

Capitolo 13 - Creare un'app per le funzioni Azure

È ora possibile creare un'app per le funzioni Azure, 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 consenta alla funzione 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 seguente. Dopo aver eseguito questa operazione, salvarlo sul desktop come project.json. Questo file definisce le librerie usate dalla funzione. Se si usa NuGet, sembra familiare.

Avviso

È importante che la denominazione sia corretta. assicurarsi che NON abbia un'estensione di file .txt. Per informazioni di riferimento, vedere la struttura JSON seguente:
```
{
"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 cercare. Per aprire un nuovo pannello, fare clic su App per le funzioni dai risultati.
Il nuovo pannello fornisce 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, effettuare il provisioning e gestire la fatturazione per una raccolta di asset Azure. È consigliabile mantenere tutti i servizi Azure associati a un singolo progetto ,ad esempio questi corsi, in un gruppo di risorse comune.
  
  Per altre informazioni su Azure gruppi di risorse, seguire questo collegamento su come gestire un gruppo di risorse.
5. Per il sistema operativo, fare clic su Windows, in quanto si tratta della piattaforma prevista.
6. Selezionare un piano di hosting (questa esercitazione usa un piano a consumo).
7. Selezionare un percorso (scegliere la stessa posizione dell'archiviazione creata nel passaggio precedente).
8. Per la sezione Archiviazioneè necessario selezionare il servizio di archiviazione creato nel passaggio precedente.
9. Non è necessario Application Insights in questa app, quindi è possibile lasciarlo disattivato.
10. Fare clic su Crea.
Dopo aver fatto clic su Crea, è necessario attendere la creazione del servizio, potrebbe essere necessario un minuto.
Una notifica viene visualizzata nel portale dopo la creazione dell'istanza del servizio.
Fare clic sulla notifica al termine della distribuzione.
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 viene visualizzata la finestra di creazione della funzione . Scorrere ulteriormente 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 essa.
Nel pannello hub IoT (Hub eventi) impostare Lingua su C# e quindi fare clic su Nuovo.
Nella finestra visualizzata verificare che sia selezionata hub IoT 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 viene reindirizzati all'editor di funzioni.

Eliminare tutto il codice in esso contenuto e sostituirlo con il codice seguente:

#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 tabella e archiviazione , rispettivamente dai passaggi 11 e 13 del capitolo 11) 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 del nome dell'account di archiviazione .
- storageAccountKey, con la chiave ottenuta nel servizio di archiviazione creato in precedenza.
Dopo il codice, fare clic su Salva.
Fare quindi clic sull'icona < (freccia) sul lato destro della pagina.
Un pannello scorre da destra. In tale pannello fare clic su Carica e verrà visualizzato un File Browser .
Passare al file project.json creato in precedenza nel Blocco note e fare clic sul pulsante Apri . Questo file definisce le librerie usate dalla funzione.
Quando il file viene caricato, viene visualizzato nel pannello a destra. Facendo clic su di esso viene aperto all'interno dell'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. Nella parte superiore destra 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 viene eseguita, visualizzando lo stato del risultato (si nota lo stato verde 202 Accettato, nella finestra Output , il 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, poiché viene 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, i messaggi del dispositivo Ubuntu vengono visualizzati nella tabella IoTMessages . Se non è già in esecuzione, riavviare il dispositivo ed è possibile visualizzare i messaggi dei risultati dal dispositivo e dal modulo all'interno della tabella tramite Visual Studio Cloud Explorer.

visualizzare i dati

Capitolo 15 - Configurazione di Power BI

Per visualizzare i dati dal dispositivo IOT, si configura Power BI (versione desktop) per raccogliere i dati dal servizio tabelle creato. La versione holoLens di Power BI usa quindi i 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 essere reindirizzati 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 su Altro.
Fare clic su Azure, Azure Archiviazione tabelle e quindi su Connetti.
Viene richiesto di inserire l'URL della 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" (che era IoTMessages, in questo corso). Il risultato finale deve essere quello visualizzato nell'immagine seguente. Quindi fare clic su OK.
Viene 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.
Viene visualizzato un pannello di navigazione , selezionare la casella accanto alla tabella e fare clic su Carica.
La tabella viene ora caricata in Power BI, ma richiede una query per visualizzarvi i valori. Fare clic con il pulsante destro del mouse sul nome della tabella che si trova nel pannello CAMPI sul lato destro dello schermo. Fare quindi clic su Modifica query.
Un editor di Power Query si apre come una nuova finestra, visualizzando la tabella. Fare clic sulla parola Record all'interno della colonna Contenuto della tabella per visualizzare il contenuto archiviato.
Fare clic su Into Table (In tabella) nella parte superiore sinistra della finestra.
Fare clic su Chiudi & Applica.
Al termine del caricamento della query, nel pannello CAMPI, sul lato destro dello schermo, 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 visualizzi 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 (noto anche come 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 quindi scaricare l'applicazione Power BI .
Avviare Power BI dall'elenco delle applicazioni.
Power BI potrebbe richiedere l'accesso 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, è sufficiente fare clic sull'icona dell'area di lavoro sul lato sinistro della finestra.

L'applicazione hub IoT completata

Congratulazioni, è stato creato un servizio di 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 Azure, facilitato da un'app per le funzioni Azure, che viene letta in Power BI e visualizzata all'interno di un Microsoft HoloLens.

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

Esercizi bonus

Esercizio 1

Espandere la struttura di messaggistica archiviata nella tabella e visualizzarla come grafico. È possibile raccogliere più dati e archiviarli nella stessa tabella, per essere visualizzati in un secondo momento.

Esercizio 2

Creare un altro modulo di acquisizione della fotocamera da distribuire nella scheda IoT, in modo che possa acquisire immagini tramite la fotocamera da analizzare.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-01-06