Zelfstudie: IoT Edge modules ontwikkelen met behulp van Visual Studio Code

• .NET Core SDK
• C# Visual Studio Code-extensie

• C/C++ Visual Studio Code-extensie
• Het installeren van de Azure IoT C SDK is niet vereist voor deze zelfstudie, maar kan nuttige functionaliteit bieden, zoals IntelliSense en programmadefinities lezen. Zie Azure IoT SDK's en bibliotheken voor informatie over de installatie.

• Java SE Development Kit 11 en Maven. U moet de JAVA_HOME omgevingsvariabele zo instellen dat deze verwijst naar uw JDK-installatie.
• Maven
• Java Extension Pack voor Visual Studio Code

• Node.js.
• Yeoman
• Azure IoT Edge Node.js Modulegenerator.

Als u een IoT Edge-module in Python wilt ontwikkelen, installeert u deze extra vereisten op uw ontwikkelcomputer:

• Python en Pip.
• Cookiecutter.
• Python-extensie voor Visual Studio Code.

De C#-voorbeeldcode die bij de projectsjabloon wordt geleverd, gebruikt de klasse ModuleClient van de IoT Hub SDK voor .NET.

1. Open in de Verkenner van Visual Studio Code modules > filtermodule > ModuleBackgroundService.cs.

2. Voeg vóór de filtermodule naamruimte drie using instructies toe voor typen die later worden gebruikt:

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

3. Voeg de temperatureThreshold variabele toe aan de ModuleBackgroundService klasse. Met deze variabele wordt de waarde ingesteld die de gemeten temperatuur moet overschrijden voordat de gegevens naar de IoT Hub worden verzonden.

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

4. Voeg de MessageBody, Machineen Ambient klassen toe. Deze klassen bepalen het verwachte schema voor de hoofdtekst van inkomende berichten.

   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. Zoek de functie ExecuteAsync. Met deze functie maakt en configureert u een ModuleClient-object waarmee de module verbinding kan maken met de lokale Azure IoT Edge runtime om berichten te verzenden en te ontvangen. Nadat u de ModuleClient hebt gemaakt, leest de code de temperatureThreshold waarde uit de gewenste eigenschappen van de moduletweeling. De code registreert een callback voor het ontvangen van berichten van een IoT Edge hub via een eindpunt met de naam input1.

   Vervang de aanroep naar de ProcessMessageAsync methode door een nieuwe die de naam van het eindpunt bijwerken en de methode die wordt aangeroepen wanneer invoer binnenkomt. Voeg ook een SetDesiredPropertyUpdateCallbackAsync methode toe voor updates aan de gewenste eigenschappen. Als u deze wijziging wilt aanbrengen, vervangt u de laatste regel van de ExecuteAsync methode door de volgende code:

   // 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. Voeg de OnDesiredPropertiesUpdate methode toe aan de ModuleBackgroundService klasse. Deze methode ontvangt updates voor de gewenste eigenschappen van de module-twin en werkt de temperatureThreshold variabele bij zodat deze overeenkomt. Alle modules hebben hun eigen moduledubbel, waardoor u rechtstreeks in de cloud de code kunt configureren die in een module wordt uitgevoerd.

   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. Voeg de FilterMessages methode toe. Deze methode wordt aangeroepen wanneer de module een bericht ontvangt van de IoT Edge hub. Berichten met temperaturen onder de temperatuurgrens die via de module-twin is ingesteld, worden daardoor gefilterd. Het voegt ook de MessageType eigenschap toe aan het bericht, waarbij de waarde is ingesteld op 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. Sla het ModuleBackgroundService.cs-bestand op.

9. Open in Visual Studio Code Explorer het bestand deployment.template.json in de werkruimte van de IoT Edge-oplossing.

