IoT en C# : développer avec .NET nanoFramework

Pourquoi utiliser C# dans un projet IoT ?

L’IoT en C# permet de prototyper une solution connectée sans changer de langage entre le microcontrôleur, les services applicatifs et l’interface utilisateur. .NET nanoFramework exécute du code C# sur des cartes contraintes comme l’ESP32 ; ASP.NET Core peut traiter ou exposer les données ; .NET MAUI peut les présenter dans une application mobile ou desktop.

Cette continuité ne rend pas C# supérieur dans tous les cas. Un système très contraint, soumis à des délais temps réel stricts ou à une consommation minimale pourra rester plus adapté à C ou C++. En revanche, lorsque la maintenabilité, les outils de développement et la mutualisation des compétences .NET comptent, C# devient une option crédible.

Nous allons voir ce que C# apporte à un projet IoT,préparer un ESP32 avec .NET nanoFramework, lire un capteur DHT11, puis situer .NET MAUI dans une architecture complète.

‍

Ce que C# apporte au développement IoT

Le principal avantage est la cohérence de l’écosystème. Le langage, le système de types et une partie des pratiques de test restent familiers d’une couche à l’autre. Les développeurs peuvent aussi s’appuyer sur Visual Studio, NuGet et un débogueur intégré. Sur le microcontrôleur, .NETnanoFramework fournit un environnement d’exécution réduit et reprend une partie des API connues de .NET IoT. Dans la pratique, cela apporte trois bénéfices :

• Une prise en main rapide pour une équipe déjà familière de C# et de .NET ;
• Un code plus expressif pour organiser les lectures de capteurs, les protocoles et les règles métier ;
• Une chaîne de développement homogène, du prototype embarqué jusqu’au service et à l’interface ;

L’interopérabilité avec du code natif existe dans l’écosystème .NET complet, mais elle ne doit pas être transposée telle quelle à un microcontrôleur. Sur .NET nanoFramework, il faut raisonner à partir des bibliothèques et des pilotes réellement disponibles pour la carte choisie.

Le projet .NET nanoFramework est open source, soutenu parla .NET Foundation et annonce plus de 15 millions de téléchargements de paquets NuGet. Il prend en charge plusieurs familles de cartes, dont ESP32, STM32, TI,NXP et Silicon Labs. Son écosystème reste toutefois plus restreint que celui d’Arduino.

‍

Une architecture IoT en C# en trois couches

Pour éviter les raccourcis, séparons les responsabilités :

• Objet connecté — l’ESP32 lit les capteurs et exécute le code embarqué avec .NET nanoFramework :
• Transport — les mesures circulent par Wi-Fi, Bluetooth Low Energy, MQTT, HTTP ou, pour unprototype local, par une liaison série ;
• Application — un service ASP.NET Core centralise éventuellement les données, tandis qu’une interface .NET MAUI les affiche sur Android, iOS, macOS ou Windows.

Cette séparation évite de coupler l’interface au matériel. Elle permet aussi de remplacer le transport ou le capteur sans réécrire toute l’application.

‍

Tutoriel : lire un DHT11 avec unESP32 et .NET nanoFramework

L’exemple suivant valide la première couche de l’architecture : lire la température et l’humidité sur un ESP32. Il constitue un point de départ, pas un produit prêt pour la production.

‍

Matériel et prérequis

• Une carte ESP32 compatible avec .NET nanoFramework ;
• Un capteur DHT11 ou DHT22 ;
• Une résistance de tirage si le module n’en intègre pas ;
• Des câbles et un câble USB capable de transmettre des données ;
• Un poste Windows avec Visual Studio 2022 et l’extension .NET nanoFramework.

‍

1. Installer les outils et flasher le firmware

Installez d’abord Visual Studio 2022 et l’extension .NET nanoFramework. La documentation officielle propose ensuite nanoff, un outil en ligne de commande qui télécharge et flashe le firmware adapté à la carte.

dotnet tool install -g nanoff
nanoff --platform esp32 --serialport COM31 --update

‍

Remplacez COM31 par le port série réellement attribué à votre ESP32. Si la carte n’est pas reconnue, vérifiez le câble USB, le pilote du convertisseur série et le modèle de carte avant de relancer la commande.

‍

2. Créer le projet et ajouter les paquets

Dans Visual Studio, créez un projet .NET nanoFramework,ouvrez Device Explorer et sélectionnez l’ESP32 détecté. Ajoutez ensuite les paquets NuGet nécessaires au modèle de capteur, notamment nanoFramework.Iot.Device.Dhtxx.Esp32. Cette variante s’appuie sur le périphérique RMT de l’ESP32 ; elle est préférable à la bibliothèque DHT générique sur cette plateforme.

