Interface PLC

Vue d'ensemble

Le cas des cartes Arduino ou M-duino

Pour les cartes Arduino ou M-duino, l'interface Storga est assurée par une librairie 'StorgaBridge' fournie par Copliant.
Cette librairie peut être utilisée de deux manières :

Dans les deux cas, vous pouvez aussi écrire dans l'environnement Arduino des fonctions complexes pour pour accéder et piloter des capteurs, écran ou autres appareils plus sophistiqués, en vous basant éventuellement sur d'autres librairies Arduino. Vous pourrez accéder à ces fonctions depuis Storga, via la fonction 'plc_call' décrite à la fin de ce document.

Les propriétés de la librairie 'StorgaBridge' qui assure l'interconnexion de la carte avec Storga, et qui fonctionne au dessus de la couche réseau UDP, sont :

Le cas des cartes Raspberry pi ou autres cartes tournant sur Linux

Pour les cartes tournant sous Linux, par exemple les Raspberry pi, l'interface Storga est assurée par un démon (exécutable 'storga_bridge') fourni par Copliant.
Cette interface utilise le même protocole, et donc dispose des mêmes caractéristiques et propriétés que l'interface Arduino ou M-duino que nous venons d'évoquer.

Déclaration et connection

La carte à interfacer doit être déclarée au niveau de la section 'Sites de fichiers (HTTP, FTP) et PLCs' de la page de définition du site Storga.

La clé 'Code du site' associé à chaque carte correspond au nom attribué à la carte, qui sera utilisé dans l'instruction 'plc_connect'.

Les champs supplémentaires à remplir sont :

Quand on utilise le protocole spécifique développé par Copliant pour interfacer les cartes de type Arduino, M-duino, ou Raspberry pi, le champ 'Utilisateur' n'est pas utilisé.

Voici le détail des options à utiliser au niveau du champ 'Options supplémentaire'

L'instruction de connexion à la carte, à utiliser dans le script Storga, est :

plc_connect "nom_de_la_carte"

Le nom de la carte doit correspondre à ce qui a été indiqué au niveau de la colonne 'Code du site' au niveau de la table de définition des PLCs dans la page de définition du site Storga.

Un programme qui utilise l'instruction 'plc_connect' doit être signé, et le signataire doit disposer des droits correspondants à ce qui a été indiqué au niveau du champ 'Droit nécessaire pour signer les programmes'.

Par défaut, en cas d'erreur d'accès à la carte, le programme Storga va se mettre aussi en erreur.
Si l'on souhaite traiter les erreurs d'accès à la carte sans déclencher d'erreur au niveau du programme Storga, on ajoute l'option 'safe' au moment de la connection à la carte :

plc_connect "nom_de_la_carte" safe

Dans ce cas, le programme Storga peut à tout moment déterminer si la connexion à la carte a fonctionné correctement via la fonction 'plc_error' qui retourne une chaîne de caractères non vide en cas d'erreur :

if plc_error<>""
  ...

Toujours si l'on a utilisé l'option 'safe' au niveau de l'instruction 'plc_connect', les entrées dont la lecture aura échoué auront, au niveau du programme Storga, la valeur 'undefined'. Voir instruction 'plc_pin' ci-dessous.

Interface bas niveau : gérer directement les broches de la carte depuis Storga

Cette interface permet de gérer les broches de la carte. Cela signifie lire les entrées digitales et analogiques, et positionner les sorties digitales et analogiques.

On commence par déclarer chaque broche, via l'instruction 'plc_pin' dont la syntaxe est :

plc_pin nom pin numéro spécifications

Le nom est le nom de variable qui sera utilisé pour accéder à cette broche.

Les mots clés utilisables au niveau des spécifications sont :

Voici un exemple, qui attribue le nom 'led' à la broche 13 d'une carte Arduino, qui correspond effectivement à une LED présente sur la carte :

plc_pin led pin 13 analog output

Une fois la broche déclarée, on y accède comme une simple variable.
Pour les broches d'entrée, on utilise sa valeur.
Pour les broche de sortie, on la positionne en utilisant l'instruction ':='

Un exemple pourrait être :

led := 0.5

Comprendre la modèle sémantique utilisé par Storga

