Blocaïne est une plateforme logicielle conçue pour l'automatisation des procédés industriels. Elle comprend deux composants principaux :

• •Un Éditeur de blocs, qui permet de créer des programmes en assemblant des blocs fonctionnels. 

• •Un Exécuteur , qui exécute les programmes créés avec l’Éditeur de blocs, pilotant ainsi l’équipement industriel via des entrées/sorties déportées.  

L’Éditeur de blocs est installé sur un « PC de Développement » et communique par Ethernet avec l’Exécuteur, déployé sur un autre ordinateur appelé « Machine cible ».

 

La connexion Ethernet permet de transférer les programmes créer avec l’Éditeur de blocs vers l’Exécuteur, elle autorise également la visualisation en temps réel au sein de l’Éditeur de blocs des variables des programmes en cours d’exécution par l’Exécuteur.

• •« Chargement à Chaud » (HotSwap) :  Une nouvelle version d’un programme peut être chargée alors que l’ancienne version est en cours d’exécution. 

• •Programmation graphique sous forme de blocs fonctionnels chaînés 

• •Chaque variable possède nativement un bit de validité, qui se propage de bloc en bloc. 

• •Typage dynamique des variables. 

• •L’ordre d’exécution des blocs est géré automatiquement 

• •La mise en page des blocs est réalisée automatiquement 

• •Blocaïne est un logiciel libre et « open source » 

   

Le projet Blocaïne en est au stade de prototype Fonctionnel.

L’utilisation de Blocaïne se fait sous la responsabilité de l’utilisateur.

Chaque bloc est constitué d’entré(s) de sortie(s) et du code permettant d’évaluer les sorties en fonction des entrées.

• •Pour les blocs de la bibliothèque de base (appelés blocs System) c’est une fonction écrite en Python qui évalue les sorties en fonction des entrées 

• •Pour les blocs créés par l’utilisateur (blocs user) c’est un chaînage de blocs system ou user, qui permet d’évaluer les sorties en fonction des entrées 

Un programme exécutable n’est autre qu’un bloc user, Un sous-programme se présente aussi sous la forme d’un bloc user, les entrées/sorties des blocs sont eux même des blocs (<inputs>, <output>), le bloc <input> possède une sortie définie par un bloc <output>, tandis que le bloc <output> possède une sortie définie par un bloc <input>. Bref tous est bloc.

l’Exécuteur dispose pour chaque programme (bloc user) de deux versions Shift A et Shift B. La nouvelle version d’un bloc est toujours téléchargée dans le Shift qui n’est pas en cours d’exécution, lorsqu’un HotSwap est initié, les valeurs courantes des variables mémorisées du Shift en cours d’exécution sont transférés à l’autre Shift, qui prend alors la relève.     

Pour chaque bloc user en cours d’exécution (Running), l’Exécuteur évalue périodiquement tous les blocs <output> associés à une tache périodique. Chaque entrée d’un bloc <output> est évalué par l’Exécuteur en exécutant d’abord le bloc précédent, et ainsi de suite.

Cette approche élimine la nécessité de définir explicitement l’ordre d’exécution des blocs.

Puisque Blocaïne s’appuie sur le langage Python, les variables (d’entrée et de sortie) utilisées par les blocs sont typées dynamiquement, leur type peut être quelconque y compris des structures complexes, dés lors qu’il s’agit d’une combinaison de types reconnue par Python (chaîne de caractères, entier, flotant, liste, dictionnaire, etc.).

Un bit de validité associé à chaque sortie de bloc est évalué automatiquement à chaque exécution en fonction de la validité des entrées et de la possibilité ou non d’évaluer de la sortie.

Chaque entrée de bloc, qu’il s’agisse d’un bloc system ou user, possède une valeur par défaut modifiable à l’instanciation.

L’Éditeur de blocs permet :

• •La création et la modification de programmes sous forme de blocs user contenant des blocs fonctionnels chaînés entre eux. 

• •La compilation , le téléchargement et le lancement de l’exécution du bloc user en cours d’édition dans la « Machine Cible ». 

• •la visualisation dynamique et le forçage des entrées/sorties des blocs user et les sous-blocs en cours d’exécution. 

