教程：使用 Visual Studio Code 开发 IoT Edge 模块

• .NET Core SDK
• C# Visual Studio Code 扩展

• C/C++ Visual Studio Code 扩展
• 本教程不需要安装 Azure IoT C SDK，但它可提供有用的功能，如 IntelliSense 和读取程序定义。 有关安装信息，请参阅 Azure IoT C SDK 和库。

• Java SE 开发工具包 11 和 Maven。 需要设置环境变量JAVA_HOME以指向你的 JDK 安装。
• Maven
• Visual Studio Code 的 Java 扩展包

• Node.js。
• Yeoman
• Azure IoT Edge Node.js 模块生成器。

若要在 Python 中开发 IoT Edge 模块，请在开发计算机上安装以下额外的先决条件：

• Python 和 Pip。
• Cookiecutter。
• 适用于 Visual Studio Code 的 Python 扩展。

项目模板附带的示例 C# 代码使用适用于 .NET 的 IoT 中心 SDK 中的 ModuleClient 类 。

1. 在 Visual Studio Code 资源管理器中，打开 模块>filtermodule>ModuleBackgroundService.cs。

2. 在 filtermodule 命名空间之前，为稍后使用的类型添加三个 using 语句：

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

3. 将 temperatureThreshold 变量添加到 ModuleBackgroundService 类。 此变量设置测量的温度必须超过的值才能将数据发送到 IoT 中心。

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

4. 添加 MessageBody、Machine 和 Ambient 类。 这些类将为传入消息的正文定义所需的架构。

   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. 查找 ExecuteAsync 函数。 此函数可创建并配置 ModuleClient 对象，使模块能够连接到本地 Azure IoT Edge 运行时以发送和接收消息。 创建 ModuleClient 后，代码从模块孪生的所需属性中读取 temperatureThreshold 值。 代码注册一个回调，以通过名为 input1 的终结点从 IoT Edge 中心接收消息。

   将对 ProcessMessageAsync 方法的调用替换为一种新方法，以更新终结点名称以及在输入到达时调用的方法。 此外添加 SetDesiredPropertyUpdateCallbackAsync 方法用于更新所需属性。 若要进行此更改，请使用以下代码替换 ExecuteAsync 方法的最后一行：

   // 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 方法添加到 ModuleBackgroundService 类。 此方法从模块孪生接收所需属性的更新，并更新 temperatureThreshold 变量以匹配。 所有模块都有自己的孪生模块，因此可以直接从云配置在模块中运行的代码。

   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 方法。 每当模块从 IoT Edge 中心接收消息，就会调用此方法。 此方法筛选掉那些所报告温度低于温度阈值（通过孪生模块进行设置）的消息。 它还会将 MessageType 属性添加到消息中，并将值设置为 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. 保存 ModuleBackgroundService.cs 文件。

9. 在 Visual Studio Code 资源管理器的 IoT Edge 解决方案工作区中打开 deployment.template.json 文件。

10. 由于我们更改了模块侦听的终结点的名称，因此还需要更新部署清单中的路由，以便 edgeHub 将消息发送到新终结点。

    在 $edgeHub 模块孪生中找到 routes 节 。 更新 sensorTofiltermodule 路由以将 替换为 input1：

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

11. 将 filtermodule 模块孪生体添加至部署清单中。 在 modulesContent 节底部的 $edgeHub 模块孪生后面插入以下 JSON 内容：

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

12. 保存 deployment.template.json 文件。

1. 在此场景中，来自传感器的数据采用 JSON 格式。 若要筛选 JSON 格式的消息，请导入用于 C 的 JSON 库。本教程使用 Parson。

   1. 下载 Parson GitHub 存储库。 将 parson.c 和 parson.h 文件复制到 filtermodule 文件夹中。

   2. 打开 模块>filtermodule>CMakeLists.txt。 在文件的顶部，将 Parson 文件导入为名为 my_parson的库。

      add_library(my_parson
          parson.c
          parson.h
      )
      

   3. 将 my_parson 添加到 CMakeLists.txt 的 target_link_libraries 函数中的库列表。

   4. 保存 CMakeLists.txt 文件。

   5. 打开 模块>filtermodule>main.c。 在 include 语句列表的底部，添加一个新的语句，以便包括适用于 JSON 支持的 parson.h：

      #include "parson.h"
      

2. 在 main.c 文件中，在 include 节之后添加一个名为 temperatureThreshold 的全局变量。 此变量设置一个值，若要向 IoT 中心发送数据，测量的温度必须超出该值。

   static double temperatureThreshold = 25;
   

