Archives par mot-clé : A4A

A4A est l’acronyme de « Ada for Automation », un cadriciel pour développer des applications d’automatisme évoluées dans le langage Ada.

A4A : Conteneur Docker

Bonjour,

Docker

J’indiquais dans l’article précédent que, sur les solutions netIOT Edge de Hilscher, Docker permet d’intégrer toutes sortes d’applications pour traiter les données acquises depuis le terrain ou le process avant de fournir celles-ci digérées aux applications hébergées dans le fameux nuage d’où doit pleuvoir la manne.

C’est aussi valable pour le netPI comme pour le Raspberry Pi sur lequel il est tout à fait possible d’installer Docker.

Il est bien sûr indispensable de se familiariser avec Docker puis de consulter la documentation pour comprendre les concepts.

Avec Docker, une application est empaquetée avec l’environnement nécessaire à son exécution dans une image que l’on va pouvoir instancier en conteneur(s) que Docker va exécuter.

On peut voir cela comme une approche composant où l’on isole chaque application et son environnement.

Pour le netPI, Hilscher offre nombre d’images prêtes à l’emploi sur le Hub communautaire où figurent également la plupart des projets  open source.

Ces images sont construites à partir de recettes, les docker files, et tous les fichiers pour les images fournies sont disponibles sur GitHub.

Dockerfile

Afin de me former sur ces technologies bien attirantes il m’est apparu que j’avais un projet candidat à la conteneurisation, Ada for Automation bien sûr !

J’ai donc installé Docker sur mon Raspberry Pi et, en m’inspirant des Dockerfiles de mes collègues, j’en ai écrit un basique que je vous présente ci-dessous.

#use latest armv7hf compatible raspbian OS version from group balena as base image
FROM balenalib/armv7hf-debian:stretch

#enable building ARM container on x86 machinery on the web (comment out next line if built on Raspberry)
#RUN [ "cross-build-start" ]

#labeling
LABEL maintainer="slos@hilscher.com" \
      version="V0.0.1" \
      description="Debian(stretch) / Ada for Automation Development"

#version
ENV ADA_FOR_AUTOMATION_BASIS_DEV_VERSION 0.0.1

#install ssh, gcc, create user "pi" and make him sudo
RUN apt-get update  \
    && apt-get install -y openssh-server build-essential \
    && mkdir /var/run/sshd \
    && useradd --create-home --shell /bin/bash pi \
    && echo 'pi:raspberry' | chpasswd \
    && adduser pi sudo
   
#install git, gnat and gprbuild
RUN apt-get update  \
    && apt-get install git gnat gprbuild

#install libmodbus
RUN apt-get update  \
    && apt-get install libmodbus5 libmodbus-dev

#install Ada for Automation and build some demo applications
RUN mkdir --parents /home/pi/Ada \
    && cd /home/pi/Ada \
    && git clone https://gitlab.com/ada-for-automation/ada-for-automation.git A4A \
    && cd "/home/pi/Ada/A4A/demo/000 a4a-k0-cli" && make

#SSH port
EXPOSE 22

#the entrypoint shall start ssh
ENTRYPOINT ["/usr/sbin/sshd", "-D"]

#set STOPSGINAL
STOPSIGNAL SIGTERM

#stop processing ARM emulation (comment out next line if built on Raspberry)
#RUN [ "cross-build-end" ]

Celui-ci, à partir d’une debian stretch, installe SSH, GCC, Git, les outils pour Ada GNAT, GPRBuild, et la librairie libmodbus.

Pour finir, il tire « Ada for Automation » depuis gitlab et compile la plus simple des applications qui implémente un serveur Modbus TCP et recopie quelques registres en entrée sur quelques registres en sortie.

Image

Construire l’image est trivial. Depuis le répertoire contenant le Dockerfile, il suffit de saisir la commande :

docker build --tag=rpi-a4a-basis-dev:latest .

Cette commande construit donc une image ayant pour nom « rpi-a4a-basis-dev » et taguée « latest » depuis le répertoire courant.

