Självstudie: Utveckla IoT Edge moduler med hjälp av Visual Studio Code

• .NET Core SDK
• C# Visual Studio Code-tillägget

• C/C++ Visual Studio Code tillägg
• Installation av Azure IoT C SDK krävs inte för den här självstudien, men kan ge användbara funktioner som IntelliSense och läsa programdefinitioner. Installationsinformation finns i Azure IoT C SDK:er och bibliotek.

• Java SE Development Kit 11 och Maven. Du måste ställa in JAVA_HOME miljövariabeln så att den pekar på din JDK-installation.
• Maven
• Java Tilläggspaket för Visual Studio Code

• Node.js.
• Yeoman
• Azure IoT Edge Node.js Module Generator.

Om du vill utveckla en IoT Edge modul i Python installerar du följande extra krav på utvecklingsdatorn:

• Python och Pip.
• Cookiecutter.
• Python-tillägg för Visual Studio Code.

C#-exempelkoden som medföljer projektmallen använder klassen ModuleClient från IoT Hub SDK för .NET.

1. I Visual Studio Codes utforskare öppnar du modules > filtermodule > ModuleBackgroundService.cs.

2. Innan namnområdet lägger du till tre filtermodule satser för typer som används senare:

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

3. Lägg till variabeln temperatureThreshold i ModuleBackgroundService klassen. Den här variabeln anger det värde som den uppmätta temperaturen måste överskrida för att data ska skickas till IoT Hub.

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

4. Lägg till klasserna MessageBody, Machineoch Ambient . Dessa klasser definierar det förväntade schemat för brödtexten i inkommande meddelanden.

   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. Hitta ExecuteAsync-funktionen. Den här funktionen skapar och konfigurerar ett ModuleClient-objekt som gör att modulen kan ansluta till den lokala Azure IoT Edge-körningen för att skicka och ta emot meddelanden. Efter att ModuleClient har skapats, läser temperatureThreshold koden värdet från den önskade egenskapen hos module twin. Koden registrerar ett återanrop för att ta emot meddelanden från en IoT Edge hubb via en slutpunkt med namnet input1.

   Ersätt anropet ProcessMessageAsync till metoden med en ny som uppdaterar namnet på slutpunkten och metoden som anropas när indata kommer. Lägg också till en SetDesiredPropertyUpdateCallbackAsync metod för uppdateringar av önskade egenskaper. Om du vill göra den här ändringen ersätter du den sista raden i ExecuteAsync metoden med följande kod:

   // 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. OnDesiredPropertiesUpdate Lägg till metoden i ModuleBackgroundService klassen. Den här metoden tar emot uppdateringar av önskade egenskaper från modultvillingen och uppdaterar variabeln så att den temperatureThreshold matchar. Alla moduler har en egen modultvilling, vilket innebär att du kan konfigurera den kod som körs i en modul direkt från molnet.

   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. FilterMessages Lägg till metoden. Den här metoden anropas när modulen tar emot ett meddelande från IoT Edge hubben. Den filtrerar ut meddelanden som rapporterar temperaturer under temperaturtröskelvärdet som angetts via modultvillingen. Den lägger också till egenskapen MessageType i meddelandet med värdet inställt på 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. Spara filen ModuleBackgroundService.cs .

9. I Visual Studio Code-explorern öppnar du filen deployment.template.json i din IoT Edge-lösnings arbetsyta.

10. Eftersom vi har ändrat namnet på slutpunkten som modulen lyssnar på måste vi också uppdatera vägarna i distributionsmanifestet så att edgeHub skickar meddelanden till den nya slutpunkten.

    Leta reda på avsnittet routes i modultvillingen $edgeHub . sensorTofiltermodule Uppdatera vägen för att ersätta input1 med inputFromSensor:

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

11. Lägg till modultvillingen filtermodul i distributionsmanifestet. Infoga följande JSON-innehåll längst ned i modulesContent avsnittet efter $edgeHub modultvilling:

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

12. Spara filen deployment.template.json.

1. Data från sensorn i det här scenariot kommer i JSON-format. Om du vill filtrera meddelanden i JSON-format importerar du ett JSON-bibliotek för C. Den här självstudien använder Parson.

   1. Ladda ned lagringsplatsen Parson GitHub. Kopiera filerna parson.c och parson.h till mappen filtermodule.

   2. Öppna moduler > filtermodule > CMakeLists.txt. Överst i filen importerar du Parson-filerna som ett bibliotek med namnet my_parson:

      add_library(my_parson
          parson.c
          parson.h
      )
      

   3. Lägg till my_parson i listan över bibliotek i target_link_libraries funktionen CMakeLists.txt.

   4. Spara filen CMakeLists.txt.

   5. Öppna moduler > filtermodule > main.c. Längst ner i listan med include instruktioner, lägg till en ny för att inkludera parson.h för JSON-stöd.

      #include "parson.h"
      

2. Lägg till en global variabel som heter efter temperatureThreshold avsnittet i filen include. Den här variabeln anger det värde som den uppmätta temperaturen måste överskrida för att data ska skickas till IoT Hub:

   static double temperatureThreshold = 25;
   