10. Omdat we de naam van het eindpunt hebben gewijzigd waarop de module luistert, moeten we ook de routes in het implementatiemanifest bijwerken, zodat edgeHub berichten naar het nieuwe eindpunt verzendt.

    Zoek de routes sectie in de $edgeHub moduletweeling. Werk de sensorTofiltermodule route bij om input1 te vervangen door inputFromSensor:

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

11. Voeg de moduletweeling filtermodule toe aan het implementatiemanifest. Voeg de volgende JSON-inhoud onderaan de modulesContent-sectie in, na de $edgeHub tweelingmodule:

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

12. Sla het bestand deployment.template.json op.

1. De gegevens van de sensor in dit scenario worden in JSON-indeling aangeleverd. Als u berichten wilt filteren in een JSON-indeling, moet u een JSON-bibliotheek voor C importeren. In deze zelfstudie wordt Parson gebruikt.

   1. Download de Parson GitHub opslagplaats. Kopieer de bestanden parson.c en parson.h naar de map filtermodule.

   2. Open modules > filtermodule > CMakeLists.txt. Importeer bovenaan het bestand de Parson-bestanden als een bibliotheek met de naam my_parson:

      add_library(my_parson
          parson.c
          parson.h
      )
      

   3. Toevoegen my_parson aan de lijst met bibliotheken in de target_link_libraries functie van CMakeLists.txt.

   4. Sla het bestand CMakeLists.txt op.

   5. Open modules > filtermodule > main.c. Voeg onderaan de lijst include met instructies een nieuwe instructie toe om parson.h op te nemen voor JSON-ondersteuning.

      #include "parson.h"
      

2. Voeg in het bestand main.c een globale variabele toe met de naam temperatureThreshold na de include sectie. Met deze variabele wordt de waarde ingesteld die de gemeten temperatuur moet overschrijden om de gegevens naar IoT Hub te kunnen verzenden:

   static double temperatureThreshold = 25;
   

3. Zoek de CreateMessageInstance functie in main.c. Vervang de binnenste if-else instructie door de volgende code waarmee een paar regels functionaliteit worden toegevoegd:

   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 nieuwe coderegels in de else instructie voegen een nieuwe eigenschap toe aan het bericht, waarmee het bericht als waarschuwing wordt gelabeld. Met deze code worden alle berichten als waarschuwingen gelabeld, omdat we functionaliteit toevoegen waarmee alleen berichten worden verzonden naar IoT Hub als ze hoge temperaturen rapporteren.

4. Vervang de volledige functie InputQueue1Callback door de volgende code. Deze functie implementeert het feitelijke berichtenfilter. Wanneer een bericht wordt ontvangen, wordt gecontroleerd of de gerapporteerde temperatuur de drempelwaarde overschrijdt. Als dit het geval is, wordt het bericht doorgestuurd via de uitvoerwachtrij. Als dat niet het is, wordt het bericht genegeerd:

   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. Voeg een moduleTwinCallback-functie toe. Deze methode ontvangt updates voor de gewenste eigenschappen van de module-twin en werkt de temperatureThreshold variabele bij zodat deze overeenkomt. Alle modules hebben een eigen moduledubbel, waarmee u de code kunt configureren die rechtstreeks vanuit de cloud in een module wordt uitgevoerd:

   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. Zoek de functie SetupCallbacksForModule. Vervang de functie door de volgende code die een else if-instructie toevoegt om te controleren of de module twin is bijgewerkt:

   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. Sla het bestand main.c op.

8. Open in Visual Studio Code Explorer het bestand deployment.template.json in de werkruimte van de IoT Edge-oplossing.

9. Voeg de moduletweeling filtermodule toe aan het implementatiemanifest. Voeg de volgende JSON-inhoud onder aan de sectie moduleContent in, na de moduledubbel $edgeHub:

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

10. Sla het bestand deployment.template.json op.

1. In de Visual Studio Code explorer, open modules > filtermodule > src > main > java > com > edgemodule > App.java.