La commande suivante permet de lister les images produites :

docker image ls -a

Conteneur

On peut bien sûr créer aussitôt un conteneur à partir de cette image avec la commande suivante :

docker container create --publish 22:22 -p 1503:1503 --privileged rpi-a4a-basis-dev:latest

On publie le port 22 pour SSH et le port 1503 pour Modbus TCP Serveur et on octroie le privilège de pouvoir tourner avec une priorité temps réel si nécessaire.

Notre conteneur est créé comme nous pouvons le constater avec la commande qui nous donne le nom qui lui a été affecté automatiquement :

docker container ls -a

Et on peut s’en servir dès à présent :

docker container start <nom_du_conteneur>

Un ssh en local ou distant permet de se connecter à notre conteneur, de naviguer en ligne de commande dans l’arborescence et de démarrer l’application de démonstration.

Empiler

Notre conteneur basique permet de réaliser des applications avec une interface en ligne de commande, sans interface graphique basée sur GtkAda ou Gnoga.

Avec Docker, il est facile d’empiler une nouvelle couche pour étendre la fonctionnalité.

Ainsi, le dockerfile suivant ajoute à l’image de base Gnoga et ses dépendances, SimpleComponents et Zanyblue, et compile l’application A4A_Piano qui dispose d’une interface web.

#use latest Ada for Automation Basis Development as base image
FROM rpi-a4a-basis-dev:latest

#enable building ARM container on x86 machinery on the web (comment out next line if built on Raspberry)
#RUN [ "cross-build-start" ]

#labeling
LABEL maintainer="slos@hilscher.com" \
      version="V0.0.1" \
      description="Debian(stretch) / Ada for Automation Web Development"

#version
ENV ADA_FOR_AUTOMATION_WEB_DEV_VERSION 0.0.1

#install Gnoga and dependencies (Simple Components, ZanyBlue)
RUN mkdir --parents /home/pi/Ada/Gnoga \
    &amp;&amp; cd /home/pi/Ada/Gnoga \
    &amp;&amp; git clone https://git.code.sf.net/p/gnoga/code gnoga \
    &amp;&amp; cd /home/pi/Ada/Gnoga/gnoga \
    &amp;&amp; make release \
    &amp;&amp; make install

#build some Ada for Automation Web demo applications
RUN cd "/home/pi/Ada/A4A/demo/010 a4a_piano" &amp;&amp; make

#SSH port
EXPOSE 22

#the entrypoint shall start ssh
ENTRYPOINT ["/usr/sbin/sshd", "-D"]

#set STOPSGINAL
STOPSIGNAL SIGTERM

#stop processing ARM emulation (comment out next line if built on Raspberry)
#RUN [ "cross-build-end" ]

On construit l’image de la même façon que la précédente :

docker build --tag=rpi-a4a-web-dev:latest .

Puis on crée le conteneur avec un port supplémentaire pour le serveur web intégré :

docker container create --publish 22:22 -p 1504:1504 -p 8081:8081 --privileged rpi-a4a-web-dev:latest

On démarre le conteneur :

docker container start <nom_du_conteneur>

Un ssh en local ou distant permet de se connecter à notre conteneur, de naviguer en ligne de commande dans l’arborescence et de démarrer l’application de démonstration.

Et en pointant un navigateur sur l’adresse du site on trouve les pages attendues !

Tandis qu’on peut jouer avec :

Il ne me reste plus qu’à y envoyer dans mon espace du Hub Docker.

Taguons nos images :

docker tag rpi-a4a-basis-dev soloist/rpi-a4a-basis-dev:latest
docker tag rpi-a4a-web-dev soloist/rpi-a4a-web-dev:latest

Connectons nous :

docker login

Et poussons :

docker push soloist/rpi-a4a-basis-dev
docker push soloist/rpi-a4a-web-dev

C’est prêt pour une utilisation avec votre Raspberry Pi ou le netPI !