Quand le programme Storga démarre, les entrées sont toutes lues en une seule fois. Il est donc inutile de mettre en place une boucle dans le programme Storga qui attendrait par exemple qu'une broche bascule : elle ne basculera pas, parce que les entrées sont lues une seule fois au moment du démarrage du programme Storga.
De manière symétrique, toutes les sorties sont positionnées en une seule fois, à la fin de l'exécution du programme Storga. Il est donc impossible de positionner une sortie, faire boucler le programme Storga quelques instants, puis positionner à nouveau la même sortie.

Interface haut niveau : dialoguer avec la boucle de décision qui tourne sur la carte

Quand la carte gère un automatisme non trivial, celui-ci est généralement implémenté via des automates. En informatique, un automate est une manière standardisée d'écrire le programme. Elle comprend une variable d'état, qui indique la position actuelle dans l'automate, et une boucle de contrôle, qui tourne en permanence, et à chaque tour : lit un certain nombre d'entrées, en déduit les sorties à positionner, et un changement éventuel de l'état, c'est à dire de la position dans le diagramme de l'automate.

Le dialogue avec un automate se fait au moyen de deux instructions. La première permet d'envoyer une commande à l'automate, c'est à dire lui demander de changer d'état. La seconde permet de lire l'état de de l'automate.

Envoyer une commande se fait classiquement en écrivant dans un buffer logique. Pour cela, dans le programme Storga, on utilise l'instruction :

plc_buffer_write numéro_du_buffer offset position_initiale contenu_a_écrire

La partie 'offset position_initiale' sont optionnels, et ne servent que si l'on souhaite écrire en ne commençant pas à la position zéro du buffer.
Le contenu à écrire se spécifie sous la forme de paires d'arguments :

L'exemple suivant écrit 1+1+1+4+4+4+4+4 = 23 octets, en commençant à l'offset 2 du buffer 0 :

plc_buffer_write 0 offset 2 u1 1 u1 13 u1 1 u4 5000 u4 2^2 u4 0 u4 2^2 u4 0

Lire l'état de l'automate se fait classiquement en lisant le contenu d'un buffer logique. Pour cela, dans le programme Storga, on utilise l'instruction :

plc_buffer_read numéro_du_buffer offset position_initiale contenu_a_lire

Les arguments ont la même signification que pour 'plc_buffer_write'. Par contre, au lieu de fournir des valeurs à écrire, on indique des variables ou stocker le contenu lu, qui sont soit de type 'Int' quand le contenu à lire est numérique, soit de type 'Str' quand le contenu à lire est une chaîne de caractères.

L'exemple suivant lit dans la variable 'v' le contenu du premier octet du buffer 0 :

plc_buffer_read 0 u1 (var Int v)

Interfacer des capteurs complexes connectés à une carte Arduino, Raspberry pi ou autre

Il s'agit d'un mixte entre l'interface bas niveau et haut niveau.

L'instruction Storga est :

plc_call numéro_de_fonction write contenu_a_écrire read contenu_a_lire

Contenu à écrire et contenu à lire utilisent les mêmes paires d'arguments que les fonctions 'plc_buffer_read' et 'plc_buffer_write'. Par contre, l'instruction 'plc_call' ne dispose pas d'une option 'offset'.

Cette instruction 'plc_call' ressemble à une instruction 'plc_buffer_write' suivie d'une instruction 'plc_buffer_read'.
Dans le cas de cartes utilisant un protocole de dialogue spécifiques TCP, UDP ou TLS, elle y correspond exactement, et c'est la seule fonction qui sera utilisée dans la pratique.

En revanche, dans le cas d'une carte Arduio ou tournant sous Linux (par exemple Rasberry pi), elle correspond à tout autre chose qui est l'appel effectif d'une fonction spécifique.
Cette fonction spécifique sera implémentée en C ou C++, et connectée à l'interface carte ↔ Storga via l'instruction 'declare_function'.
On utilisera une telle fonction pour accéder depuis Storga à des capteurs complexes connectés à la carte via le bus i2c, piloter un écran LCD, etc.

Au niveau de l'environnement Arduino, la fonction à laquelle on accède a pour prototype :

int ma_fonction(const uint8_t *param,int psize,uint8_t *result,int rsize) {
  ...
}

La fonction retourne 0 en cas de success, une valeur non nulle en cas d'échec.

L'interface de cette fonction avec Storga se déclare via une variable globale de type 'FunctionBuffer' :

struct FunctionBuffer buffer_de_ma_fonction;

puis une instruction 'StorgaBridge.delcare_function' au niveau de la fonction 'setup' :

StorgaBridge.declare_function(&buffer_de_ma_fonction,numéro_de_la_fonction,ma_fonction);