close

Articles Home » Programming Languages » C# and IoT: Developing Edge Applications with .NET and Azure IoT

C# and IoT: Developing Edge Applications with .NET and Azure IoT

The Internet of Things (IoT) has revolutionized the way we interact with the world around us. It allows devices to collect and exchange data, enabling automation and insights that were previously unimaginable. Edge applications play a crucial role in IoT, processing data closer to the source and providing real-time insights. In this article, we will explore how to develop edge applications using C#, .NET, and Azure IoT. With an emphasis on non-beginners, we will delve into the details of designing, building, and deploying these applications.

1. Understanding the IoT Landscape and Edge Applications

IoT refers to the network of interconnected devices that communicate and exchange data with each other. These devices, often called “things,” can include anything from sensors to appliances, vehicles, and more. Edge applications run on these devices or on gateways that aggregate data from multiple devices, enabling local processing and analytics.

Edge applications provide several advantages, such as:

  • Reduced latency: By processing data close to the source, edge applications can provide real-time insights and faster response times.
  • Bandwidth optimization: Local processing reduces the need to send large amounts of data to the cloud, conserving bandwidth and reducing costs.
  • Enhanced security and privacy: Edge applications can filter sensitive data before sending it to the cloud, ensuring data privacy and compliance with regulations.
  • Increased reliability: Local processing can continue even if connectivity to the cloud is lost, ensuring uninterrupted operations.

2. C# and .NET for IoT Development

C# is a versatile, object-oriented programming language that is part of the .NET ecosystem. It is widely used for a variety of applications, including web, desktop, and mobile. With the advent of .NET Core and .NET 5+, C# has become a popular choice for IoT development as well.

.NET provides a number of advantages for IoT developers:

  • Cross-platform support: .NET Core and .NET 5+ can run on multiple platforms, including Windows, Linux, and macOS, enabling IoT applications to target a wide range of devices.
  • Robust libraries: The .NET ecosystem offers a wealth of libraries and frameworks that simplify IoT development, such as IoT.Device.Bindings, which provides drivers for various sensors and peripherals.
  • Familiar development experience: For developers who are already familiar with C# and .NET, building IoT applications can be a natural extension of their existing skills.

3. Azure IoT: A Cloud Platform for IoT Solutions

Azure IoT is a suite of cloud services and tools designed specifically for IoT applications. It provides a comprehensive set of features that help developers build, deploy, and manage IoT solutions at scale. Some of the key components of Azure IoT include:

  • Azure IoT Hub: A managed service for bi-directional communication between IoT devices and the cloud, offering features such as device authentication, message routing, and device management.
  • Azure IoT Edge: A runtime that extends cloud intelligence to edge devices, enabling local processing and analytics using cloud-developed modules.
  • Azure IoT Central: A fully managed IoT application platform that simplifies the development and deployment of IoT solutions, providing customizable dashboards, device management, and analytics capabilities.

4. Developing Edge Applications with C#, .NET, and Azure IoT

To build an edge application with C#, .NET, and Azure IoT, follow these steps:

Step 1: Setting up the development environment

  • Install Visual Studio or Visual Studio Code, along with the .NET SDK for your target platform (e.g., .NET 5+ for cross-platform development).
  • Install the Azure IoT Edge extension for Visual Studio or Visual Studio Code to simplify the development and deployment of edge applications.

Step 2: Creating an IoT Edge solution

  • Create a new IoT Edge solution in Visual Studio or Visual Studio Code, which will generate a solution template with the necessary project files and configuration.
  • Add a new C# .NET Core or .NET 5+ IoT Edge module to the solution. This module will contain the code for your edge application.

Step 3: Developing the edge application

In the module’s Program.cs file, implement the desired functionality for your edge application. This can include:

  • Reading data from sensors or other connected devices using .NET libraries, such as IoT.Device.Bindings.
  • Processing and analyzing the data locally, using techniques such as data filtering, aggregation, or machine learning.
  • Communicating with other modules, devices, or the cloud using the Azure IoT Edge runtime’s built-in support for module-to-module and device-to-cloud messaging.

Step 4: Debugging and testing the edge application

  • Use the Azure IoT Edge extension’s built-in support for local debugging and testing to run and debug your edge application on your development machine.
  • Deploy the edge application to a physical or virtual IoT Edge device to test its behavior in a real-world environment.

Step 5: Deploying the edge application to production devices

  • Set up an Azure IoT Hub to manage the communication between your IoT devices and the cloud.
  • Create an Azure IoT Edge deployment manifest that defines the desired configuration for your edge devices, including the modules to be deployed and their respective settings.
  • Use the Azure Portal, Azure IoT Central, or Azure CLI to deploy the edge application to your production IoT devices, leveraging the IoT Hub’s device management capabilities.

5. Monitoring and Managing Edge Applications with Azure IoT

Once your edge application is deployed, it is crucial to monitor its performance and manage its lifecycle. Azure IoT provides various tools and services to help with this:

  • Azure Monitor: Collect, analyze, and visualize telemetry data from your IoT devices and edge applications to gain insights into their performance and identify potential issues.
  • Azure IoT Hub device management: Remotely manage the configuration, firmware updates, and security settings of your IoT devices using the IoT Hub’s built-in device management capabilities.
  • Azure IoT Central: Use the customizable dashboards and analytics features in IoT Central to monitor the performance of your IoT solution, detect anomalies, and visualize key performance indicators (KPIs).