2. Voeg bovenaan het bestand de volgende code toe om nieuwe klassen waarnaar wordt verwezen, te importeren.

   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. Voeg de volgende definitie toe aan de App klasse. Met deze variabele wordt een drempelwaarde voor temperatuur ingesteld. De gemeten temperatuur van de machine wordt pas gerapporteerd aan IoT Hub als deze deze waarde overschrijdt:

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

4. Vervang de executemethode van MessageCallbackMqtt door de volgende code. Deze methode wordt aangeroepen wanneer de module een MQTT-bericht ontvangt van de IoT Edge hub. Hiermee worden berichten gefilterd die temperaturen rapporteren onder de temperatuurdrempel die is ingesteld via de module-twin.

   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. Voeg de volgende twee statische binnenste klassen toe aan de App klasse. Deze klassen werken de tempThreshold variabele bij wanneer de gewenste eigenschap van de module-tweeling wordt gewijzigd. Alle modules hebben een eigen moduledubbel, waarmee u de code kunt configureren die rechtstreeks vanuit de cloud in een module wordt uitgevoerd:

   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. Voeg de volgende regels toe aan de main methode na client.open() om de updates van de module-twin te abonneren:

   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. Sla het App.java bestand op.

8. Open in Visual Studio Code Explorer het bestand deployment.template.json in de werkruimte van de IoT Edge-oplossing.

9. Voeg de moduletweeling filtermodule toe aan het implementatiemanifest. Voeg de volgende JSON-inhoud onderaan de moduleContent-sectie in, na de $edgeHub tweelingmodule:

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

10. Sla het bestand deployment.template.json op.

1. Open modules > filtermodule > app.js in de Verkenner van Visual Studio Code.

2. Voeg een temperatuurdrempelvariabele toe aan het begin van app.js. De temperatuurdrempel bepaalt de waarde die de gemeten temperatuur moet overschrijden om de gegevens naar IoT Hub te kunnen verzenden:

   var temperatureThreshold = 25;
   

3. Vervang de hele PipeMessage functie door de FilterMessage functie.

   // 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. Vervang de functienaam pipeMessage door filterMessage in de client.on() aanroep:

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

5. Kopieer de volgende code in de callback van de client.open() functie, na client.on() de else instructie. Deze functie wordt aangeroepen wanneer de gewenste eigenschappen worden bijgewerkt:

   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. Sla het bestand app.js op.

7. Open in Visual Studio Code Explorer het bestand deployment.template.json in de werkruimte van de IoT Edge-oplossing.

8. Voeg de moduletweeling filtermodule toe aan het implementatiemanifest. Voeg de volgende JSON-inhoud onder aan de sectie moduleContent in, na de moduledubbel $edgeHub:

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

9. Sla het bestand deployment.template.json op.

Voeg in deze sectie de code toe waarmee de filtermodule wordt uitgebreid om de berichten te analyseren voordat u ze verzendt. U voegt code toe waarmee berichten worden gefilterd waarbij de gerapporteerde temperatuur van de machine binnen de acceptabele limieten valt.

1. Open in de Visual Studio Code Explorer modules > filtermodule > main.py.

2. Importeer bovenaan het main.py-bestand de JSON-bibliotheek:

   import json
   

3. Voeg globale definities toe voor de variabelen TEMPERATURE_THRESHOLD, RECEIVED_MESSAGES en TWIN_CALLBACKS . De temperatuurdrempel bepaalt de waarde die de gemeten machinetemperatuur moet overschrijden voordat de gegevens naar de IoT Hub worden verzonden:

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

4. Vervang de create_client functie door de volgende code:

   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. Sla het bestand main.py op.

6. Open in Visual Studio Code Explorer het bestand deployment.template.json in de werkruimte van de IoT Edge-oplossing.

7. Voeg de moduletweeling filtermodule toe aan het implementatiemanifest. Voeg de volgende JSON-inhoud onderaan de modulesContent-sectie in, na de $edgeHub tweelingmodule:

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

8. Sla het bestand deployment.template.json op.