Cordialement,
Stéphane

A4A : Pilotage d’un variateur en EtherCAT

Bonjour,

J’espérais à voix haute pouvoir réaliser des manipulations avec un variateur communiquant en CANopen ou EtherCAT et mon souhait a été exaucé par un ami travaillant chez INFRANOR à Lourdes qui a bien voulu mettre à ma disposition un banc de test composé d’un variateur et d’un ensemble moteur / codeur… Miracle !

Je l’en remercie très chaleureusement !

Le banc est équipé d’un variateur XtrapulsPac et l’on peut depuis le site télécharger bien sûr la documentation, le logiciel de configuration Gem Drive Studio, le fichier ESI EtherCAT, en bref tout le nécessaire pour la manipulation.

Je n’ai pas rencontré de problème particulier avec Gem Drive Studio et j’ai pu configurer, régler le variateur et me familiariser avec son fonctionnement via la liaison série.

Pour ma démonstration, le PC de test étant un peu ancien, j’ai utilisé une carte Hilscher cifX au format PCI.

On peut télécharger une archive du DVD contenant la documentation, les outils de configuration et les firmwares ici.

Cependant, je préfère me fournir dans la base de connaissance qui dispose des dernières versions…

Ainsi, il est possible de se procurer la dernière version de l’outil de configuration SYCON.net.

Il est aussi possible de récupérer le dernier firmware EtherCAT Master .

On a donc importé dans SYCON.net le fichier ESI du variateur, menu « Network > Import Device Descriptions… », ne pas oublier de sélectionner le type de fichier « EtherCAT DDF », inséré l’esclave EtherCAT sur le réseau de la cifX configurée en EtherCAT Maitre et sélectionné les PDO en entrée et sortie pour un fonctionnement en boucle de vitesse.

Côté EtherCAT Maitre, dans la mémoire process de la carte Hilscher cifX donc, on retrouve les données d’entrée et sortie correspondantes :

Gem Drive Studio comme SYCON.net fonctionnent sous Microsoft Windows(R).

Cependant notre application va s’exécuter sous Linux avec les modifications PREEMPT_RT permettant d’obtenir un comportement temps réel.
Nous récupérerons donc les fichiers de firmware et de configuration pour les disposer dans l’arborescence du pilote cifX pour Linux.

Je travaille principalement sur des systèmes Debian et sur cet OS il existe un noyau Linux déjà compilé avec les patches PREEMPT_RT qui n’est donc qu’à une portée de clics ou d’une ligne de commande.
Cherchez « linux-image-rt » dans votre outil habituel et tant que vous y êtes installez également les en-têtes correspondants qui seront nécessaires pour la compilation du pilote Hilscher cifX qui n’est fourni que sous forme de code source.

Une fois installé, il suffit de redémarrer la machine en sélectionnant ce noyau.

Compilez ensuite le pilote comme expliqué dans la documentation relative. Ce pilote est en deux parties, l’une en espace noyau, uio_netx, qu’il vous faudra recompiler à chaque mise à jour du noyau, l’autre en espace utilisateur, la libcifx, qui est l’API pour votre application.

Voyez également la documentation pour l’utilisation du module si vous voulez vous passer de l’incantation en « root » :

modprobe -v uio_netx

Si tout ce passe bien, l’incantation fournit un résultat tel que :

On a disposé firmware et configuration dans le dossier idoine, par exemple :

Vous avez bien sûr installé « Ada for Automation », les dépendances et les outils pour le développement et vous avez navigué vers le répertoire contenant la démonstration « 122 ap7-wui ».
Un simple « make » doit vous permettre de générer l’application dont il est question dans cet article.

Cette application nécessite des droits spécifiques pour tourner avec des priorités temps réel.
Aussi il faut faire partie du groupe dédié ou être « root » pour pouvoir l’exécuter.

Cela démarre sur les chapeaux de roues en laissant une trace de ce style dans la console :

root@hf-test-2:/home/slos/Ada/A4A/demo/122 app7-wui# ./bin/App7_WUI_cifX
error
Log_Level = LEVEL_ERROR
2018-12-17 14:43:29.94 => A4A.Kernel.Sig_Handler : Waiting Signal Interrupt... Use Ctrl+C to exit
2018-12-17 14:43:29.94 => A4A.Kernel.Main_Task : Main_Task's ID is the_main_task_00005579443C2E50
Started at 2018-12-17 14:43:29.94
2018-12-17 14:43:29.94 => A4A.Generic_Periodic_Task : started !
2018-12-17 14:43:29.94 => A4A.Kernel.Main_Task : Initialising cifX Driver...
2018-12-17 14:43:31.61 => A4A.Kernel.Main_Task : Opening cifX Driver...
2018-12-17 14:43:31.61 => A4A.Kernel.Main_Task : Starting cifX TCP Server...
2018-12-17 14:43:31.61 => A4A.Kernel.Main_Task :
***********************************************
          Driver Information
Version     : cifX Toolkit 1.2.0.0
Board Count :  1
***********************************************

2018-12-17 14:43:31.61 => A4A.Kernel.Main_Task : Waiting for the firmware to start...
2018-12-17 14:43:36.61 => A4A.Kernel.Main_Task : Opening cifX Channel...
2018-12-17 14:43:36.61 => A4A.Kernel.Main_Task :
***********************************************
          Channel Information
Board_Name    : cifX0
Board Alias   : ECM
Device Number :  1250100
Serial Number :  20952

Firmware : EtherCAT Master
Version  :  4. 4. 9(Build  0)
Date     :  2018- 10- 10
***********************************************

2018-12-17 14:43:36.61 => A4A.Kernel.Main_Task : Setting Flag Host Ready...
2018-12-17 14:43:36.61 => A4A.Kernel.Main_Task : Setting Flag Bus On...
2018-12-17 14:43:38.61 => A4A.Kernel.Main_Task : (16#800C0021#)COM-flag not set
2018-12-17 14:43:38.61 => A4A.Kernel.Main_Task : Initialising Channel Messaging...
2018-12-17 14:43:38.61 => A4A.Kernel.Main_Task : Getting DPM IO Info...
2018-12-17 14:43:39.11 => A4A.Kernel.Main_Task :
***********************************************
          DPM IO_Info

Number of IO Block Info    :  2

Input Area :
Type of sub block    :  2
Flags                :  17
Offset               :  0
Length               :  10

Output Area :
Type of sub block    :  2
Flags                :  18
Offset               :  0
Length               :  6
***********************************************

2018-12-17 14:43:39.11 => A4A.Kernel.Main_Task : Calling Cold_Start...
2018-12-17 14:43:39.11 => A4A.Kernel.Main_Task : (16#800C0021#)COM-flag not set
Gnoga            :1.2b
Application root :/home/slos/Ada/A4A/demo/122 app7-wui/
Executable at    :/home/slos/Ada/A4A/demo/122 app7-wui/bin/
HTML root        :/home/slos/Ada/A4A/demo/122 app7-wui/html/
Upload directory :/home/slos/Ada/A4A/demo/122 app7-wui/html/
Templates root   :/home/slos/Ada/A4A/demo/122 app7-wui/
/js  at          :/home/slos/Ada/A4A/demo/122 app7-wui/js/
/css at          :/home/slos/Ada/A4A/demo/122 app7-wui/css/
/img at          :/home/slos/Ada/A4A/demo/122 app7-wui/img/
Boot file        :000-boot.html
HTTP listen on   ::8091
Press Ctrl-C to close server.
2018-12-17 14:43:39.96 : HTTP Server Started

Si je pointe mon navigateur sur l’adresse locale et le port choisi (:8091 cf. la trace), je peux piloter le variateur depuis le mot de contrôle et observer un signal en dent de scie sur la consigne et la mesure…

… tandis que je mate une vidéo de lapin…

… ce qui charge ma vieille CPU comme une bête …

Dans cette vue de « htop » on voit bien les priorités des processes de l’application temps réel, notamment les deux avec la priorité -89 sont les tâches « main » et « periodic », une priorité normale en FIFO étant à -50, -89 est une priorité plutôt haute donc.

C’est ce qui permet à ces tâches de se comporter honnêtement :

Ainsi, la tâche « main », cadencée à 1 ms, subit une fois sur mille un dépassement de son heure d’activation.

La vue d’état de la cifX montre des informations classiques…


… que je peux vérifier également depuis SYCON.net sur un autre poste :

Car « Ada for Automation » implémente « netX Diagnostic and Remote Access » comme déjà évoqué.

J’espère bien trouver un peu de temps pour mener d’autres expérimentations comme implémenter quelques fonctions de Motion Control

Cordialement,
Stéphane

A4A : Raspberry Pi 3 / netHAT / PROFINET IO / Temps Réel

Bonjour,

L’article précédent présentait une mise en œuvre d’un module Hilscher netHAT configuré en PROFINET IO Device sur un Raspberry Pi 3. Ce module netHAT communiquait avec un automate SIEMENS S7 1500-PN PROFINET IO Contrôleur.

Pour illustrer la chose, la voici :

Raspberry Pi 3 / netHAT
Raspberry Pi 3 / netHAT

Le système d’exploitation est une Raspbian Stretch tout ce qu’il y a de plus standard :

Raspbian Stretch

Au-dessus de l’API cifX, fournie par le pilote Hilscher pour Linux, tourne une application exemple « Ada for Automation », le fameux Piano.

Cette application est configurée avec une tâche Main périodique avec une période de 50 ms et une priorité temps réel, ce que l’on peut constater aisément avec htop :

htop

Une priorité à 20 est une priorité non temps réel normale, à -50 c’est une priorité temps réel par défaut, à -89 une priorité temps réel élevée.

Et on relève que, en général, la période de 50 ms est respectée à +100 µs près, et dans environ 1 % des cas à moins de 2 ms près :

Scheduling Stats

Côté PROFINET IO Contrôleur, j’ai utilisé une carte cifX 50-RE Hilscher configurée bien sûr en PROFINET IO Controller avec SYCON.net, l’outil ad-hoc, et au-dessus également une application « Ada for Automation » mais avec une configuration non temps réel.

On constate tout de suite la différence au niveau ordonnancement des tâches :

Pour les besoins de la démo le netHAT remplace parfaitement le netRAPID évoqué sur ce blog.

Et vous pouvez retrouver cette démo vivante sur le portail :
http://ada4automation.slo-ist.fr/#app2

Ainsi, le temps réel sous Linux fonctionne plutôt bien, n’est-ce pas ?
Cela doit pouvoir convenir à bien des applications d’automatisme.

Cordialement,
Stéphane

A4A : Raspberry Pi 3 / netHAT / PROFINET IO

Bonjour,

Je disais donc dans mon dernier article qu’il fallait que je vous fasse une petite démonstration de l’utilisation du netHAT Hilscher avec un Raspberry Pi 3 et « Ada for Automation ».

Voilà donc une copie d’écran montrant l’application piano connectée, via le netHAT configuré en PROFINET IO Device, à un automate SIEMENS S7 1500-PN PROFINET IO Contrôleur :

Raspberry Pi 3 Ada for Automation netHAT
Raspberry Pi 3 Ada for Automation netHAT

On reconnait dans cette vue de TIA Portal les valeurs d’E/S affichées dans la vue ci-dessus, les bits de poids faible sont à gauche dans la vue du piano (b0 .. b7) :

netHAT TIA Portal Visu
netHAT TIA Portal Visu

La vue d’état cifX montre donc l’état du netHAT puisque celui-ci partage avec celle-ci, comme la plupart des produits Hilscher, l’API cifX, la Dual Port Memory, les piles de protocoles et l’OS.

La seule subtilité que j’ai rencontrée, c’est que la version du pilote Linux livrée avec le netHAT est plus récente que celle que j’utilisais jusqu’alors (la V1.1.0.0) et que l’architecture en a été revue.
En substance, un plugin permet maintenant de gérer la connexion via SPI et il n’est plus nécessaire de le gérer côté application. Le netHAT est directement vu comme une cifX.

netHAT cifX Status
netHAT cifX Status

Bien sûr, tout baigne côté automate aussi !

netHAT TIA Portal Network
netHAT TIA Portal Network

Une petite formation ? 😉

Cordialement,
Stéphane

Raspberry Pi 3 / SenseHAT / netHAT / netPi

Bonjour,

Je cherchais pour mes expériences une solution qui soit ludique, et aussi accessible à tout un chacun, et mes tribulations m’ont conduit à sélectionner un combo Raspberry Pi 3 + SenseHAT.

Hilscher France a donc fait l’acquisition de ces éléments chez KUBII :

Starter Kit Officiel Pi3
https://www.kubii.fr/fr/kits-raspberry-pi/1637-kit-demarrage-raspberry-pi3-3272496004207.html

Raspberry Pi Sense Hat
https://www.kubii.fr/fr/cartes-extension-cameras-raspberry-pi/1081-raspberry-pi-sense-hat-640522710799.html

Pourquoi donc un tel investissement me direz vous ?

Sans doute parce que depuis quelques temps cette plateforme économique et performante permet d’imaginer tout un tas d’utilisations dans ce qu’il est convenu d’appeler l’IoT, l’IIoT, Industry 4.0, etc…

Aussi, à l’instar de certains confrères, la société Hilscher a développé certains produits autour de cette plateforme comme le netHAT, le netPi et le Edge Gateway « Connect » :
https://www.netiot.com/interface/nethat/
https://www.netiot.com/netpi/industrial-raspberry-pi-3/
https://www.netiot.com/edge/

Hilscher innove en testant le canal de vente Amazon et l’on peut y acheter le netHAT et le netPi :
https://www.amazon.fr/Hilscher-NXHAT52-RTE-nethat-52-de-RTE/dp/B01MFH0FP9
https://www.amazon.fr/Industrial-Raspberry-Industry-Communication-4×1-2Ghz-Real-Time-Ethernet/dp/B0756XD2CN

Pour ces produits, Hilscher France n’assure pas de support.
Cependant, l’on peut vous proposer une formation !

Le netHAT est fourni avec un pilote Linux compilé, des firmwares en version limitée à 32 octets d’E/S pour EtherCAT, Ethernet/IP et PROFINET IO Device et bien sûr de la documentation.

Le tout s’installe sans encombre sur la Raspbian et ça tombe en marche comme sur le plan.

Vous pouvez donc vous familiariser avec la technologie Hilscher pour une quarantaine d’euros, ce qui est modique vous en conviendrez aisément.

Bien sûr, « Ada for Automation » peut tout à fait être utilisé avec le netHAT. J’y reviendrai bien sûr.

Avec un Raspberry Pi + un netHAT, on peut aussi tester le concept netPi et développer des applications qui tourneront sur le netPi sans modification.

Bref, je souhaitais monter une manipulation avec un Rasberry Pi 3, un SenseHAT pour des capteurs pas chers et un netHAT pour connecter ce bijou de technologie à votre automate préféré.

En fait, le SenseHAT et le netHAT ne peuvent pas se monter l’un sur l’autre comme on pourrait le penser de prime abord.

Je pensais développer un binding Ada pour le SenseHAT mais ce n’est pas si simple.
Le langage choisi par l’équipe Raspberry est plutôt le Python et la plupart des bibliothèques fournies pour les « HAT » sont en Python.
La bibliothèque disponible pour le SenseHAT est donc en Python aussi et utilise d’une part une bibliothèque en C++ qui gère nombre de capteurs et d’autre part le framebuffer pour les LEDs et un IO device pour le joystick.

Monsieur Phil Munts, que je remercie, m’a bien fait part de sa librairie :
http://git.munts.com/libsimpleio/ada/

Mais je voulais quelque chose de super vite fait et j’ai penché pour une solution mettant en œuvre un framework Modbus développé par un collègue, Monsieur Luc JEAN, que je remercie chaleureusement :
https://github.com/ljean/modbus-tk

Pourquoi donc ? « Ada for Automation » disposant de la fonctionnalité Modbus TCP Client et le framework permettant de réaliser très simplement un serveur Modbus TCP, il suffisait donc de raccrocher les données des capteurs dans les registres du serveur.

J’ai utilisé également ce bout de code qui m’a bien aidé, je remercie aussi son auteur :
https://frank-deng.github.io/python-kbhit.en.html

Le SenseHAT dispose d’une application de simulation avec interface graphique et il est possible d’utiliser celle-ci en lieu et place du matériel tel que dans l’exemple suivant.

SenseHAT Simu GUI
SenseHAT Simu GUI

On y démarre depuis un terminal :

python 3 sense-omb.py
python 3 sense-omb.py

Et on teste par exemple avec Modbus Poll :

Modbus Poll Example
Modbus Poll Example

En Python, c’est une vingtaine de lignes de code pour remonter température, pression, hygrométrie et cap :

#!/usr/bin/env python
# -*- coding: utf_8 -*-
"""
 Modbus TestKit: Implementation of Modbus protocol in python

 (C)2009 - Luc Jean - luc.jean@gmail.com
 (C)2009 - Apidev - http://www.apidev.fr

 This is distributed under GNU LGPL license, see license.txt
"""


import sys
import struct

import modbus_tk
import modbus_tk.defines as cst
from modbus_tk import modbus_tcp

from sense_emu import SenseHat

import kbhit, time;

sense = SenseHat()

def main():
    """main"""

    kbhit.init();
    running = True;

    logger = modbus_tk.utils.create_logger(name="console", record_format="%(message)s")

    try:
        #Create the server
        server = modbus_tcp.TcpServer(port=1502)
        logger.info("running...")
        logger.info("enter 'q' for closing the server")

        server.start()

        slave_1 = server.add_slave(1)
        slave_1.add_block('0', cst.HOLDING_REGISTERS, 0, 100)

        while running:
            if kbhit.kbhit():
                ch = kbhit.getch();
                if 'q' == ch:
                    running = False;

            slave_1.set_values('0', 0, struct.unpack('>HH', struct.pack('>f', sense.temp)))
            slave_1.set_values('0', 2, struct.unpack('>HH', struct.pack('>f', sense.pressure)))
            slave_1.set_values('0', 4, struct.unpack('>HH', struct.pack('>f', sense.humidity)))
            slave_1.set_values('0', 6, struct.unpack('>HH', struct.pack('>f', sense.compass)))

            time.sleep(0.1);

    finally:
        server.stop()
        kbhit.restore();

if __name__ == "__main__":
    main()

C’est naturellement pas très temps réel mais c’est très bien pour mon cas d’école.

Et en plus, on peut facilement imaginer de reproduire ce schéma avec d’autres HATs comme le « Automation HAT » par exemple :
https://shop.pimoroni.com/products/automation-hat

Vous pouvez donc remonter les données du SenseHAT vers votre automate préféré disposant d’une connectivité Modbus TCP Client.
Bon, en travaillant un peu, ça doit fonctionner dans les deux sens, hein !

Quid du netHAT ? Si on utilise l’application de simulation SenseHAT on peut bien sûr le mettre sur le même Raspberry Pi et se connecter en local.
Si l’on souhaite de vraies données physiques, il faudra l’installer sur un autre Raspberry Pi, et le faire communiquer avec le premier, toujours en Modbus TCP.
C’est trivial avec « Ada for Automation » et je vous le montrerai ce tantôt.

Cordialement,
Stéphane