Example Exercise: Monitoring and Controlling Smart Building Environment with C#, .NET, and Azure IoT

In this example, we will develop an edge application to monitor and control the environment inside a smart building. The application will collect data from sensors, process it locally, and send commands to actuators based on the processed data. We will use C#, .NET 5, and Azure IoT services for this exercise.

Requirements:

  1. Temperature and humidity sensors
  2. HVAC (heating, ventilation, and air conditioning) system with an IoT-enabled thermostat

Step 1: Create a new IoT Edge solution and module

Follow the steps described in the article to create a new IoT Edge solution and a C# .NET 5 IoT Edge module named “SmartBuildingEnvironment.”

Step 2: Add references to necessary libraries

In your SmartBuildingEnvironment.csproj file, add references to the following NuGet packages:

<ItemGroup>
  <PackageReference Include="Microsoft.Azure.Devices.Client" Version="1.39.0" />
  <PackageReference Include="System.Device.Gpio" Version="1.5.0" />
  <PackageReference Include="Iot.Device.Bindings" Version="1.5.0" />
</ItemGroup>
Code language: C# (cs)

Step 3: Implement the edge application

Replace the content of the Program.cs file with the following code:

using System;
using System.Device.I2c;
using System.Threading.Tasks;
using Iot.Device.Bmxx80;
using Microsoft.Azure.Devices.Client;
using Microsoft.Azure.Devices.Shared;
using Microsoft.Extensions.Logging;

namespace SmartBuildingEnvironment
{
    class Program
    {
        private static ModuleClient _moduleClient;
        private static readonly ILogger _logger = LoggerFactory.Create(builder => builder.AddConsole()).CreateLogger<Program>();

        public static async Task<int> Main(string[] args)
        {
            try
            {
                _logger.LogInformation("Initializing Azure IoT Edge module...");

                _moduleClient = await ModuleClient.CreateFromEnvironmentAsync(TransportType.Mqtt);
                await _moduleClient.OpenAsync();

                await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null);

                var twin = await _moduleClient.GetTwinAsync();
                await OnDesiredPropertyChanged(twin.Properties.Desired, null);

                _logger.LogInformation("Starting the environment monitoring loop...");

                using (var i2cDevice = I2cDevice.Create(new I2cConnectionSettings(1, Bme280.DefaultI2cAddress)))
                using (var bme280 = new Bme280(i2cDevice))
                {
                    while (true)
                    {
                        var temperature = bme280.ReadTemperature();
                        var humidity = bme280.ReadHumidity();

                        _logger.LogInformation($"Temperature: {temperature.DegreesCelsius} °C, Humidity: {humidity.Percent} %");

                        await SendEnvironmentDataAsync(temperature.DegreesCelsius, humidity.Percent);

                        await Task.Delay(TimeSpan.FromSeconds(10));
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred during edge module execution");
                return 1;
            }
        }

        private static async Task OnDesiredPropertyChanged(TwinCollection desiredProperties, object userContext)
        {
            if (desiredProperties.Contains("targetTemperature"))
            {
                double targetTemperature = desiredProperties["targetTemperature"];
                _logger.LogInformation($"Received desired property update: targetTemperature = {targetTemperature} °C");

                // Code to control HVAC system based on the target temperature
            }
        }

        private static async Task SendEnvironmentDataAsync(double temperature, double humidity)
        {
            var message = new Message(System.Text.Encoding.UTF8.GetBytes($"{{\"temperature\": {temperature}, \"humidity\": {humidity}}}"));
            await _moduleClient.SendEventAsync("output1", message);

            _logger.LogInformation($"Sent environment data to IoT Hub: temperature = {temperature} °C, humidity = {humidity} %");
        }
    }
}
Code language: C# (cs)

This code initializes an Azure IoT Edge module that collects temperature and humidity data from a BME280 sensor and sends the data to the IoT Hub. It also listens for desired property updates containing a target temperature, which can be used to control an HVAC system.

Step 4: Debugging and testing the edge application

Use the Azure IoT Edge extension’s built-in support for local debugging and testing to run and debug the edge application on your development machine. Deploy the edge application to a physical or virtual IoT Edge device to test its behavior in a real-world environment.

Step 5: Deploying the edge application to production devices

Follow the steps described in the article to deploy the edge application to your production IoT devices using Azure IoT Hub.

Step 6: Monitoring and managing the edge application

Use the Azure Monitor, Azure IoT Hub device management, and Azure IoT Central tools to monitor the performance of your IoT solution, detect anomalies, and visualize key performance indicators (KPIs). Ensure that your edge application is functioning correctly and efficiently by monitoring the temperature and humidity data collected from the BME280 sensor and the control signals sent to the HVAC system.

Conclusion:

In this example exercise, we developed an edge application using C#, .NET 5, and Azure IoT services to monitor and control the environment inside a smart building. The edge application collects data from temperature and humidity sensors, processes the data locally, and sends commands to the HVAC system based on the processed data. This exercise demonstrates the power and flexibility of using C#, .NET, and Azure IoT for building complex IoT solutions. By following these steps, developers can create, deploy, and manage edge applications that efficiently process sensor data and provide intelligent control for IoT systems.

Related posts: