Archives de catégorie : netPi

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 \
    && cd /home/pi/Ada/Gnoga \
    && git clone https://git.code.sf.net/p/gnoga/code gnoga \
    && cd /home/pi/Ada/Gnoga/gnoga \
    && make release \
    && make install

#build some Ada for Automation Web demo applications
RUN cd "/home/pi/Ada/A4A/demo/010 a4a_piano" && 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

Node-RED, InfluxDB, Grafana, Docker

Bonjour,

Nous avons pu voir dans les articles précédents quelques tableaux de bord réalisés avec des composants issus de la bibliothèque suivante :
https://github.com/node-red/node-red-dashboard

Ce n’est certes pas la seule solution et le couple InfluxDB / Grafana est souvent cité pour réaliser des projets IoT avec le Raspberry Pi.

InfluxDB permet de stocker des données horodatées dans une base de données que Grafana va interroger pour les afficher sous forme de diagrammes, de graphiques, ou sous forme tabulaire.

Ce sont des projets « open source » et il est possible de les installer sur toutes sortes de machines dont le Raspberry Pi.

Il se trouve qu’il y a un nœud Node-RED qui permet d’insérer depuis un flow des données dans une base InfluxDB, ce qui rend l’opération triviale :
https://flows.nodered.org/node/node-red-contrib-influxdb

Voilà, voilà…

Les données du « flow » présenté ici parviennent via le lien (link) au nœud qui les envoie à la base de données InfluxDB.

Et Grafana peut piocher dans les données pour les afficher comme vous le souhaitez :

En ce qui concerne la mise en œuvre d’une telle solution sur votre Raspberry Pi les articles et la documentation ne manquent pas.

Sur les solutions durcies netIOT Edge de Hilscher le système d’exploitation sécurisé ne permet pas d’installer quoi que ce soit non signé par Hilscher et il faut utiliser Docker via l’interface d’administration Portainer, ce qui est chose relativement aisée.

En fait, des conteneurs officiels sont disponibles sur le Hub Docker tant pour InfluxDB que pour Grafana.

Et Portainer permet de télécharger les images et de configurer les conteneurs correspondants.

Bien sûr, InfluxDB comme Grafana ont beaucoup plus à offrir, ce que je vous laisse le soin d’approfondir.

Comme l’interface applicative est basée sur le protocole HTTP, toutes sortes d’architectures sont envisageables.

Cordialement,
Stéphane

Raspberry Pi : Une passerelle Modbus – Communication S7

Bonjour,

Suivant le fil de nos expériences sur Raspberry Pi / Node-RED / netPi, netIOT… il est donc possible de communiquer en Modbus d’une part et en communication S7 sur Iso on TCP / RFC 1006 d’autre part.

Bien que cela ne soit pas une demande très fréquente il m’a été demandé quelques fois une passerelle permettant de connecter un automate communiquant selon le protocole Modbus, généralement il faut bien le dire un automate de la gamme SCHNEIDER ELECTRIC, avec un automate de la gamme SIEMENS S7.

S’il est possible bien sûr, et c’est souvent ainsi que la connexion est réalisée, d’utiliser une passerelle de la gamme Hilscher comme les netTAP 50 / 100 / 151 pour des conversions Modbus ou Ethernet/IP vers PROFIBUS ou PROFINET, il est nécessaire dans ce cas de modifier la configuration du réseau et de l’automate SIEMENS S7 pour y ajouter la passerelle en tant qu’esclave et programmer les échanges.

Cela demande de toute évidence de disposer des outils, des compétences, du programme et de l’autorisation de le modifier.

Dans certains cas, on souhaite seulement accéder aux données de l’automate qui sont déjà disponibles, par exemple dans un bloc de données mises à disposition pour un SCADA, et c’est ce que permet la communication S7.

Ainsi, le « flow » suivant réalise une communication entre un automate SCHNEIDER ELECTRIC M340, dans ce cas serveur Modbus TCP, et un automate SIEMENS S7-1500.

La passerelle équipée de Node-RED est dans ce cas le client Modbus TCP et lit et écrit les données dans le M340 d’une part.
D’autre part, elle lit et écrit les données dans le S7-1500.

Avec la version JSON pour l’import :
Node-RED-Modbus-S7-GW-00

On a donc un potentiomètre qui permet de régler le %MW10 en l’écrivant dans le S-1500 et une relecture de ce même mot.
Le résultat de la lecture est affiché d’une part dans une jauge et d’autre part écrit dans le %MW205 du M340.
Finalement, on lit ce %MW205 dans le M340 et on affiche sa valeur dans une jauge.

Un autre cas de figure est traité en partie basse du « flow », le cas où la passerelle est serveur Modbus TCP.

On a donc un nœud Modbus Serveur qui va être interrogé par un client Modbus TCP quelconque, en l’occurrence pour ma démonstration Modbus Poll.

Pour tester le nœud Modbus Serveur, un potentiomètre permet d’écrire une valeur dans le %MW0.
Le %MW10 remontant du S7-1500 est lui écrit en %MW1 (en même temps qu’il est écrit dans le M340).

On lit dans le nœud Modbus Serveur les données (et on y écrit) avec les mêmes nœuds que pour le M340 bien sûr sauf que cela se passe sur l’hôte local (localhost : 127.0.0.1).

On obtient le tableau de bord suivant :

Et Modbus Poll affiche bien les données attendues !

Cordialement,
Stéphane

Raspberry Pi : un tableau de bord pour votre automate Siemens S7

Bonjour,

Si votre installation comporte des automates Siemens S7, vous êtes bien en peine de discuter selon le protocole Modbus bien que cela soit possible. Et vous vous demandez comment réaliser vous aussi un superbe tableau de bord pour votre automate comme celui exposé ici.

C’est très possible et nous allons pouvoir avec Node-RED mettre en œuvre de nouveaux nœuds permettant la communication S7 via ISO on TCP / RFC 1006 :
https://flows.nodered.org/node/node-red-contrib-s7comm

Ces nœuds ont été développés par Hilscher :
https://github.com/Hilscher/node-red-contrib-s7comm

sur la base de l’excellent travail de ce projet :
https://github.com/plcpeople/nodeS7

Vous voudrez bien consulter la littérature fournie par ces projets pour plus d’information.

Disposant d’une CPU Siemens S7-1500 PN j’ai donc pu tester ces blocs et j’ai créé ce « flow » que je partage :

Le « flow » exporté est ici :
Node-RED-S7-1500-RFC1006-0

Il réalise la lecture du %MW0, sa mise en forme et l’affichage dans une jauge.
L’état de la communication est également affiché.
Un potentiomètre permet de régler une valeur écrite dans ce même %MW0, ce qui suffit à ma démonstration.

Le code de la fonction est très simple. On récupère sur une sortie la valeur qui nous intéresse et l’on teste l’état de la communication que l’on retourne sur la seconde sortie.

var msg_out = {payload:msg.payload.value[0]};
var msg_com = {payload:(msg.payload.error === 0)};
return [msg_out, msg_com];

Les nœuds peuvent accéder en lecture et écriture aux différentes zones mémoire de l’automate (entrée, sortie, mémento, blocs de données, tempo et compteurs) et tous les types de données élémentaires, aussi les chaines de caractères S7, sont supportés.

Ainsi le « flow » montre l’exemple du réel %MD2. La valeur est aussi envoyée vers un autre « flow » connecté à une base de données « InfluxDB » mais c’est une autre histoire que je vous raconterai ce tantôt.

Et voici un beau tableau de bord pour votre S7-1500 :

Si votre CPU ne possède pas de connexion TCP/IP, rien n’est perdu !

En effet, vous pouvez lui adjoindre un NL 50-MPI (ou un NT 50-MPI) connecté sur le port MPI ou PROFIBUS.

Ces passerelles ont déjà fait l’objet de plusieurs articles.

Ainsi je peux faire la même chose avec ma CPU Siemens S7 315-2DP :

Les nœuds Node-RED S7-Comm sont installés par défaut dans toutes les passerelles de la gamme netIOT Edge.

Ces équipements industriels iront très bien à côté de votre CPU Siemens ! 😉

Cordialement,
Stéphane

Raspberry Pi : un tableau de bord pour votre automate Modbus

Bonjour,

L’article précédent montrait la réalisation d’un tableau de bord pour un serveur Modbus TCP un peu particulier avec Node-RED.

Il est bien sûr possible d’appliquer ces mêmes technologies pour créer un tableau de bord quel que soit le serveur Modbus TCP ou l’esclave Modbus RTU.

En l’occurrence, j’ai à ma disposition un automate M340 de SCHNEIDER ELECTRIC, muni d’un coupleur NOC04101, et qui possède, entre autres, la fonctionnalité serveur Modbus TCP et le « flow » ci-après réalise les opérations suivantes :

D’une part, on lit et on affiche dans une jauge la valeur du %MW200.
On trouve donc les nœuds suivants :

  • un nœud qui effectue la lecture du %MW200, fonction FC3, lecture de registres internes,
  • un autre, l’extraction et la mise en forme de la donnée pour la jauge,
  • et la jauge elle-même.

D’autre part, un potentiomètre permet de régler la valeur du %MW210.
Il y a ainsi :

  • le nœud du potentiomètre,
  • et celui réalise l’écriture du %MW210, FC6, écriture d’un registre interne.

Le code de la fonction d’extraction est très simple, la requête FC3 remonte un tableau de données et l’on ne s’intéresse qu’à la première :

var msg_out = {payload:msg.payload[0]};
return msg_out;

Le programme automate se contente de recopier la valeur du %MW210 dans le %MW200 pour les besoins de ma démonstration.