3. 在 main.c 中找到 CreateMessageInstance 函数。 将内部的 if-else 语句替换为以下代码，以添加几行功能：

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

   else 语句中的新代码行将一个新属性添加到消息，用于将消息标记为警报。 此代码将所有消息标记为警报，因为仅当报告了较高的温度时，我们要添加的功能才会向 IoT 中心发送消息。

4. 将整个 InputQueue1Callback 函数替换为以下代码。 此函数实现实际的消息传送筛选器。 收到消息后，它会检查报告的温度是否超过阈值。 如果超过了阈值，则通过其输出队列转发消息。 如果未超过阈值，则忽略消息。

   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. 添加 moduleTwinCallback 函数。 此方法从模块孪生接收所需属性的更新，并更新 temperatureThreshold 变量以匹配。 所有模块都有自己的孪生模块，因此可以直接从云配置在模块中运行的代码。

   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. 找到 SetupCallbacksForModule 函数。 将函数替换为以下代码，用于添加 else if 语句以检查模块孪生是否已更新。

   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. 保存 main.c 文件。

8. 在 Visual Studio Code 资源管理器的 IoT Edge 解决方案工作区中打开 deployment.template.json 文件。

9. 将 filtermodule 模块孪生添加到部署清单。 在 moduleContent 节底部 $edgeHub 模块孪生后插入以下 JSON 内容：

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

10. 保存 deployment.template.json 文件。

1. 在 Visual Studio Code 资源管理器中，打开 模块>filtermodule>src>main>java>com>edgemodule>App.java。

2. 在该文件顶部添加以下代码，以便导入新的引用的类。

   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. 将以下定义添加到类 App 中。 此变量设置温度阈值。 在测量的机器温度超过此值之前，不会向 IoT 中心报告此温度。

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

4. 将 MessageCallbackMqtt 的执行方法替换为以下代码。 每当模块从 IoT Edge 中心接收 MQTT 消息，就会调用此方法。 此方法筛选掉那些所报告温度低于温度阈值（通过孪生模块进行设置）的消息。

   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. 将以下两个静态内部类添加到类 App 中。 当模块孪生的所需属性发生更改时，这些类将更新 tempThreshold 变量。 所有模块都有自己的孪生模块，因此可以直接从云配置在模块中运行的代码。

   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. 在 client.open（） 之后将以下行添加到 main 方法中，以订阅模块孪生更新。

   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. 保存 App.java 文件。

8. 在 Visual Studio Code 资源管理器的 IoT Edge 解决方案工作区中打开 deployment.template.json 文件。

9. 将 filtermodule 模块孪生体添加至部署清单中。 在 moduleContent 节底部的 $edgeHub 模块孪生后面插入以下 JSON 内容：

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

10. 保存 deployment.template.json 文件。

1. 在 Visual Studio Code 资源管理器中，打开 模块>filtermodule>app.js。

2. 将温度阈值变量添加到 app.js 的开头。 温度阈值设置一个值，若要向 IoT 中心发送数据，测量的温度必须超出该值。

   var temperatureThreshold = 25;
   

3. 将整个 PipeMessage 函数替换为 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. 在 pipeMessage 调用中，将函数名称 filterMessage 替换为 client.on()。

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

5. 将以下代码片段复制到 client.open() 函数回调中，具体说来是在 client.on() 语句中的 else 后面。 更新所需属性时，会调用此函数。

   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. 保存 app.js 文件。

7. 在 Visual Studio Code 资源管理器的 IoT Edge 解决方案工作区中打开 deployment.template.json 文件。

8. 将 filtermodule 模块孪生添加到部署清单。 在 moduleContent 节底部 $edgeHub 模块孪生后插入以下 JSON 内容：

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

9. 保存 deployment.template.json 文件。

在本部分中，添加扩展 filtermodule 以在发送消息之前分析消息的代码。 需要添加代码来筛选报告的计算机温度在可接受范围内的消息。

1. 在 Visual Studio Code 资源管理器中，打开 模块>filtermodule>main.py。

2. 在 main.py 文件的顶部，导入 json 库：

   import json
   

3. 为 TEMPERATURE_THRESHOLD、RECEIVED_MESSAGES 和 TWIN_CALLBACKS 变量添加全局定义。 温度阈值设置测量的计算机温度必须超过的值，才能将数据发送到 IoT 中心。

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

4. 将 create_client 函数替换为以下代码：

   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. 保存 main.py 文件。

6. 在 Visual Studio Code 资源管理器的 IoT Edge 解决方案工作区中打开 deployment.template.json 文件。

7. 将 filtermodule 模块孪生体添加至部署清单中。 在 modulesContent 节底部的 $edgeHub 模块孪生后面插入以下 JSON 内容：

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

8. 保存 deployment.template.json 文件。