Chaque bloc est constitué de :

• •Une entête : contenant le nom du bloc 

• •D’entrée(s) : située(s) à gauche sous l’entête, contenant le nom de l’entrée 

• •De sortie(s) : située(s) à droite sous l’entête à, contenant le nom de la sortie 

 

Les blocs peuvent êtres chaînés entre eux par des liens, notez qu’une sortie ne peut être liée qu’à une entrée et qu’une entrée ne peut être liée qu’à une seule sortie.

À chaque bloc correspond un fichier nommé : « nom du bloc.bloc ». Les fichiers des blocs system sont dans le répertoire /blocs/system, alors que les fichiers des blocs user sont dans /blocs/user.

L’interface graphique de l’Éditeur de blocs « Blocaïne » est constituée d’une ou plusieurs fenêtres, chacune contient les éléments suivants :

1. 1.Une barre de titre (de la fenêtre) 

2. 2.Une barre de menu 

3. 3.Trois icônes : 💾, ⚡, 👁️ 

4. 4.Une zone graphique, ou vous déposez et reliez entre eux des blocs, afin de constitué un programme (blocs user). 

5. 5.Une barre de status : 

 

Interface graphique de l’éditeur de bloc (Blocaïne)

En haut de chaque fenêtre se situe une barre de titre qui contient :

• •le mode en cours : Editing ou Monitoring 

• •le nom du bloc en cours d’édition ou de débogage 

Notez que si le bloc a été ouvert en temps que sous-bloc, sous-sous-bloc etc, le chemin ayant permis son ouverture apparaîtra devant le nom du bloc. Cela est utile en mode Monitoring  (débogage) pour déterminer à quelle instance du bloc appartiennent les variables affichées dans cette fenêtre.

La barre de menu située en haut à gauche sous la barre de titre, contient les quatre menus suivants :

• •Bloc : est équivalent au menu « Fichier » de la plupart des logiciels. 

• •Target : gère l’interface avec la « Machine Cible » (donc avec l’Exécuteur). 

• •Edit : gère la présentation. 

• •Help : affiche de la documentation. 

Le menu « Bloc » contient le sous-menu suivant :

• •Open : permet d’ouvrir un fichier contenant un bloc. 

• •Save [F3] : permet de sauvegarder le bloc en cours d’édition dans un fichier dont le nom correspond au nom du bloc courant. 

• •Save as [F4] : permet de sauvegarder le bloc en cours d’édition dans un fichier dont le nom sera saisie par l’utilisateur. 

• •Update [F5] : permet de mette à jour toutes les interface externe des blocs user utilisés comme sous-programme dans le bloc user en cour d’édition. 

• •Change Properties : cela permet de modifier les champs associés à l’entête du bloc user en cours d’édition comme « l’auteur du bloc », « les mots clef »...mais aussi son « nom ». 

• •Open new windows : ouvre une nouvelle fenêtre, ce qui permet ouvrir un autre bloc user. 

• •Quit [Escape] : quitte la fenêtre courante, sans sauvegarder le bloc user en cours d’édition. 

Le menu « Target » contient le sous-menu suivant :

• •Disconnect from Target ou Connect to Target : pour se connecter ou se déconnecter de la « Machine Cible » (donc à l’Exécuteur). 

• •Check <nom_du_bloc> : pour vérifier si le bloc en cours d’édition est valide et compilable. 

• •Check  & Transfert <nom_du_bloc> : vérifie que le bloc en cours d’édition est valide le compile, puis transfert le résultat dans la « machine Cible » vers le Shift qui n’est pas « running ». 

• •Check, Transfert & Execute <nom_du_bloc> : vérifie que le bloc en cours d’édition est valide, le compile, transfert le résultat dans la « Machine Cible » vers un Shift qui n’est pas « running », puis l’Exécuteur lance son exécution: dans le cas ou le bloc est déjà en cours d’exécution sur l’autre Shift un chargement à chaud (HotSwap) sera initié, sinon un simple démarrage (Run) sera initié. 

• •Monitoring (Start/Stop) [Space] : permet de basculer du mode édition au mode débogage. 

Le menu « Edit » contient le sous-menu suivant :