[
    {
        "id": "43e491b2.0b35a8",
        "type": "tab",
        "label": "Modbus",
        "disabled": false,
        "info": ""
    },
    {
        "id": "6ca8bbe5.c10cfc",
        "type": "modbus-read",
        "z": "43e491b2.0b35a8",
        "name": "",
        "topic": "",
        "showStatusActivities": false,
        "showErrors": false,
        "unitid": "",
        "dataType": "HoldingRegister",
        "adr": "200",
        "quantity": "1",
        "rate": "1",
        "rateUnit": "s",
        "delayOnStart": false,
        "startDelayTime": "",
        "server": "43c0221.3e519dc",
        "x": 150,
        "y": 100,
        "wires": [
            [
                "d1453b66.31e57",
                "74b2d916.437c08"
            ],
            []
        ]
    },
    {
        "id": "d1453b66.31e57",
        "type": "debug",
        "z": "43e491b2.0b35a8",
        "name": "",
        "active": false,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "false",
        "x": 350,
        "y": 100,
        "wires": []
    },
    {
        "id": "35d64d2a.3a0dfa",
        "type": "ui_gauge",
        "z": "43e491b2.0b35a8",
        "name": "Modbus Gauge",
        "group": "338d75bf.8d7ca2",
        "order": 1,
        "width": 0,
        "height": 0,
        "gtype": "gage",
        "title": "MW200 Gauge",
        "label": "units",
        "format": "{{value}}",
        "min": 0,
        "max": "65535",
        "colors": [
            "#00b500",
            "#e6e600",
            "#ca3838"
        ],
        "seg1": "",
        "seg2": "",
        "x": 500,
        "y": 180,
        "wires": []
    },
    {
        "id": "74b2d916.437c08",
        "type": "function",
        "z": "43e491b2.0b35a8",
        "name": "",
        "func": "var msg_out = {payload:msg.payload[0]};\nreturn msg_out;",
        "outputs": 1,
        "noerr": 0,
        "x": 330,
        "y": 140,
        "wires": [
            [
                "35d64d2a.3a0dfa",
                "de0996f0.d1aef"
            ]
        ]
    },
    {
        "id": "de0996f0.d1aef",
        "type": "debug",
        "z": "43e491b2.0b35a8",
        "name": "",
        "active": false,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "false",
        "x": 490,
        "y": 140,
        "wires": []
    },
    {
        "id": "82cf117c.244d88",
        "type": "modbus-write",
        "z": "43e491b2.0b35a8",
        "name": "",
        "showStatusActivities": false,
        "showErrors": false,
        "unitid": "",
        "dataType": "HoldingRegister",
        "adr": "210",
        "quantity": "1",
        "server": "43c0221.3e519dc",
        "x": 500,
        "y": 320,
        "wires": [
            [],
            []
        ]
    },
    {
        "id": "7fad2d38.5ba184",
        "type": "ui_slider",
        "z": "43e491b2.0b35a8",
        "name": "Modbus MW210 Slider",
        "label": "MW210 Slider",
        "group": "338d75bf.8d7ca2",
        "order": 0,
        "width": 0,
        "height": 0,
        "passthru": true,
        "topic": "",
        "min": 0,
        "max": "65535",
        "step": 1,
        "x": 160,
        "y": 320,
        "wires": [
            [
                "82cf117c.244d88"
            ]
        ]
    },
    {
        "id": "43c0221.3e519dc",
        "type": "modbus-client",
        "z": "43e491b2.0b35a8",
        "name": "M340",
        "clienttype": "tcp",
        "bufferCommands": true,
        "stateLogEnabled": false,
        "tcpHost": "192.168.1.100",
        "tcpPort": "502",
        "tcpType": "DEFAULT",
        "serialPort": "/dev/ttyUSB",
        "serialType": "RTU-BUFFERD",
        "serialBaudrate": "9600",
        "serialDatabits": "8",
        "serialStopbits": "1",
        "serialParity": "none",
        "serialConnectionDelay": "100",
        "unit_id": 1,
        "commandDelay": 1,
        "clientTimeout": 1000,
        "reconnectTimeout": 2000
    },
    {
        "id": "338d75bf.8d7ca2",
        "type": "ui_group",
        "z": "43e491b2.0b35a8",
        "name": "Modbus",
        "tab": "52e4f040.d2daf",
        "order": 1,
        "disp": true,
        "width": "6"
    },
    {
        "id": "52e4f040.d2daf",
        "type": "ui_tab",
        "z": "43e491b2.0b35a8",
        "name": "Modbus",
        "icon": "dashboard",
        "order": 3
    }
]

Le code du flow est disponible ici :
Node-RED-M340-OMB0

Et le tableau de bord résultant ressemble à ceci :

Je suis certain que vous voyez déjà toutes les opportunités qui s’offrent à vous pour un investissement somme toute modique.

Avec un œil sur votre automate depuis n’importe quel navigateur, de votre bureau ou sur votre mobile, vous pourrez vous consacrer à d’autres tâches comme apprendre Ada 😉 :
https://learn.adacore.com/index.html#

Bien sûr, lorsque vous vous serez fait la main sur votre Raspberry Pi, vous pourrez compter sur une version industrialisée de celui ci comme le netPI CORE 3 :
https://www.hilscher.com/products/product-groups/industrial-internet-industry-40/netiot-edge/niot-e-npi3-en/

Cordialement,
Stéphane