Esercitazione: Sviluppare moduli IoT Edge con Visual Studio Code

• ASP.NET Core SDK
• Estensione C# per Visual Studio Code

• Estensione C/C++ di Visual Studio Code
• Per questa esercitazione non è necessario installare l'SDK di Azure IoT C, ma tale SDK può fornire funzionalità utili come IntelliSense e la lettura delle definizioni dei programmi. Per informazioni sull'installazione, vedere SDK e librerie di Azure IoT C.

• Java SE Development Kit 11 e Maven. È necessario impostare la JAVA_HOMEvariabile di ambiente in modo che punti all'installazione di JDK.
• Intenditore
• Java Extension Pack per Visual Studio Code

• Node.js.
• Yeoman
• Generatore del modulo Azure IoT Edge Node.js.

Per sviluppare un modulo IoT Edge in Python, installare questi prerequisiti aggiuntivi nel computer di sviluppo:

• Python e Pip.
• Cookiecutter.
• Estensione Python per Visual Studio Code.

L'esempio di codice C# disponibile con il modello di progetto usa la classe ModuleClient da IoT Hub SDK per .NET.

1. Nello strumento di esplorazione di Visual Studio Code aprire i moduli>filtermodule>ModuleBackgroundService.cs.

2. Prima dello spazio dei nomi filtermodule, aggiungere tre istruzioni using per i tipi usati in un secondo momento:

   using System.Collections.Generic;     // For KeyValuePair<>
   using Microsoft.Azure.Devices.Shared; // For TwinCollection
   using Newtonsoft.Json;                // For JsonConvert
   

3. Aggiungere la variabile temperatureThreshold alla classe ModuleBackgroundService. Questa variabile imposta il valore che la temperatura misurata deve superare per l'invio dei dati all'hub IoT.

   static int temperatureThreshold { get; set; } = 25;
   

4. Aggiungere le classi MessageBody, Machine e Ambient. Queste classi definiscono lo schema previsto per il corpo dei messaggi in arrivo.

   class MessageBody
   {
       public Machine machine {get;set;}
       public Ambient ambient {get; set;}
       public string timeCreated {get; set;}
   }
   class Machine
   {
       public double temperature {get; set;}
       public double pressure {get; set;}
   }
   class Ambient
   {
       public double temperature {get; set;}
       public int humidity {get; set;}
   }
   

5. Trovare la funzione ExecuteAsync. Questa funzione crea e configura l'oggetto ModuleClient, che consente al modulo di connettersi al runtime locale di Azure IoT Edge per inviare e ricevere messaggi. Dopo la creazione di ModuleClient, il codice legge il valore temperatureThreshold dalle proprietà desiderate del modulo gemello. Il codice registra un callback per la ricezione di messaggi da un hub IoT Edge tramite un endpoint denominato input1.

   Sostituire la chiamata al metodo ProcessMessageAsync con un nuovo metodo che aggiorna il nome dell'endpoint e il metodo chiamato all'arrivo dell'input. Aggiungere inoltre un metodo SetDesiredPropertyUpdateCallbackAsync per gli aggiornamenti alle proprietà desiderate. Per apportare questa modifica, sostituire l'ultima riga del metodo ExecuteAsync con il codice seguente:

   // Register a callback for messages that are received by the module.
   // await _moduleClient.SetInputMessageHandlerAsync("input1", PipeMessage, cancellationToken);
   
   // Read the TemperatureThreshold value from the module twin's desired properties
   var moduleTwin = await _moduleClient.GetTwinAsync();
   await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, _moduleClient);
   
   // Attach a callback for updates to the module twin's desired properties.
   await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
   
   // Register a callback for messages that are received by the module. Messages received on the inputFromSensor endpoint are sent to the FilterMessages method.
   await _moduleClient.SetInputMessageHandlerAsync("inputFromSensor", FilterMessages, _moduleClient);
   

6. Aggiungere il metodo onDesiredPropertiesUpdate alla classe ModuleBackgroundService. Questo metodo riceve gli aggiornamenti della proprieta desiderata dal modulo gemello e aggiorna la variabile temperatureThreshold. Tutti i moduli hanno un modulo gemello che consente di configurare il codice in esecuzione all'interno di un modulo direttamente dal cloud.

   static Task OnDesiredPropertiesUpdate(TwinCollection desiredProperties, object userContext)
   {
       try
       {
           Console.WriteLine("Desired property change:");
           Console.WriteLine(JsonConvert.SerializeObject(desiredProperties));
   
           if (desiredProperties["TemperatureThreshold"]!=null)
               temperatureThreshold = desiredProperties["TemperatureThreshold"];
   
       }
       catch (AggregateException ex)
       {
           foreach (Exception exception in ex.InnerExceptions)
           {
               Console.WriteLine();
               Console.WriteLine("Error when receiving desired property: {0}", exception);
           }
       }
       catch (Exception ex)
       {
           Console.WriteLine();
           Console.WriteLine("Error when receiving desired property: {0}", ex.Message);
       }
       return Task.CompletedTask;
   }
   

7. Aggiungere il metodo FilterMessages. Questo metodo viene chiamato ogni volta che l'hub di IoT Edge invia un messaggio al modulo. Filtra i messaggi con un valore della temperatura inferiore alla soglia relativa alla temperatura configurata tramite il modulo gemello. Aggiunge inoltre la proprietà MessageType al messaggio con il valore impostato su Avviso.

   async Task<MessageResponse> FilterMessages(Message message, object userContext)
   {
       var counterValue = Interlocked.Increment(ref _counter);
       try
       {
           ModuleClient moduleClient = (ModuleClient)userContext;
           var messageBytes = message.GetBytes();
           var messageString = Encoding.UTF8.GetString(messageBytes);
           Console.WriteLine($"Received message {counterValue}: [{messageString}]");
   
           // Get the message body.
           var messageBody = JsonConvert.DeserializeObject<MessageBody>(messageString);
   
           if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
           {
               Console.WriteLine($"Machine temperature {messageBody.machine.temperature} " +
                   $"exceeds threshold {temperatureThreshold}");
               using (var filteredMessage = new Message(messageBytes))
               {
                   foreach (KeyValuePair<string, string> prop in message.Properties)
                   {
                       filteredMessage.Properties.Add(prop.Key, prop.Value);
                   }
   
                   filteredMessage.Properties.Add("MessageType", "Alert");
                   await moduleClient.SendEventAsync("output1", filteredMessage);
               }
           }
   
           // Indicate that the message treatment is completed.
           return MessageResponse.Completed;
       }
       catch (AggregateException ex)
       {
           foreach (Exception exception in ex.InnerExceptions)
           {
               Console.WriteLine();
               Console.WriteLine("Error in sample: {0}", exception);
           }
           // Indicate that the message treatment is not completed.
           var moduleClient = (ModuleClient)userContext;
           return MessageResponse.Abandoned;
       }
       catch (Exception ex)
       {
           Console.WriteLine();
           Console.WriteLine("Error in sample: {0}", ex.Message);
           // Indicate that the message treatment is not completed.
           ModuleClient moduleClient = (ModuleClient)userContext;
           return MessageResponse.Abandoned;
       }
   }
   

8. Salvare il file ModuleBackgroundService.cs.

9. Nello strumento di esplorazione di Visual Studio Code aprire il file deployment.template.json nell'area di lavoro della soluzione IoT Edge.

10. Poiché è stato modificato il nome dell'endpoint su cui il modulo è in ascolto, è anche necessario aggiornare le route nel manifesto della distribuzione in modo che edgeHub invii messaggi al nuovo endpoint.

    Trovare la sezione route nel modulo gemello $edgeHub. Aggiornare la route sensorTofiltermodule per sostituire input1 con inputFromSensor:

    "sensorTofiltermodule": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/filtermodule/inputs/inputFromSensor\")"
    