• •Auto layout [F7] : cette commande effectue une mis en page automatique. 

• •Status bar (show/hide) : cette commande permet de montrer ou cacher la « barre de status ».  

Le menu « Help » contient le sous-menu suivant :

• •Versions : donne la version de l’Éditeur de blocs et de la structure des blocs. 

• •Mouse usage : donne des instructions sur l’utilisation de la souris : 

• • ◦[Left click] to select, to use menu 

  • ◦[Left held down] to scroll within window, to move bloc, to link I/O bloc 

  • ◦[Left double-click] to open user bloc 

  • ◦[Right button] to open the context menu 

  • ◦[wheel button] to monitor the target variables (on/off)  

  • ◦[wheel rotation] to zoom (in/out) 

• •Key usage : donne des instructions sur l’utilisation du clavier : 

  • ◦[F1] Open the documentation for the bloc whose header is located under the cursor 

  • ◦[F3] to save curant bloc 

  • ◦[F4] to save curant bloc as 

  • ◦[F5] to update curant bloc 

  • ◦[F7] to layout curant bloc 

  • ◦[Delete] Delete the bloc whose header is located under the cursor 

  • ◦[Space] to monitor the target variables (on/off) 

  • ◦[Escape] to close window 

• •General Documentaion : ouvre le présent document (au format HTML) dans le navigateur web par défaut. 

Ces icônes permettent un accès rapide au fonctionnalités les plus fréquemment utilisées :

• •"💾" : sauvegarde du bloc courant. 

• •"⚡" : vérifie la cohérence du bloc courant, le convertit (compilation) dans un format compréhensible par l’Exécuter, le transfert dans la Machine Cible puis demande à l’Exécuteur : 

1. 1. 1.Son démarrage (Run), si le bloc courant n’est pas déjà en cours d’exécution dans la machine Cible. 

   2. 2.Son chargement à chaud (HotSwap), si le bloc courant est déjà en cours d’exécution dans la machine Cible. 

• •"👁️" : bascule d’un mode à l’autre entre Editing et Monitoring. 

Cette zone vous permet de construire un programme (bloc user) en y déposant des blocs system ou user et en les reliant entre eux.

Pour naviguer dans cette zone, il faut utiliser une souris :

• •La rotation de la molette : permet de zoomer/dézoomer. 

• •Un déplacement de la souris bouton gauche enfoncée : permet de déplacer la zone visible (scroller) 

• •Clic droit : permet de faire apparaître le menu contextuel. 

• •Double clic gauche sur l’entête d’un bloc user : ouvre le bloc user pointé dans une nouvelle fenêtre. 

• •Double clic gauche sur une entrée ou une sortie d’un bloc user : ouvre le bloc user de l’I/O pointée dans une nouvelle fenêtre et positionne l’entrée ou la sortie au centre de la zone graphique. 

• •Clic gauche : permet de sélectionner un champ dans un menu. 

• •Déplacement clic gauche enfoncé : permet de créer un lien (entre une entrée et une sortie) ou de déplacer un bloc. 

• •Clic sur le bouton de la molette : active/déactive la visualisation en temps réel des valeurs des variables situées dans la cible (Monitoring On/Off) 

Un clic droit sur une zone vierge, fait apparaître le menu contextuel suivant :

 

ce menu permet d’ajouter un bloc.

Un clic droit sur l’entête d’un bloc, fait apparaître le menu contextuel suivant :

 

1. 1.Delete : permet la suppression du bloc 

2. 2.Update : met à jour l’interface externe du bloc, à partir du fichier de ce bloc. 

3. 3.Change event  : permet l’association le bloc à une tache périodique afin qui soi exécutable. Ce champ n’est disponible que pour les blocs <output> 

4. 4.Position :2/3,  move up, move down : permet de modifier l’ordre des entrées ou des sorties dans l’interface externe du bloc user en cours d’édition. Ce champ n’est disponible  que pour les blocs <input> ou <output>. 

5. 5.Documentation : ouvre le fichier d’aide du bloc dans le navigateur web par défaut. Ce champ n’est disponible que si un fichier d’aide nommé « bloc_ type de bloc_nom du bloc.html » est présent dans le répertoire « /Documentation ». 

   1. 1.type de bloc : peut être ; user ou system 

   2. 2.nom du bloc : correspondant au nom défini dans l’entête du bloc 