3. CreateMessageInstance Hitta funktionen i main.c. Ersätt den inre if-else instruktionen med följande kod som lägger till några rader med funktioner:

   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");
       }
   }
   

   De nya kodraderna i -instruktionen else lägger till en ny egenskap i meddelandet, som etiketterar meddelandet som en avisering. Den här koden etiketterar alla meddelanden som aviseringar eftersom vi lägger till funktioner som bara skickar meddelanden till IoT Hub om de rapporterar höga temperaturer.

4. Ersätt hela funktionen InputQueue1Callback med följande kod. Den här funktionen implementerar själva meddelandefiltret. När ett meddelande tas emot kontrollerar det om den rapporterade temperaturen överskrider tröskelvärdet. Om så är fallet, vidarebefordras meddelandet via utdatakön. Annars ignoreras meddelandet:

   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. Lägg till en moduleTwinCallback-funktion. Den här metoden tar emot uppdateringar av önskade egenskaper från modultvillingen och uppdaterar variabeln så att den temperatureThreshold matchar. Alla moduler har en egen modultvilling som gör att du kan konfigurera koden som körs i en modul direkt från molnet:

   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. Hitta SetupCallbacksForModule-funktionen. Ersätt funktionen med följande kod som lägger till en else if instruktion för att kontrollera om modultvillingen uppdateras:

   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. Spara filen main.c.

8. I Visual Studio Code-explorern öppnar du filen deployment.template.json i din IoT Edge-lösnings arbetsyta.

9. Lägg till modultvillingen filtermodul i distributionsmanifestet. Infoga följande JSON-innehåll längst ned i avsnittet moduleContent efter $edgeHub-modultvillingen:

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

10. Spara filen deployment.template.json.

1. I Visual Studio Codes utforskare, öppna moduler > filtermodule > src > main > java > com > edgemodule > App.java.

2. Lägg till följande kod längst upp i filen för att importera nya refererade klasser.

   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. Lägg till följande definition i App klassen. Den här variabeln anger ett tröskelvärde för temperatur. Den uppmätta datortemperaturen rapporteras inte IoT Hub förrän den överskrider det här värdet:

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

4. Ersätt metoden execute för MessageCallbackMqtt med följande kod. Den här metoden anropas när modulen tar emot ett MQTT-meddelande från IoT Edge hubben. Den filtrerar ut meddelanden som rapporterar temperaturer under det temperaturtröskelvärde som anges via modultvillingen:

   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. Lägg till följande två statiska inre klasser i App klassen. Dessa klasser uppdaterar variabeln tempThreshold när modultvillingens önskade egenskap ändras. Alla moduler har en egen modultvilling som gör att du kan konfigurera koden som körs i en modul direkt från molnet:

   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. Lägg till följande rader i main metoden efter client.open() för att prenumerera på modultvillinguppdateringarna:

   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. Spara filen App.java .

8. I Visual Studio Code Explorer öppnar du filen deployment.template.json i din IoT Edge-lösnings arbetsyta.

9. Lägg till modultvillingen filtermodul i distributionsmanifestet. Infoga följande JSON-innehåll längst ned i moduleContent avsnittet efter $edgeHub modultvilling:

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

10. Spara filen deployment.template.json.

1. I Visual Studio Code explorer öppnar du modules > filtermodule > app.js.

2. Lägg till en temperaturtröskelvariabel i början av app.js. Temperaturtröskelvärdet anger det värde som den uppmätta temperaturen måste överskrida för att data ska skickas till IoT Hub:

   var temperatureThreshold = 25;
   

3. Ersätt hela PipeMessage funktionen med FilterMessage funktionen.

   // 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. Ersätt funktionsnamnet pipeMessage med filterMessage i anropet client.on() :

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

5. Kopiera följande kod till funktionsåteranropet client.open(), efter client.on() inuti else-instruktionen. Den här funktionen anropas när önskade egenskaper uppdateras:

   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. Spara app.js-filen.

7. I den Visual Studio Code explorer öppnar du filen deployment.template.json i IoT Edge-lösningens arbetsyta.

8. Lägg till modultvillingen filtermodul i distributionsmanifestet. Infoga följande JSON-innehåll längst ned i avsnittet moduleContent efter $edgeHub-modultvillingen:

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

9. Spara filen deployment.template.json.

I det här avsnittet lägger du till koden som expanderar filtermodulen för att analysera meddelandena innan de skickas. Du lägger till kod som filtrerar meddelanden där den rapporterade datortemperaturen ligger inom de godkända gränserna.

1. I Visual Studio Code explorer öppnar du modules > filtermodule > main.py.

2. Längst upp i filen main.py importerar du json-biblioteket:

   import json
   

3. Lägg till globala definitioner för variablerna TEMPERATURE_THRESHOLD, RECEIVED_MESSAGES och TWIN_CALLBACKS . Temperaturtröskelvärdet anger det värde som den uppmätta datortemperaturen måste överskrida för att data ska skickas till IoT Hub:

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

4. create_client Ersätt funktionen med följande kod:

   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. Spara filen main.py.

6. I Visual Studio Code-explorer öppnar du filen deployment.template.json i arbetsytan för din IoT Edge-lösning.

7. Lägg till modultvillingen filtermodul i distributionsmanifestet. Infoga följande JSON-innehåll längst ned i modulesContent avsnittet efter $edgeHub modultvilling:

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

8. Spara filen deployment.template.json.