‍

3. Lire la température et l’humidité

Le numéro de broche doit correspondre au câblage réel. Pour un DHT22, remplacez Dht11 par Dht22. La lecture est espacée de deux secondes afin de respecter le rythme lent de ce type de capteur.

using System.Diagnostics;
using System.Threading;
using Iot.Device.DHTxx.Esp32;

public class Program
{
    public static void Main()
    {
        const int sensorPin = 26; // À adapter au câblage réel

        using Dht11 sensor = new(sensorPin);

        while (true)
        {
            var temperature = sensor.Temperature;
            var humidity = sensor.Humidity;

            if (sensor.IsLastReadSuccessful)
            {
                Debug.WriteLine(
                    $"Température : {temperature.DegreesCelsius:F1} °C ; " +
                    $"humidité : {humidity.Percent:F1} %");
            }
            else
            {
                Debug.WriteLine("Lecture du capteur impossible.");
            }

            Thread.Sleep(2000);
        }
    }
}

‍

4. Déployer et vérifier la mesure

Avant d’ajouter le réseau ou l’interface, stabilisez la lecture locale du capteur. Cela réduit le nombre de causes possibles en cas d’anomalie.

1. Dans Device Explorer, sélectionnez la carte cible ;
2. Compilez puis lancez le déploiement avec F5 pour déboguer, ou Ctrl + F5 pour exécuter sans débogage ;
3. Contrôlez les valeurs dans la fenêtre Output de Visual Studio ;
4. Testez plusieurs lectures et vérifiez qu’une erreur reste visible lorsque le capteur est débranché.

‍

Afficher les mesures dans une application .NET MAUI

.NET MAUI permet de construire une interface commune pour Android, iOS, macOS et Windows. Le transport des données doit néanmoins être isolé dans un service adapté à chaque scénario. Une liaison série directe peut convenir à une démonstration Windows reliée en USB ; pour une application réellement mobile, Wi-Fi, HTTP, MQTT ou Bluetooth Low Energy seront généralement plus pertinents.

La page ne devrait donc recevoir qu’une mesure déjà validée par la couche de communication. Elle peut ensuite mettre à jour l’interface sur le thread principal :

using Microsoft.Maui.ApplicationModel;

private void DisplayReading(double temperatureCelsius)
{
    MainThread.BeginInvokeOnMainThread(() =>
    {
        temperatureLabel.Text =
            $"Température : {temperatureCelsius:F1} °C";
    });
}

‍

Cette séparation rend le code plus testable : le service de transport reçoit et convertit les données ; la page se concentre sur l’affichage. Elle facilite aussi le passage d’un prototype USB à une architecture réseau.

‍

C#, C++ ou MicroPython : comment choisir ?

Le choix du langage dépend d’abord des contraintes du produit et des compétences de l’équipe. Le tableau ci-dessous donne des repères, sans prétendre couvrir toutes les cartes ni tous les environnements.

Quand choisir C# pour l’IoT ?

C# est particulièrement pertinent lorsque l’équipe maîtrise déjà .NET, souhaite partager ses pratiques entre l’embarqué, le backend et l’interface, ou doit livrer rapidement un prototype maintenable. Il convient aussi lorsque la carte et les périphériques nécessaires sont bien couverts par .NET nanoFramework.

À l’inverse, C ou C++ garderont l’avantage pour un matériel très limité, des contraintes temps réel fortes ou un besoin de contrôle maximal. MicroPython reste attractif pour l’apprentissage et les prototypes courts. Rust et TinyGo peuvent également être étudiés, mais leur pertinence dépend du support matériel et de la maturité des bibliothèques attendues.

‍

Conclusion

L’IoT en C# constitue une voie pragmatique pour les équipes qui veulent capitaliser sur .NET. .NET nanoFramework couvre la couche embarquée sur des cartes compatibles ; ASP.NET Core et .NET MAUI prolongent la solution côté services et interfaces. La réussite du projet dépend toutefois du bon découpage entre objet, transport et application — ainsi que d’une vérification précoce du support matériel.

Vous préparez un prototype ou une architecture d’objets connectés ? Découvrez l’expertise IoT et systèmes embarqués d’ELEPHANT Technologies, ou échangez avec nos équipes sur un accompagnement sur mesure.

‍

Pour aller plus loin

• Le C++ n’a pas dit son dernier mot ;
• Rust et l’industrie automobile ;
• Documentation.NET nanoFramework ;
• Démarrer avec .NET nanoFramework dans Visual Studio ;
• Bibliothèque DHTxx pour ESP32 ;
• Plateformes prises en charge par .NET MAUI.

‍