6. 6.Properties :

   

    

   afficher les propriétés du bloc comme ceci. 

Un clic droit sur une entête d’un bloc, fait apparaître le menu contextuel suivant :

 

1. 1. Delete link  : permet la suppression du lien avec le bloc précédent. Ce champ n’est disponible que si il existe un lien entre l’entrée et la sortie d’un autre bloc. 

2. 2.Open: permet ouvrir une nouvelle fenêtre qui édite le bloc user de l’entrée, et positionne l’entrée au centre de la zone graphique. 

3. 3.Create locale name : permet de nommer localement l’entrée, ce nom est associé à l’interface externe de l’instance.  

4. 4.Create locale comment : permet d’associer un commentaire locale à l’entrée, ce commentaire est associé à l’interface externe de l’instance.  

5. 5.Set default value : permet de donner une valeur par défaut locale à l’entrée, cette valeur est associé à l’interface externe de l’instance.  

6. 6.OverWritting  : permet de surcharger la valeur de l’entée. 

7. 7.Properties : afficher les propriétés de l’entrée comme ceci. 

 

Un clic droit sur une sortie d’un bloc, fait apparaître le menu contextuel suivant :

 

1. 1.Rename : permet de renommer le nom de la sortie, se nouveau nom apparaîtra dans l’interface externe du bloc. Ce champ n’est disponible  que pour les blocs <input>. 

2. 2.Set  defaut value : permet de définir la valeur par défaut de l’entrée liée à l’instance du bloc. Ce champ n’est disponible que pour les blocs <input>. 

3. 3.Open: permet ouvrir une nouvelle fenêtre qui édite le bloc user de l’entrée, et positionne la sortie au centre de la zone graphique. Ce champ n’est disponible que pour les blocs user. 

4. 4.Create locale name : permet de nommer localement l’entrée, ce nom est associé à l’interface externe de l’instance.  

5. 5.Create locale comment : permet d’associer un commentaire locale à l’entrée, ce commentaire est associé à l’interface externe de l’instance.  

6. 6.Add initial value : permet de donner une valeur initiale à une sortie « mémorisée ». Ce champ n’est disponible que pour tous les blocs dont la sortie est « mémorisée » d’un cycle sur l’autre, ex : <memory>, <previous>, <edge>. 

7. 7.OverWritting  : permet de surcharger la valeur de la sortie. 

8. 8.Properties : afficher les propriétés de la sortie comme ceci. 

 

Pour insérer un bloc, il faut faire un clic droit sur une zone vierge, afin de faire apparaître le menu contextuel suivant :

 

Il faut alors choisir le type de bloc que vous souhaitez :

• •input : pour créer une nouvelle entrée dans le bloc user en cours d’édition. 

• •output : pour créer une nouvelle sortie dans le bloc user en cours d’édition. 

• •system : pour insérer un bloc faisant partie de la bibliothèque standard. 

• •user : pour insérer un bloc user précédemment créé. 

Pour supprimer un bloc, vous pouvez faire un clic droit sur l’entête du bloc à supprimer, afin de faire apparaître le menu contextuel suivant :

 

puis sélectionner Detete.

Vous pouvez aussi positionner le curseur sur l’entête du bloc à supprimer, puis appuyer sur la touche « Suppr ».

Pour lier la sortie d’un bloc à l’entrée d’un autre bloc, enfoncez le bouton gauche de la sourie sur la sortie du premier bloc, puis glissez (bouton gauche toujours enfoncé) jusqu’à l’entrée du second bloc puis relâcher le bouton gauche. Les liens peuvent aussi être créés indifféremment d’entrée vers sortie ou de sortie vers entrée, mais une entrée ne peut avoir qu’une seule source (donc provenir d’une seule sortie).

Il y deux possibilités pour supprimer un lien :

Soit faire un clic droit sur le lien, afin de faire apparaître le menu contextuel suivant :

 

puis sélectionner Delete link

Soit faire un clic droit sur l’entrée située à l’extrémité du lien, afin de faire apparaître le menu contextuel suivant :

 

 

 

