Zelfstudie: IoT Edge-modules ontwikkelen met 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 C-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 (Engelstalig).

De C#-voorbeeldcode die bij de projectsjabloon hoort, maakt gebruik van de ModuleClient-klasse van de IoT Hub SDK voor .NET.

1. Open >in Visual Studio Code Explorer ModuleBackgroundService.cs.

2. Voeg vóór de filtermodulenaamruimte 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 variabele temperatureThreshold toe aan de klasse ModuleBackgroundService . 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 klassen MessageBody, Machine en Ambient 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 de ModuleClient is gemaakt, leest de code de waarde van temperatureThreshold uit de gewenste eigenschappen van de moduledubbel. 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 methode die de naam van het eindpunt bijwerkt en de methode die wordt aangeroepen wanneer invoer binnenkomt. Voeg ook een SetDesiredPropertyUpdateCallbackAsync-methode toe voor updates aan de gewenste eigenschappen. Vervang de laatste regel van de ExecuteAsync-methode door de volgende code om deze wijziging aan te brengen:

   // 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 klasse ModuleBackgroundService . Deze methode ontvangt updates van de gewenste eigenschappen van de moduledubbel en updatet de variabele temperatureThreshold naar dezelfde waarde. 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 methode FilterMessages toe. Deze methode wordt aangeroepen wanneer de module een bericht ontvangt van de IoT Edge-hub. Berichten die temperaturen onder de drempelwaarde die via de moduledubbel is ingesteld, worden hierdoor gefilterd. Ook wordt de eigenschap BerichtType toegevoegd aan het bericht met de waarde ingesteld op Alarm.

   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 deployment.template.json-bestand in de werkruimte van uw 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 sectie Routes in de $edgeHub moduledubbel. Werk de sensorTofiltermodule-route bij om deze te vervangen door input1inputFromSensor:

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

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

       "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 boven in het bestand de Parson-bestanden als een bibliotheek met de naam my_parson.

      add_library(my_parson
          parson.c
          parson.h
      )
      

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

   4. Sla het bestand CMakeLists.txt op.

   5. Open modules>filtermodule>main.c. Voeg onder aan de lijst met insluitinstructies een nieuwe toe om parson.h voor JSON-ondersteuning op te nemen:

      #include "parson.h"
      

2. Voeg in het bestand main.c na de sectie include een globale variabele toe met de naam temperatureThreshold. Deze variabele bepaalt de waarde die de gemeten temperatuur moet overschrijden voordat de gegevens naar IoT Hub worden verzonden.

   static double temperatureThreshold = 25;
   

3. Zoek de functie CreateMessageInstance in main.c. Vervang de interne if-else-instructie door de volgende code waarmee een aantal regels functionaliteit wordt 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");
           }
       }
   

   Met de nieuwe regels code in de else-instructie wordt een nieuwe eigenschap toe aan het bericht toegevoegd, waardoor het bericht als een 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 er hoge temperaturen worden gerapporteerd.

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. Zo ja, dan wordt het bericht doorgestuurd via de uitvoerwachtrij. Zo nee, dan 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 van de gewenste eigenschappen van de moduledubbel en updatet de variabele temperatureThreshold naar dezelfde waarde. Alle modules hebben hun eigen moduledubbel, waardoor u rechtstreeks in de cloud de code kunt configureren die 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 waarmee een else if-instructie wordt toegevoegd om te controleren of de moduledubbel 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 deployment.template.json-bestand in de werkruimte van uw IoT Edge-oplossing.

9. Voeg de moduledubbel 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. Open in visual Studio Code Explorer modules>filtermodule>src>main>>

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

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

4. Vervang de execute-methode van MessageCallbackMqtt door de volgende code. Deze methode wordt aangeroepen wanneer de module een MQTT-bericht ontvangt van de IoT Edge-hub. Berichten die temperaturen onder de drempelwaarde die via de moduledubbel is ingesteld, worden hierdoor gefilterd.

   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 klasse App. Met deze klassen wordt de variabele tempThreshold bijgewerkt wanneer de gewenste eigenschap van de moduledubbel verandert. Alle modules hebben hun eigen moduledubbel, waardoor u rechtstreeks in de cloud de code kunt configureren die 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 module main, na client.open(), om u te abonneren op de updates van de moduledubbel.

   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 deployment.template.json-bestand in de werkruimte van uw IoT Edge-oplossing.

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

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

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

1. Open >in Visual Studio Code Explorer app.js.

2. Voeg een temperatuurdrempelvariabele toe aan het begin van app.js. De temperatuurdrempel bepaalt de waarde die de gemeten temperatuur moet overschrijden voordat de gegevens naar IoT Hub worden verzonden.

   var temperatureThreshold = 25;
   

3. Vervang de hele PipeMessage-functie door de functie 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. Vervang de functienaam pipeMessage door filterMessage in de client.on() aanroep.

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

5. Kopieer het volgende codefragment in de functieaanroep client.open(), na client.on() binnen de else-instructie. Deze functie wordt aangeroepen wanneer de gewenste eigenschappen zijn 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 deployment.template.json-bestand in de werkruimte van uw IoT Edge-oplossing.

8. Voeg de moduledubbel 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 >main.py.

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

   import json
   

3. Voeg globale definities toe voor variabelen voor 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 functie create_client 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 deployment.template.json-bestand in de werkruimte van uw IoT Edge-oplossing.

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

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

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