Esercitazione: Sviluppare moduli IoT Edge usando Visual Studio Code

• .NET Core SDK
• estensione C# per Visual Studio Code

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

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

• Node.js.
• Yeoman
• Azure IoT Edge Node.js Generatore di moduli.

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.

Il codice C# di esempio fornito con il modello di progetto usa la classe ModuleClient dall'SDK di IoT Hub per .NET.

1. Nell'esplora risorse di Visual Studio Code, apri modules > filtermodule > ModuleBackgroundService.cs.

2. Prima del filtermodule namespace, aggiungere tre using istruzioni 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 temperatureThreshold variabile alla ModuleBackgroundService classe . Questa variabile imposta il valore che la temperatura misurata deve superare affinché i dati vengano inviati al IoT Hub.

   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 un oggetto ModuleClient che consente al modulo di connettersi al runtime Azure IoT Edge locale per inviare e ricevere messaggi. Dopo aver creato ModuleClient, il codice legge il temperatureThreshold valore dalle proprietà desiderate del modulo gemello. Il codice registra un callback per ricevere messaggi da un hub IoT Edge tramite un endpoint denominato input1.

   Sostituire la chiamata del metodo ProcessMessageAsync con una nuova chiamata che aggiorna il nome dell'endpoint e il metodo chiamato quando l'input arriva. Aggiungere anche un SetDesiredPropertyUpdateCallbackAsync metodo per gli aggiornamenti alle proprietà desiderate. Per apportare questa modifica, sostituire l'ultima riga del ExecuteAsync metodo 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 OnDesiredPropertiesUpdate metodo alla ModuleBackgroundService classe . Questo metodo riceve gli aggiornamenti sulle proprietà desiderate dal modulo gemello e aggiorna la temperatureThreshold variabile in modo che corrisponda. 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 FilterMessages metodo . Questo metodo viene chiamato ogni volta che il modulo riceve un messaggio dall'hub IoT Edge. Filtra i messaggi con un valore della temperatura inferiore alla soglia relativa alla temperatura configurata tramite il modulo gemello. Aggiunge anche la MessageType proprietà al messaggio con il valore impostato su Alert:

   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. In Esplora 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.

    Trova la routes sezione nella $edgeHub modulo gemello. Aggiornare la sensorTofiltermodule route 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 nella parte inferiore della modulesContent sezione, 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. Scarica il repository GitHub Parson. Copiare i file parson.c e parson.h nella cartella filtermodule.

   2. Aprire modules > filtermodule > CMakeLists.txt. Nella parte superiore 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 target_link_libraries funzione di CMakeLists.txt.

   4. Salvare il file CMakeLists.txt.

   5. Aprire modules > filtermodule > main.c. Alla fine dell'elenco di istruzioni include, aggiungere una nuova istruzione che includa parson.h per il supporto JSON.

      #include "parson.h"
      

2. Nel file main.c aggiungere una variabile globale denominata temperatureThreshold dopo la include sezione . Questa variabile imposta il valore che la temperatura misurata deve superare affinché i dati vengano inviati a IoT Hub:

   static double temperatureThreshold = 25;
   

3. Trovare la CreateMessageInstance funzione in main.c. Sostituire l'istruzione interna if-else 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 etichetta il messaggio come avviso. Questo codice etichetta tutti i messaggi come avvisi, perché verranno aggiunte funzionalità che inviano messaggi solo a IoT Hub 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 coda di output. In caso contrario, 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 sulle proprietà desiderate dal modulo gemello e aggiorna la temperatureThreshold variabile in modo che corrisponda. Tutti i moduli hanno un proprio 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 viene 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. In Esplora 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 > 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 App classe . Questa variabile imposta una soglia di temperatura. La temperatura della macchina misurata non viene segnalata a IoT Hub fino a quando non supera questo valore:

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

4. Sostituire il metodo execute di MessageCallbackMqtt con il codice seguente. Questo metodo viene chiamato ogni volta che il modulo riceve un messaggio MQTT dall'hub IoT Edge. Filtra i messaggi che segnalano le temperature al di sotto della soglia di temperatura impostata 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 nella App classe . Queste classi aggiornano la tempThreshold variabile quando cambia la 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 sottoscrivere gli 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. In Esplora 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 nella parte inferiore della moduleContent sezione, dopo il modulo gemello $edgeHub :

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

10. Salvare il file deployment.template.json .

1. Nell'esplora di Visual Studio Code, apri modules > filtermodule > app.js.

2. Aggiungere una variabile di soglia della temperatura all'inizio di app.js. La soglia di temperatura imposta il valore che la temperatura misurata deve superare affinché i dati vengano inviati a IoT Hub:

   var temperatureThreshold = 25;
   

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

   // 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 pipeMessage della filterMessage funzione con client.on() nella chiamata:

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

5. Copia il codice seguente nel callback della funzione client.open() dopo client.on() all'interno dell'istruzione else. Questa funzione viene richiamata quando vengono aggiornate le proprietà desiderate:

   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. In Esplora Visual Studio Code aprire il file deployment.template.json nell'area di lavoro della soluzione IoT Edge.

8. 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
         }
     }
   

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. Nell'Esplora di Visual Studio Code, apri modules > filtermodule > main.py.

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

   import json
   

3. Aggiungere definizioni globali per le variabili di 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 al IoT Hub:

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

4. Sostituire la create_client funzione 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. In Esplora 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 nella parte inferiore della modulesContent sezione, dopo il modulo gemello $edgeHub :

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

8. Salvare il file deployment.template.json .