puis sélectionner Delete link

Elle indique :

• •l’état de la connexion avec la Machine Cible. 

• •la position de la souris par rapport à la zone graphique (canvas). 

• •le coefficient de zoom courant. 

• •la position de la souris par rapport à la mire. 

L’interface d’un bloc user est constitué ; d’entrées et de sorties, celle-ci sont optionnelles mais indispensable pour l’interconnexion avec les autres blocs.

• •Les entrées sont collectées à l’aide de blocs system <input> 

• •Les sorties sont délivrées à l’aide de blocs system <output> 

Voici l’interface graphique du bloc system <input>

 

Sa fonction est de définir une entrée d’un bloc user. Le bloc <input> n’a pas d’entrée, mais possède une sortie nommée « in_0 », c’est la variable (de type quelconque) qui rentrera dans du bloc user,  sa valeur par défaut est 0 (int), elle peut être ajustée pour chaque instance d’un bloc <input>. Cette sortie peut être renommée, le nouveau nom apparaîtra dans l’interface externe du bloc user en tant qu’entrée.

Voici l’interface graphique du bloc system <output>

 

Sa fonction est de définir une sortie d’un bloc user. Le bloc <output> n’a pas de sortie, mais possède une entrée nommée « out_0 », c’est la variable (de type quelconque) qui sortira du bloc user, elle n’a pas de valeur par défaut, mais une valeur par défaut peut être ajouter pour chaque instance d’un bloc <output>. Cette entrée peut être renommée, le nouveau nom apparaîtra dans l’interface externe du bloc user en tant que sortie.

Voici un bloc user nommé « règle de 3 » qui contient trois blocs <input> et un bloc <output>.

• •la sortie du première bloc <input> a été renommée en « in » 

• •la sortie du second bloc <input> a été renommée en « coeff » 

• •la sortie du troisième bloc <input> a été renommée en « div » 

• •l’entrée du bloc <output> a été renommée en « out » 

 

Figure : bloc user <règle de 3 >

Voici l’interface externe du bloc « règle de 3 », ici un bloc user nommé <bloc1> fait référence au bloc « régle de 3 », les 3 entrées et la sortie correspondent aux <input>/<output> définies dans le bloc « régle de 3 » sont bien présentes dans son interface externe.

 

Figure ; interface externe du bloc user <règle de 3>

L’ordre d’apparition des entrées et des sorties dans l’interface externe d’un bloc user peut être modifier de la façon suivante :

1. 1.Ouvrir le bloc user dont vous voulez modifier l’ordre des entrées et/ou des sorties de son interface externe, en double cliquant sur l’entête du bloc à modifier, si il est présent dans la zone graphique, ou en utilisant la barre de menu (bloc/open) ou (bloc/open new window). 

2. 2.Faites un clic droit sur l’entête du bloc <input> ou <output> selon que vous souhaitiez modifier l’ordre des entrées ou des sorties. Afin de faire apparaître le menu contextuel suivant  : 

3. 3.Position:2/3 indique la position dans l’interface externe, de l’entrée ou la sortie que vous avez sélectionnée , vous pouvez alors sélection move up ou move down. pour la décaler d’une position vers haut ou vers le bas.

   

    

    

Le basculement du mode « édition » au mode « visualisation dynamique » et vice versa, s’effectue  soit en cliquant sur l’icône « œil »  (👁️), soit en appuyant sur la touche [Espace], bien sûr le bloc édité doit être en cours d’exécution pour pouvoir basculé en mode « visu dynamique ».

Ce mode est dédié à création et à la modification de blocs user.

Voici un exemple de bloc user qui calcule la moyenne de 2 nombres :

 

Figure 2 : bloc en mode édition

Ce mode est dédié au débogage, il permet la visualisation en temps réel des valeurs des variables d’un bloc user ou d’un sous-bloc user

la validité de chaque variable est représentée par la couleur de fond :

• •Vert        = valide 

• •Rouge        = invalide 

• •jaune   = forcé et valide 

• •Noir    = Forcé et invalide 

 Voici un exemple du bloc « moyenne » (en visualisation dynamique) :

 

Figure 3 : bloc en mode visu dynamique

Les bits de validité peuvent être lus ou modifiés en utilisant les blocs system suivants :

• •<valideRead> : permet de lire le bit de validité, cela permet par exemple de sélectionner une position de replie dans le cas de variables « invalide » 

• •<valideWrite> : permet l’écriture du bit de validité, autorisant l’utilisateur à définir sa propre équation de validité. 

Rappel : L’exécuteur est installé sur un PC appelé « Machine cible », il exécute les programmes (blocs user) qui pilotent l’équipement industriel en utilisant les entrées/sorties déportées.

Pour qu’un chaînage de blocs contenu dans un bloc user soient exécutable, il est impératif que ce chaînage se termine par un bloc <output> et que ce dernier soit associé à un événement (comme l’événement périodique à 100ms par exemple). l’Exécuteur évalue périodiquement tous les blocs <output> du bloc user, déclenchant ainsi l’évaluation du bloc précédent qui nécessite évaluation du bloc précédent et ainsi de suite. Cette approche élimine la nécessité de définir explicitement l’ordre d’exécution.

Un bloc user peut contenir plusieurs blocs <output>, chaque <output> pouvant êtres associés à un événement périodique différent. Il est donc possible d’inclure dans un même blocs user des chaînes de blocs qui seront exécutés avec des périodicités différentes. Si il existe des liens entre les chaînes de blocs de périodicité différente, sur chaque lien inter-chaîne il faudra insérer un bloc system <previous>, afin que la chaîne qui doit être exécuté lentement ne soit pas exécuté à la période de la chaîne la plus rapide.

Pour que le chargement à la volée soit possible, l’Exécuteur dispose pour chaque bloc user (programme) de deux versions Shift A et Shift B. La nouvelle version d’un bloc user est toujours téléchargée dans le Shift qui n’est pas en cours d’exécution, lorsqu’un « hot swap » est initié, les valeurs courantes des variables du Shift en cours d’exécution sont transférés à l’autre Shift, qui prend alors la relève.

De manière générale tant qu’un bloc n’a pas était évalué ses sorties sont « invalides »

La validité associée à chaque sortie est évaluée automatiquement lorsque le bloc est exécuté. Si une des entrées nécessaires à l’évaluation de la sortie est « invalide » ou si la sortie du bloc ne peut être évalué à cause d’un confit de type ou autre, la sortie sera « invalide », sinon elle sera « valide ».

Un serveur HTTP est intégré à l’Exécuteur, il permet à l’utilisateur par le biais d’un simple navigateur web de visualiser l’état de la Machine Cible :

• •Visualiser les taches disponibles et le nombre de <output> associé  

• •Visualiser la charge CPU générale et par tache 

• •Visualiser la liste des blocs disponible dans la Machine Cible et l’état des Shifts (A &t B) (Pending, Ready, Running) 

• •Visualiser l’état et la valeur des <output> de tous les blocs pour les Shifts (A & B) 

• •Visualisé les connexions Ethernet en cours gérées par l’Exécuteur   

Il permet aussi de passer des commandes simples telle que :

• •Arrêter l’exécution d’un bloc user (commande : Stop) 

• •Démarrer l’exécution d’un bloc user (commande : Run) 

• •Initialiser un bloc user (commande : Initialize) 

• •Supprimer un bloc user (commande : Delete) 

• •Intervertir les Shift A et Shift B 

  • ◦lorsqu’aucun Shift est « Running » (commande : ClodSwap) 

  • ◦lorsqu’un Shift est « Running » (commande : HotSwap) 

• •Lancer des commandes dédiés au débug 

  • ◦ (commande : print list_compiled) 

  • ◦ (commande : print list_threads) 

Target: jbar-HLYL-WXX9 (ip:192.168.5.58)

Target: jbar-HLYL-WXX9 (ip:192.168.5.58)

Target: jbar-HLYL-WXX9 (ip:192.168.5.58)

Pour ajouter un bloc à la bibliothèque standard, il faut :

1. 1.Créer l’interface externe (interface graphique) du nouveau bloc. 

2. 2.Codez la fonction « Python » associée au nouveau bloc et ajouter le nom du bloc à la liste des blocs de la bibliothèque standard. 