11. Aggiungere il modulo gemello filtermodule al manifesto della distribuzione. Inserire il contenuto JSON seguente alla fine della sezione modulesContent dopo il modulo gemello $edgeHub:

       "filtermodule": {
           "properties.desired":{
               "TemperatureThreshold":25
           }
       }
    

12. Salvare il file deployment.template.json.

1. I dati del sensore in questo scenario sono disponibili in formato JSON. Per filtrare i messaggi in formato JSON, importare una libreria JSON per C. Questa esercitazione usa Parson.

   1. Scaricare il repository Parson di GitHub. Copiare i file parson.c e parson.h nella cartella filtermodule.

   2. Aprire i moduli>filtermodule>CMakeLists.txt. All'inizio del file importare i file Parson come libreria denominata my_parson.

      add_library(my_parson
          parson.c
          parson.h
      )
      

   3. Aggiungere my_parson all'elenco di librerie nella funzione target_link_libraries di CMakeLists.txt.

   4. Salvare il file CMakeLists.txt.

   5. Aprire moduli>filtermodule>main.c. Alla fine dell'elenco di istruzioni include aggiungerne una nuova per includere parson.h per il supporto JSON:

      #include "parson.h"
      

2. Nel file main.c aggiungere una variabile globale denominata temperatureThreshold dopo la sezione include. Questa variabile imposta il valore che la temperatura misurata deve superare per inviare i dati all'hub IoT.

   static double temperatureThreshold = 25;
   

3. Trovare la funzione CreateMessageInstance in main.c. Sostituire l'istruzione if-else interna con il codice seguente che aggiunge alcune righe di funzionalità:

       if ((messageInstance->messageHandle = IoTHubMessage_Clone(message)) == NULL)
       {
           free(messageInstance);
           messageInstance = NULL;
       }
       else
       {
           messageInstance->messageTrackingId = messagesReceivedByInput1Queue;
           MAP_HANDLE propMap = IoTHubMessage_Properties(messageInstance->messageHandle);
           if (Map_AddOrUpdate(propMap, "MessageType", "Alert") != MAP_OK)
           {
              printf("ERROR: Map_AddOrUpdate Failed!\r\n");
           }
       }
   

   Le nuove righe di codice nell'istruzione else aggiungono una nuova proprietà al messaggio, che lo etichetta come avviso. Questo codice etichetta tutti i messaggi come avvisi, perché verrà aggiunta una funzionalità che invia i messaggi all'hub IoT solo se segnalano temperature elevate.

