Méthode: FB_Init
, FB_Reinit
, FB_Exit
Vous pouvez déclarer les méthodes explicitement afin d'influer sur l'initialisation des variables des blocs fonction, ainsi que sur le comportement à la sortie des blocs fonction.
Astuce
Le type de la valeur de retour pour les méthodes implicites est BOOL
. La valeur n'est pas évaluée par le système, mais le type ne doit pas être modifié.
FB_Init
est toujours disponible implicitement et est principalement utilisé pour l'initialisation. Pour une influence spécifique, vous pouvez également déclarer les méthodes explicitement et y fournir du code supplémentaire avec le code d'initialisation standard.
FB_Reinit
doit être implémenté explicitement. Si cette méthode existe, elle est appelée après que l'instance du bloc fonctionnel concerné a été copié. Cela se produit lors d'un changement en ligne après des modifications de la déclaration du bloc fonction (changement de signature) afin de réinitialiser le nouveau module d'instance. Pour réinitialiser l'implémentation de base du bloc fonction, il faut appeler FB_Reinit
explicitement.
FB_Exit
doit être implémenté explicitement. S'il existe une implémentation, la méthode est appelée avant que le contrôleur supprime le code de l'instance de bloc fonction (appel implicite).
Ce qui suit montre quelques cas d'utilisation de ces méthodes pour différentes conditions de fonctionnement.
Cas de fonctionnement "Premier téléchargement"
Lors du téléchargement d'une application vers un automate avec les réglages d'usine, la mémoire de toutes les variables doit être décalée à l'état initial requis. De cette manière, les zones de données des instances de bloc fonctionnel reçoivent les valeurs requises. Par la mise en œuvre explicite de FB_Init
pour les blocs fonction, vous pouvez réagir spécifiquement à cette situation dans le code de l'application. En évaluant les paramètres de la méthode bInCopyCode
(FALSE
) et bInitRetains
(TRUE
), vous pouvez clairement détecter cette condition de fonctionnement.
Cas de fonctionnement "Modification en ligne"
Dans le cadre de la modification en ligne, vous pouvez influer sur l'initialisation des instances de bloc fonctionnel à l'aide des méthodes FB_Exit
, FB_Init
, et FB_Reinit
. Lors du changement en ligne, les modifications apportées à l'application en mode hors ligne sont appliquées dans l'automate en cours d'exécution. Par conséquent, les "anciennes" instances de bloc fonction sont remplacées par vos "nouveaux frères et soeurs" autant que possible sans incident. Si aucune modification n'a été apportée à la partie déclaration d'un bloc fonction dans l'application avant la connexion, mais uniquement dans l'implémentation, les zones de données ne sont pas remplacées. Seuls les blocs de code sont remplacés. Ensuite, les méthodes FB_Exit
, FB_Init
, et FB_Reinit
ne sont pas appelés.
Astuce
Si vous avez apporté des modifications à la déclaration d'un bloc fonctionnel qui ont conduit à l'opération de copie décrite ci-dessus, vous recevez un message lors de la modification en ligne concernant les "effets indésirables possibles". Dans le Des détails de la vue des messages, vous voyez une liste de toutes les instances à copier.
Dans le code de la FB_Init
méthode, le paramètre bInCopyCode
(TRUE
) peut être évalué pour détecter si une modification en ligne est en cours d'exécution ou non.
Les appels suivants se succèdent lors d'un changement en ligne :
FB_Exit
old_inst.FB_Exit(bInCopyCode := TRUE);
Tu peux appeler
FB_Exit
lors de la sortie de "l'ancienne" instance afin de déclencher des tâches de nettoyage spécifiques avant l'opération de copie. De cette façon, vous pouvez préparer les données pour l'opération de copie suivante et influencer l'état de la nouvelle instance. Vous pouvez informer d'autres parties de l'application du changement d'emplacement en attente dans la mémoire. Portez une attention particulière aux variables de typePOINTER
etREFERENCE
. Ceux-ci peuvent ne plus faire référence aux emplacements de mémoire requis après la modification en ligne. Variables d'interface (INTERFACE
) sont gérés séparément par le compilateur et adaptés en conséquence lors de la modification en ligne. Des ressources externes telles que des sockets, des fichiers ou d'autres descripteurs peuvent être appliquées par la nouvelle instance, dans certains cas inchangées. Souvent, ils ne doivent pas être traités spécialement lors d'un changement en ligne. (Voir "Cas de fonctionnement 'Re-télécharger'")FB_Init
new_inst.FB_Init(bInitRetains := FALSE, bInCopyCode := TRUE);
FB_Init
est appelé avant l'opération de copie et peut être utilisé afin d'exécuter des opérations spécifiques pour le changement en ligne. Par exemple, vous pouvez initialiser des variables en conséquence au "nouvel" emplacement dans la mémoire, ou informer d'autres parties de l'application du nouvel emplacement de variables spécifiques dans la mémoire.Opération de copie :
copy
copy(&old_inst, &new_inst);
Les valeurs existantes restent inchangées. Pour cela, ils sont copiés de l'ancienne instance dans la nouvelle instance.
FB_Reinit
new_inst.FB_Reinit();
Cette méthode est appelée après l'opération de copie et doit définir des valeurs définies pour les variables de l'instance. Par exemple, vous pouvez initialiser des variables en conséquence au "nouvel" emplacement dans la mémoire, ou informer d'autres parties de l'application du nouvel emplacement de variables spécifiques dans la mémoire. Concevoir la mise en œuvre indépendamment du changement en ligne. La méthode peut également être appelée à tout moment depuis l'application afin de réinitialiser une instance de bloc fonction à son état d'origine.
Astuce
Avec le {attribute 'no_copy'}
, vous pouvez empêcher qu'il soit copié lors du changement en ligne pour une seule variable du bloc fonction. Il conserve toujours la valeur initiale.
Pour plus d'informations, consultez : Réserve de mémoire des paramètres pour modification en ligne
Cas de fonctionnement "Nouveau téléchargement"
Lors du téléchargement d'une application, une application existante peut être remplacée sur l'automate. Par conséquent, la fourniture de mémoire pour les blocs fonctionnels présents doit être régulée. Vous pouvez utiliser le FB_Exit
méthode pour mettre en œuvre les étapes nécessaires à cet effet. Par exemple, vous pouvez décaler des ressources externes (avec des handles de socket et de fichier) dans un état défini.
Vous pouvez détecter cette condition de fonctionnement en vérifiant si le paramètre bInCopyCode = FALSE
pour le FB_Exit
méthode.
Cas de fonctionnement "Début d'application"
Les affectations initiales sont traitées avant le premier cycle des tâches d'application.
T1 : TON := (PT:=t#500ms);
Ces types d'affectations ne sont exécutés qu'après avoir appelé FB_Init
. Afin de contrôler les effets de ces affectations, vous pouvez fournir un bloc fonction ou une méthode d'un bloc fonction avec le {attribute ‘call_after_init‘}
attribut. Vous devez ajouter l'attribut au-dessus de la partie déclaration du corps du bloc fonction et au-dessus de la partie déclaration de la méthode correspondante. Un POU qui étend un autre POU qui utilise le {attribute 'call_after_init'}
L'attribut doit également avoir l'attribut. Pour plus de clarté, nous recommandons que les méthodes correspondantes soient remplacées par le même nom, la même signature et le même attribut. Cela nécessite d'appeler SUPER^.MyInit
. Le nom de la méthode peut être choisi sans restriction. (Des exceptions: FB_Init
, FB_Reinit
, et FB_Exit
). La méthode est appelée après le traitement des affectations initiales et avant le démarrage des tâches de l'application. Par conséquent, le procédé peut réagir à l'entrée de l'utilisateur.
Lors de l'utilisation FB_Init
ou {attribute 'call_after_init'}
, n'oubliez pas que la détection d'erreurs dans FB_Init
méthode ou dans des méthodes décorées avec le {attribute 'call_after_init'}
est fastidieux, car la définition de points d'arrêt peut ne pas avoir l'effet escompté.
Important
Si le code d'initialisation explicitement défini est atteint lors de l'exécution, l'instance de bloc fonction est déjà complètement initialisée via le code d'initialisation implicite. Par conséquent, il ne doit pas y avoir de SUPER^.FB_Init
appel.
Important
FB_Init
remplace le INI
opérateur qui est utilisé dans CoDeSys V2.3. Les méthodes ne peuvent pas être comparées à la conception d'un constructeur, comme en C#, C++ ou Java. Cela a des conséquences pour les blocs fonctionnels qui étendent d'autres blocs fonctionnels. (Voir ci-dessous : "Blocs fonctions dérivés")
Interface de méthode FB_Init
METHOD FB_Init : BOOL VAR_INPUT bInitRetains : BOOL; // TRUE: the retain variables are initialized (reset warm / reset cold) bInCopyCode : BOOL; // TRUE: the instance will be copied to the copy code afterward (online change) END_VAR
Vous pouvez déclarer des entrées de bloc fonction supplémentaires dans un FB_init
méthode. Ensuite, vous devez définir ces entrées dans la déclaration de l'instance du bloc fonction.
Méthode FB_Init
pour le serialdevice
bloc fonction
METHOD PUBLIC FB_Init : BOOL VAR_INPUT nbInitRetains : BOOL; // initializing of retain variable bInCopyCode : BOOL; // instance is copied to copy code iCOMnum : INT; // additional input: number of the COM interface, that is to be observed END_VAR
Instanciation de la serialdevice
bloc fonction :
com1: serialdevice(iCOMnum:=1); com0: serialdevice(iCOMnum:=0);
Interface de méthode FB_Reinit
METHOD FB_Reinit : BOOL
Interface de méthode FB_Exit
Il y a le paramètre obligatoire bInCopyCode
.
METHOD FB_Exit : BOOL VAR_INPUT bInCopyCode : BOOL; // TRUE: the exit method is called in order to leave the instance which will be copied afterwards (online change). END_VAR
Comportement des blocs fonction dérivés
Si un bloc fonction est dérivé d'un autre bloc fonction, le FB_Init
méthode du bloc fonction dérivé doit définir les mêmes paramètres que la FB_Init
méthode du bloc fonctionnel de base. Cependant, vous pouvez ajouter d'autres paramètres afin de configurer une initialisation spéciale pour l'instance.
Les blocs fonctionnels MainFB
, SubFB
, et SubSubFB
sont dérivés les uns des autres. Donc, SubFB EXTENDS MainFB
et SubSubFB EXTENDS SubFB
appliquer.
FB_Exit
et FB_Init
:fbSubSubFb.FB_Exit(...);
fbSubFb.FB_Exit(...);
fbMainFb.FB_Exit(...);
fbMainFb.FB_Init(...);
fbSubFb.FB_Init(...);
fbSubSubFb.FB_Init(...);