Notez qu’il faudra redémarrer l’Exécuteur et l’Éditeur de blocs pour prendre en compte ce nouveau bloc system.

Ouvrir l’Éditeur de blocs.

Dans la barre de menu, cliquez sur « Bloc » puis « Change Properties », afin d’ouvrir la fenêtre « bloc info » suivante :

 

Figure : bloc info

Saisissez le nom du nouveau bloc system dans le champ « name: ». Saisissez « system » dans le champ « Key0: ». Confirmez votre saisie en cliquant sur « Vadidation »

Dans la zone graphique, ajoutez des blocs system <input> et/ou <output> selon le nombre d’entrées et de sorties nécessaires, renommez ces entrées/sorties et leurs donner une valeur par défaut, puis appuyez sur la touche [F3] pour sauvegardez.

Pour vérifier que l’interface a bien été créée, ouvrez une nouvelle fenêtre puis insérez un bloc system, le bloc fraîchement ajouté doit figuré dans la liste, sélectionnez le, et vérifiez que l’interface externe correspond à ce que vous souhaitez.

Les fonctions associées aux bloc system sont dans le fichier /Target/exec.py, par exemple, voici la fonction Python associée au bloc system <and> :

 

Figure: fonction « c_exesubloc_and »

Si on fait abstraction des éléments liés au débogage il ne reste que ceci :

1 def c_exesubloc_and (pebloc, pieb, pio, pcounter):

2 cesubloc = pebloc.sublocs[pieb]

3 if cesubloc.header['counter'] == pcounter:

4   pass

5 else:

6          cesubloc.header['counter'] = pcounter

7          try:

8              pebloc.c_exebloc_recup_inputs(pieb, pcounter)

9                cesubloc.c_exesubloc_validation_standard()

10             cesubloc.outputs[0]['var'] = cesubloc.inputs[0]['var'] and cesubloc.inputs[1]['var']

11        except:

12               cesubloc.outputs[0]['valide'] = False

13  return cesubloc.outputs[pio]

Explication du code :

Ligne 1 : Le nom de la fonction est « c_exsubloc_ » suivi du nom du bloc system. Les paramètres sont :

• •pebloc : est la structure « exécutable » du bloc user en cours d’exécution. 

• •pieb : est l’index du bloc system à exécuter 

• •pio : est l’index de la sortie dont il faut retourner la valeur 

Ligne 2 : permet de pointer sur le bloc à exécuter.

Ligne 3 : test si le bloc a déjà été exécuté

Ligne 6 : marque le bloc comme déjà exécuté

Ligne 8 : récupère toutes les entrées du bloc

Ligne 9: affecte tous les bits de validation des sorties du bloc en fonction de ses entrées

Ligne 10: affecte la sortie en fonction des entrées (ET logique)

Ligne 12 : affecte le bit de validité à « invalide » dans le cas où le calcul du bloc ne se soit pas passé correctement

Ligne 13 : retourne la sortie demandée (sortie d’index pio)

Dans la plupart des cas votre nouvelle fonction sera identique à celle de bloc system <and>, sauf :

• •la ligne 1 : puisque le nom de la fonction sera différent. 

• •la ligne 10 : puisque vous affecterez les sorties en fonction des entrées selon vos besoins. 

Toujours dans le fichier: /Target/exec.py, il faut ajouter l’association entre le nom de votre nouveau bloc system et la fonction Python fraîchement créée, ceux-ci se passe dans la fonction « recup_procedure ».

Notez que cette fonction est utilisée par l’Éditeur de blocs lorsque qu’un bloc user est compilé :

 

Figure : fonction « recup_procedure »

Pour cela vous devrez ajouter une ligne avant le « else » est créer un nouveau paramètre dont le nom sera constitué de :

« PARAM_NAME_BLOC_ » suivi du nom de votre nouveau bloc system en majuscule.

Il faudra aussi modifier le fichier /Target/PARAM_NAME_BLOC.py, en y ajouter une ligne pour définir la constante « PARARM_NAME_BLOC_votrebloc », la chaine de caractère située à droite su signe « = » correspond au nom de ficher votre nouveau bloc system.

 

Figure : fichier PARAM_NAME_BLOC.py