Il y a quelques semaines, lors de notre article sur .NET Core et NuGet, nous vous avions promis un article sur l'utilisation de ces deux technos sur un Raspberry Pi. Chose promise chose due, cette semaine nous allons voir comment écrire une application .NET Core sous Windows et la déployer sur un Raspberry Pi.
L’application que nous allons réaliser est assez simple, on va afficher sur un Yocto-MaxiDisplay la valeur courante d'un capteur Yoctopuce. Nous allons tout d'abord développer et tester cette application sous Windows, et ensuite nous allons installer cette application sur un Raspberry Pi 3.
Visual Studio 2019
Comme Microsoft vient de sortir la version 2019 de Visual Studio, nous allons utiliser cette version, mais la procédure est la même pour les versions 2017 et 2015.
On commence donc par créer un nouveau projet Console APP (.NET Core).
Il faut créer un projet Console APP (.NET Core)
Il faut ensuite ajouter une dépendance à notre package NuGet.
Il faut ajouter une dépendance à notre package Nuget
Le code
Nous n'allons pas trop nous attarder sur le code de l'application car il est trivial, et nous avons déjà de nombreux articles qui expliquent en détails les fonctions que nous utilisons.
Au démarrage, le code vérifie qu'un senseur Yoctopuce est présent. Le code vérifie aussi qu'un Yocto-Display, Yocto-MaxiDisplay ou Yocto-MiniDisplay est présent. Ensuite, tant que ces deux modules sont connectés, on récupère la valeur ainsi que le nom du senseur et on affiche ces deux informations sur le Yocto-MaxiDisplay.
{
Console.WriteLine("Using Yoctopuce lib " + YAPI.GetAPIVersion());
string errsmg = "";
if (YAPI.RegisterHub("usb", ref errsmg) != YAPI.SUCCESS)
{
Console.WriteLine("Unable to register the USB port :" + errsmg);
return;
}
YSensor sensor = YSensor.FirstSensor();
if (sensor == null)
{
Console.WriteLine("No Yoctopuce sensor find on USB.");
return;
}
YDisplay display = YDisplay.FirstDisplay();
if (display == null)
{
Console.WriteLine("No Yoctopuce display find on USB.");
return;
}
// display clean up
display.resetAll();
YDisplayLayer l1 = display.get_displayLayer(1);
l1.hide(); // L1 is hidden, l2 stay visible
int w = display.get_displayWidth();
int h = display.get_displayHeight();
while (sensor.isOnline() && display.isOnline())
{
string value = sensor.get_currentValue() + " " + sensor.get_unit();
string name = sensor.get_friendlyName();
// display a text in the middle of the screen
l1.clear();
l1.selectFont("Large.yfm");
l1.drawText(w / 2, h / 2, YDisplayLayer.ALIGN.CENTER, value);
l1.selectFont("Small.yfm");
l1.drawText(w - 1, h - 1, YDisplayLayer.ALIGN.BOTTOM_RIGHT, name);
display.swapLayerContent(0, 1);
Console.WriteLine(name + " ->" + value);
YAPI.Sleep(500,ref errsmg);
}
YAPI.FreeAPI();
}
Cet exemple est assez primitif mais permet d’illustrer l'utilisation de notre librairie. Le projet complet est disponible sur GitHub: https://github.com/yoctopuce-examples/YoctoDotNetCore
Maintenant que notre projet et prêt, nous pouvons tester notre application sous Windows. Pour ce faire, il faut bien évidement brancher un Yocto-Display et un capteur Yoctopuce. Dans notre cas, nous avons utilisé un Yocto-Light-V3 et un Yocto-MaxiDisplay-G.
Maintenant que l'on a vérifié que notre code fonctionne sous Windows, regardons comment exécuter la même application sur un Raspberry Pi.
Générer une version pour Raspberry Pi
Depuis la version 2.1 du .NET Core, il est possible de générer un "exécutable" qui fonctionne sous Linux ARM. Il est même possible de générer un exécutable "Self-contained" qui contient notre application et la machine virtuelle .NET.
L'avantage de cette dernière option est qu'elle permet de d'inclure tout ce qui est nécessaire pour que l'application fonctionne, ce qui rend son installation plus facile.
Pour générer la version "Raspberry Pi", il faut "publier" notre application. Le wizard est accessible depuis le menu "build" dans Visual Studio.
Le menu build permet de publier l'application
Ce menu permet de configurer le type de package que l'on va publier. Pour notre cas, il faut créer un profile de type "Folder". Il faut ensuite éditer ce profile pour que les options suivantes soient sélectionnées:
- Target Framework: au minimum netcoreapp2.1
- Deployment Mode: Self-contained
- Target Runtime: linux-arm
Les paramètres de publication de l'application
Il ne reste plus qu'à cliquer sur le bouton Publish pour que Visual Studio compile l'application et copie tous les fichiers nécessaires dans le répertoire de sortie.
Un fois la compilation terminée, il ne reste plus qu'à copier tout le contenu du répertoire sur le Raspberry Pi 3. On peux utiliser SSH, FTP ou une simple clef USB.
Lancer l'application sur Raspberry Pi
Une fois le répertoire copié sur le Raspberry Pi, il y a encore une dernière opération à effectuer: ajouter les droits d’exécution à l'application. Cette dernière opération doit s'effectuer directement sur le Raspberry Pi.
On utilise simplement la commande chmod avec +x et l’exécutable comme argument.
pi@raspberrypi:~/publish $ chmod +x YoctoCoreDemo
On peut ensuite lancer directement l'application sans avoir à installer quoi que ce soit d'autre.
pi@raspberrypi:~/publish $ sudo ./YoctoCoreDemo ....
Pas besoin de package Mono ou de Runtime .NET, tout est inclus dans l'application. L'application est directement utilisable sur une image Raspbian.
Et voilà, nous avons notre application qui fonctionne sous Raspberry Pi.
La même application qui tourne sur Raspberry Pi
Conclusion
Comme nous venons de le voir, il est très facile de porter une application .NET Core sur Raspberry Pi. Le fait de pouvoir développer l'application sous Windows et ensuite la déployer sur une image standard de Raspberry Pi est très pratique. Cela devient tout aussi facile si ce n'est plus que d'écrire un script Python.
Il y toutefois quelques informations à garder en tête.
Seuls les Raspberry Pi 2, 3 et 3+ sont supportés par .NET Core. Il n'est pour l'instant pas possible d'utiliser les Raspberry Pi Zero.
Actuellement, il n'est pas possible de créer des applications graphiques portables à l'aide de .NET Core. Si vous avez besoin de réaliser une application graphique, c'est possible mais il faudra obligatoirement utiliser Mono. Nous avons du reste un article à ce sujet: Utiliser la librairie C# sous Linux et macOS avec Mono.
Nous avons utilisé Visual Studio pour réaliser cet exemple, mais il est aussi possible de réaliser et compiler la même application sous Linux ou macOS en installant le SDK .NET Core sur ces OS. Il faut ensuite utiliser l'utilitaire dotnet.
Pour finir, si vous n'avez pas l'habitude d'utiliser Linux, nous avons quelques articles qui pourraient vous intéresser:
- Comment débuter sous Linux avec des modules Yoctopuce
- Lancer une application au démarrage de Linux avec systemd