4. Sostituire l'intera funzione InputQueue1Callback con il codice seguente. Questa funzione implementa i filtri effettivi per i messaggi. Quando viene ricevuto un messaggio, verifica se la temperatura segnalata supera la soglia. In caso affermativo, inoltra il messaggio tramite la relativa coda di output. In caso negativo, ignora il messaggio.

   static unsigned char *bytearray_to_str(const unsigned char *buffer, size_t len)
   {
       unsigned char *ret = (unsigned char *)malloc(len + 1);
       memcpy(ret, buffer, len);
       ret[len] = '\0';
       return ret;
   }
   
   static IOTHUBMESSAGE_DISPOSITION_RESULT InputQueue1Callback(IOTHUB_MESSAGE_HANDLE message, void* userContextCallback)
   {
       IOTHUBMESSAGE_DISPOSITION_RESULT result;
       IOTHUB_CLIENT_RESULT clientResult;
       IOTHUB_MODULE_CLIENT_LL_HANDLE iotHubModuleClientHandle = (IOTHUB_MODULE_CLIENT_LL_HANDLE)userContextCallback;
   
       unsigned const char* messageBody;
       size_t contentSize;
   
       if (IoTHubMessage_GetByteArray(message, &messageBody, &contentSize) == IOTHUB_MESSAGE_OK)
       {
           messageBody = bytearray_to_str(messageBody, contentSize);
       } else
       {
           messageBody = "<null>";
       }
   
       printf("Received Message [%zu]\r\n Data: [%s]\r\n",
               messagesReceivedByInput1Queue, messageBody);
   
       // Check if the message reports temperatures higher than the threshold
       JSON_Value *root_value = json_parse_string(messageBody);
       JSON_Object *root_object = json_value_get_object(root_value);
       double temperature;
       if (json_object_dotget_value(root_object, "machine.temperature") != NULL && (temperature = json_object_dotget_number(root_object, "machine.temperature")) > temperatureThreshold)
       {
           printf("Machine temperature %f exceeds threshold %f\r\n", temperature, temperatureThreshold);
           // This message should be sent to next stop in the pipeline, namely "output1".  What happens at "output1" is determined
           // by the configuration of the Edge routing table setup.
           MESSAGE_INSTANCE *messageInstance = CreateMessageInstance(message);
           if (NULL == messageInstance)
           {
               result = IOTHUBMESSAGE_ABANDONED;
           }
           else
           {
               printf("Sending message (%zu) to the next stage in pipeline\n", messagesReceivedByInput1Queue);
   
               clientResult = IoTHubModuleClient_LL_SendEventToOutputAsync(iotHubModuleClientHandle, messageInstance->messageHandle, "output1", SendConfirmationCallback, (void *)messageInstance);
               if (clientResult != IOTHUB_CLIENT_OK)
               {
                   IoTHubMessage_Destroy(messageInstance->messageHandle);
                   free(messageInstance);
                   printf("IoTHubModuleClient_LL_SendEventToOutputAsync failed on sending msg#=%zu, err=%d\n", messagesReceivedByInput1Queue, clientResult);
                   result = IOTHUBMESSAGE_ABANDONED;
               }
               else
               {
                   result = IOTHUBMESSAGE_ACCEPTED;
               }
           }
       }
       else
       {
           printf("Not sending message (%zu) to the next stage in pipeline.\r\n", messagesReceivedByInput1Queue);
           result = IOTHUBMESSAGE_ACCEPTED;
       }
   
       messagesReceivedByInput1Queue++;
       return result;
   }
   

5. Aggiungere una funzione moduleTwinCallback. Questo metodo riceve gli aggiornamenti della proprieta desiderata dal modulo gemello e aggiorna la variabile temperatureThreshold. Tutti i moduli hanno un modulo gemello che consente di configurare il codice in esecuzione all'interno di un modulo direttamente dal cloud.

   static void moduleTwinCallback(DEVICE_TWIN_UPDATE_STATE update_state, const unsigned char* payLoad, size_t size, void* userContextCallback)
   {
       printf("\r\nTwin callback called with (state=%s, size=%zu):\r\n%s\r\n",
           MU_ENUM_TO_STRING(DEVICE_TWIN_UPDATE_STATE, update_state), size, payLoad);
       JSON_Value *root_value = json_parse_string(payLoad);
       JSON_Object *root_object = json_value_get_object(root_value);
       if (json_object_dotget_value(root_object, "desired.TemperatureThreshold") != NULL) {
           temperatureThreshold = json_object_dotget_number(root_object, "desired.TemperatureThreshold");
       }
       if (json_object_get_value(root_object, "TemperatureThreshold") != NULL) {
           temperatureThreshold = json_object_get_number(root_object, "TemperatureThreshold");
       }
   }
   

6. Trovare la funzione SetupCallbacksForModule. Sostituire la funzione con il codice seguente che aggiunge un'istruzione else if per verificare se il modulo gemello è aggiornato.

   static int SetupCallbacksForModule(IOTHUB_MODULE_CLIENT_LL_HANDLE iotHubModuleClientHandle)
   {
       int ret;
   
       if (IoTHubModuleClient_LL_SetInputMessageCallback(iotHubModuleClientHandle, "input1", InputQueue1Callback, (void*)iotHubModuleClientHandle) != IOTHUB_CLIENT_OK)
       {
           printf("ERROR: IoTHubModuleClient_LL_SetInputMessageCallback(\"input1\")..........FAILED!\r\n");
           ret = MU_FAILURE;
       }
       else if (IoTHubModuleClient_LL_SetModuleTwinCallback(iotHubModuleClientHandle, moduleTwinCallback, (void*)iotHubModuleClientHandle) != IOTHUB_CLIENT_OK)
       {
           printf("ERROR: IoTHubModuleClient_LL_SetModuleTwinCallback(default)..........FAILED!\r\n");
           ret = MU_FAILURE;
       }
       else
       {
           ret = 0;
       }
   
       return ret;
   }
   

7. Salvare il file main.c.

8. Nello strumento di esplorazione di Visual Studio Code aprire il file deployment.template.json nell'area di lavoro della soluzione IoT Edge.

9. Aggiungere il modulo gemello Module al manifesto della distribuzione. Inserire il contenuto JSON seguente alla fine della sezione moduleContent, dopo il modulo gemello $edgeHub:

   "filtermodule": {
       "properties.desired":{
           "TemperatureThreshold":25
       }
   }
   

10. Salvare il file deployment.template.json.

1. Nello strumento di esplorazione di Visual Studio Code aprire modules>filtermodule>src>main>java>com>edgemodule>App.java.

2. Aggiungere il codice seguente all'inizio del file per importare nuove classi di riferimento.

   import java.io.StringReader;
   import java.util.concurrent.atomic.AtomicLong;
   import java.util.HashMap;
   import java.util.Map;
   
   import javax.json.Json;
   import javax.json.JsonObject;
   import javax.json.JsonReader;
   
   import com.microsoft.azure.sdk.iot.device.DeviceTwin.Pair;
   import com.microsoft.azure.sdk.iot.device.DeviceTwin.Property;
   import com.microsoft.azure.sdk.iot.device.DeviceTwin.TwinPropertyCallBack;
   

3. Aggiungere la definizione seguente alla classe App. Questa variabile imposta una soglia di temperatura. La temperatura misurata della macchina non viene segnalata all'hub IoT finché non supera questo valore.

   private static final String TEMP_THRESHOLD = "TemperatureThreshold";
   private static AtomicLong tempThreshold = new AtomicLong(25);
   

4. Sostituire il metodo execute MessageCallbackMqtt con il codice seguente. Questo metodo viene chiamato ogni volta che il modulo riceve un messaggio MQTT dall'hub di IoT Edge. Filtra i messaggi con un valore della temperatura inferiore alla soglia relativa alla temperatura configurata tramite il modulo gemello.

   protected static class MessageCallbackMqtt implements MessageCallback {
       private int counter = 0;
       @Override
       public IotHubMessageResult execute(Message msg, Object context) {
           this.counter += 1;
   
           String msgString = new String(msg.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET);
           System.out.println(
                  String.format("Received message %d: %s",
                           this.counter, msgString));
           if (context instanceof ModuleClient) {
               try (JsonReader jsonReader = Json.createReader(new StringReader(msgString))) {
                   final JsonObject msgObject = jsonReader.readObject();
                   double temperature = msgObject.getJsonObject("machine").getJsonNumber("temperature").doubleValue();
                   long threshold = App.tempThreshold.get();
                   if (temperature >= threshold) {
                       ModuleClient client = (ModuleClient) context;
                       System.out.println(
                           String.format("Temperature above threshold %d. Sending message: %s",
                           threshold, msgString));
                       client.sendEventAsync(msg, eventCallback, msg, App.OUTPUT_NAME);
                   }
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
           return IotHubMessageResult.COMPLETE;
       }
   }
   

5. Aggiungere le due classi interne statiche seguenti alla classe App. Queste classi aggiornano la variabile tempThreshold al variare della proprietà desiderata del modulo gemello. Tutti i moduli hanno un modulo gemello che consente di configurare il codice in esecuzione all'interno di un modulo direttamente dal cloud.

   protected static class DeviceTwinStatusCallBack implements IotHubEventCallback {
       @Override
       public void execute(IotHubStatusCode status, Object context) {
           System.out.println("IoT Hub responded to device twin operation with status " + status.name());
       }
   }
   
   protected static class OnProperty implements TwinPropertyCallBack {
       @Override
       public void TwinPropertyCallBack(Property property, Object context) {
           if (!property.getIsReported()) {
               if (property.getKey().equals(App.TEMP_THRESHOLD)) {
                   try {
                       long threshold = Math.round((double) property.getValue());
                       App.tempThreshold.set(threshold);
                   } catch (Exception e) {
                       System.out.println("Failed to set TemperatureThread with exception");
                       e.printStackTrace();
                   }
               }
           }
       }
   }
   

6. Aggiungere le righe seguenti al metodo main dopo client.open() per eseguire la sottoscrizione agli aggiornamenti del modulo gemello.

   client.startTwin(new DeviceTwinStatusCallBack(), null, new OnProperty(), null);
   Map<Property, Pair<TwinPropertyCallBack, Object>> onDesiredPropertyChange = new HashMap<Property, Pair<TwinPropertyCallBack, Object>>() {
       {
           put(new Property(App.TEMP_THRESHOLD, null), new Pair<TwinPropertyCallBack, Object>(new OnProperty(), null));
       }
   };
   client.subscribeToTwinDesiredProperties(onDesiredPropertyChange);
   client.getTwin();
   

7. Salvare il file App.java.

8. Nello strumento di esplorazione di Visual Studio Code aprire il file deployment.template.json nell'area di lavoro della soluzione IoT Edge.

9. Aggiungere il modulo gemello filtermodule al manifesto della distribuzione. Inserire il contenuto JSON seguente alla fine della sezione moduleContent dopo il modulo gemello $edgeHub:

     "filtermodule": {
         "properties.desired":{
             "TemperatureThreshold":25
         }
     }
   

10. Salvare il file deployment.template.json.

1. Nello strumento di esplorazione di Visual Studio Code aprire modules>filtermodule>app.js.

2. Aggiungere una variabile di soglia della temperatura all'inizio di app.js. La soglia della temperatura imposta il valore che la temperatura misurata deve superare per inviare i dati all'hub IoT.

   var temperatureThreshold = 25;
   

3. Sostituire l'intera funzione PipeMessage con la funzione FilterMessage.

   // This function filters out messages that report temperatures below the temperature threshold.
   // It also adds the MessageType property to the message with the value set to Alert.
   function filterMessage(client, inputName, msg) {
       client.complete(msg, printResultFor('Receiving message'));
       if (inputName === 'input1') {
           var message = msg.getBytes().toString('utf8');
           var messageBody = JSON.parse(message);
           if (messageBody && messageBody.machine && messageBody.machine.temperature && messageBody.machine.temperature > temperatureThreshold) {
               console.log(`Machine temperature ${messageBody.machine.temperature} exceeds threshold ${temperatureThreshold}`);
               var outputMsg = new Message(message);
               outputMsg.properties.add('MessageType', 'Alert');
               client.sendOutputEvent('output1', outputMsg, printResultFor('Sending received message'));
           }
       }
   }
   
   

4. Sostituire il nome della funzione pipeMessage con filterMessage nella chiamata client.on().

   client.on('inputMessage', function (inputName, msg) {
       filterMessage(client, inputName, msg);
       });
   

5. Copiare il frammento di codice seguente nel callback della funzione client.open(), dopo client.on() nell'istruzione else. Questa funzione viene richiamata quando le proprietà desiderate vengono aggiornate.

   client.getTwin(function (err, twin) {
       if (err) {
           console.error('Error getting twin: ' + err.message);
       } else {
           twin.on('properties.desired', function(delta) {
               if (delta.TemperatureThreshold) {
                   temperatureThreshold = delta.TemperatureThreshold;
               }
           });
       }
   });
   

6. Salvare il file app.js.

7. Nello strumento di esplorazione di Visual Studio Code aprire il file deployment.template.json nell'area di lavoro della soluzione IoT Edge.

8. Aggiungere il modulo gemello Module al manifesto della distribuzione. Inserire il contenuto JSON seguente alla fine della sezione moduleContent, dopo il modulo gemello $edgeHub:

     "filtermodule": {
         "properties.desired":{
             "TemperatureThreshold":25
         }
     }
   

9. Salvare il file deployment.template.json.

In questa sezione aggiungere il codice che espande filtermodule per analizzare i messaggi prima di inviarli. Si aggiunge codice che filtra i messaggi in cui la temperatura del computer segnalata rientra nei limiti accettabili.

1. Nello strumento di esplorazione di Visual Studio Code aprire modules>filtermodule>main.py.

2. All'inizio del file main.py importare la libreria json:

   import json
   

3. Aggiungere definizioni globali per le variabili TEMPERATURE_THRESHOLD, RECEIVED_MESSAGES e TWIN_CALLBACKS. La soglia di temperatura imposta il valore che la temperatura del computer misurata deve superare per l'invio dei dati all'hub IoT.

   # global counters
   TEMPERATURE_THRESHOLD = 25
   TWIN_CALLBACKS = 0
   RECEIVED_MESSAGES = 0
   

4. Sostituire la funzione create_client con il codice seguente:

   def create_client():
       client = IoTHubModuleClient.create_from_edge_environment()
   
       # Define function for handling received messages
       async def receive_message_handler(message):
           global RECEIVED_MESSAGES
           print("Message received")
           size = len(message.data)
           message_text = message.data.decode('utf-8')
           print("    Data: <<<{data}>>> & Size={size}".format(data=message.data, size=size))
           print("    Properties: {}".format(message.custom_properties))
           RECEIVED_MESSAGES += 1
           print("Total messages received: {}".format(RECEIVED_MESSAGES))
   
           if message.input_name == "input1":
               message_json = json.loads(message_text)
               if "machine" in message_json and "temperature" in message_json["machine"] and message_json["machine"]["temperature"] > TEMPERATURE_THRESHOLD:
                   message.custom_properties["MessageType"] = "Alert"
                   print("ALERT: Machine temperature {temp} exceeds threshold {threshold}".format(
                       temp=message_json["machine"]["temperature"], threshold=TEMPERATURE_THRESHOLD
                   ))
                   await client.send_message_to_output(message, "output1")
   
       # Define function for handling received twin patches
       async def receive_twin_patch_handler(twin_patch):
           global TEMPERATURE_THRESHOLD
           global TWIN_CALLBACKS
           print("Twin Patch received")
           print("     {}".format(twin_patch))
           if "TemperatureThreshold" in twin_patch:
               TEMPERATURE_THRESHOLD = twin_patch["TemperatureThreshold"]
           TWIN_CALLBACKS += 1
           print("Total calls confirmed: {}".format(TWIN_CALLBACKS))
   
       try:
           # Set handler on the client
           client.on_message_received = receive_message_handler
           client.on_twin_desired_properties_patch_received = receive_twin_patch_handler
       except:
           # Cleanup if failure occurs
           client.shutdown()
           raise
   
       return client
   

5. Salvare il file main.py.

6. Nello strumento di esplorazione di Visual Studio Code aprire il file deployment.template.json nell'area di lavoro della soluzione IoT Edge.

7. Aggiungere il modulo gemello filtermodule al manifesto della distribuzione. Inserire il contenuto JSON seguente alla fine della sezione modulesContent dopo il modulo gemello $edgeHub:

       "filtermodule": {
           "properties.desired":{
               "TemperatureThreshold":25
           }
       }
   

8. Salvare il file deployment.template.json.