appel de méthode

Pour implémenter un appel de méthode, les paramètres réels (arguments) sont passés aux variables d'interface. Alternativement, les noms des paramètres peuvent être omis.

Selon le modificateur d'accès déclaré, une méthode ne peut être utilisée que dans son propre espace de noms (INTERNAL), uniquement dans le propre bloc de programmation et ses dérivés (PROTECTED) ou uniquement dans votre propre bloc de programmation (PRIVATE) être appelé. à PUBLIC la méthode peut être appelée n'importe où.

Au sein de l'implémentation, une méthode peut s'appeler elle-même récursivement, soit directement au moyen du CE pointeur ou au moyen d'une variable locale pour le bloc fonction affecté.

Appel de méthode en tant qu'appel de fonction virtuelle

L'héritage peut conduire à des appels de fonctions virtuelles.

Les appels de fonctions virtuelles permettent au même appel dans le code source du programme d'invoquer différentes méthodes lors de l'exécution.

L'appel de méthode est dynamiquement lié dans les cas suivants :

Vous appelez une méthode à l'aide d'un pointeur vers un module fonction.
Exemple: pfub^.method
Dans cette situation, le pointeur peut pointer sur des instances du type de bloc fonctionnel et sur des instances de tous les blocs fonctionnels dérivés.
Vous appelez la méthode d'une variable d'interface.
Exemple: interface1.method
L'interface peut faire référence à toutes les instances de blocs fonctionnels qui implémentent cette interface.
Une méthode appelle une autre méthode du même module fonction. Dans ce cas, la méthode peut également appeler la méthode d'un bloc fonction dérivé de même nom.
Une méthode est appelée en utilisant une référence à un module de fonction. Dans cette situation, la référence peut pointer vers des instances du type de bloc fonctionnel et vers des instances de tous les blocs fonctionnels dérivés.
vous pointez VAR_IN_OUT-Variables d'un type de bloc fonctionnel de base à une instance d'un type de FB dérivé.
Dans cette situation, la variable peut pointer vers des instances du type du bloc fonctionnel et vers des instances de tous les blocs fonctionnels dérivés.

Exemple

Exemple 31. méthodes surchargées

Les blocs fonctionnels fub1 et fub2 développer le bloc fonction fubbase et implémenter l'interface interface1. Il y a les méthodes method1 et method2.

PROGRAM PLC_PRG
VAR_INPUT
  b : BOOL;
END_VAR

VAR  pInst : POINTER TO fubbase;
  instBase : fubbase;
  inst1 : fub1;
  inst2 : fub2;
  instRef : REFERENCE to fubbase;
END_VAR

IF b THEN
  instRef REF= inst1;            (* reference to fub1 *)
  pInst := ADR(instBase);
ELSE
  instRef REF= inst2;            (* reference to fub2  *)
  pInst := ADR(inst1);
END_IF
pInst^.method1();            (* If b is TRUE, fubbase.method1 will be called, otherwise fub1.method1 is called *)
instRef.method1();        (* If b ist TRUE, fub1.method1 will be called, otherwise fub2.method1 is called*)

En admettant que fubbase de l'exemple ci-dessus deux méthodes method1 et method2 contient, écrase fub1 method2, mais non method1. L'appel de method1 se déroule comme suit :

pInst^.method1();

Lorsque b TRUE est, appelle CODESYSfubbase.method1 vers le haut, sinon fub1.method1.

Sorties supplémentaires

Selon la norme CEI 61131-3, les méthodes, comme les fonctions normales, peuvent avoir des sorties supplémentaires déclarées. Lors de l'appel de la méthode, vous affectez des variables aux sorties supplémentaires.

Vous trouverez des informations détaillées à ce sujet sous la rubrique "Fonction".

Syntaxe à l'appel

<function block name>.<method name>(<first input name> := <value> (, <further input assignments>)+ , <first output name> => <first output variable name> (,<further output assignments>)+ );

Exemple 32. Exemple

déclaration

METHOD PUBLIC DoIt : BOOL
VAR_INPUT
        iInput_1 : DWORD;
        iInput_2 : DWORD;
END_VAR
VAR_OUTPUT
        iOutput_1 : INT;
        sOutput_2 : STRING;
ENDVAR

appeler

fbInstance.DoIt(iInput_1 := 1, iInput_2 := 2, iOutput_1 => iLocal_1, sOUtput_2 => sLocal_2);

Lorsque la méthode est appelée, les valeurs des sorties de la méthode sont écrites dans la variable de sortie déclarée localement.

Appel d'une méthode même si l'application est en état STOP

Il peut être défini dans la description de l'appareil qu'une certaine instance de bloc fonctionnel (d'un bloc de bibliothèque) appelle toujours une certaine méthode dans un cycle de tâche. Si la méthode prend les paramètres d'entrée de l'exemple suivant, cela fonctionne CODESYS la méthode démarre également lorsque l'application active est actuellement à l'état STOP :

Exemple 33. Exemple

VAR_INPUT
        pTaskInfo : POINTER TO DWORD;
        pApplicationInfo: POINTER TO _IMPLICIT_APPLICATION_INFO;
END_VAR

(*Now the status of the application can be queried via pApplicationInfo and the instructions can be implemented: *)

IF pApplicationInfo^.udState = 1 THEN <instructions> END_IF;

Appelez la méthode de manière récursive

Astuce

Utilisez les récursions principalement pour manipuler des types de données récursifs tels que des listes chaînées. En général, il est conseillé d'être prudent lors de l'utilisation de la récursivité. Une récursivité d'une profondeur inattendue peut entraîner un débordement de pile et donc un arrêt de la machine.

Dans son implémentation, une méthode peut s'appeler :

Directement au moyen du CE aiguille
indirectement à l'aide d'une instance de bloc fonction local du bloc fonction de base

Un avertissement du compilateur est généralement émis avec un tel appel récursif. Si la méthode avec le pragma {attribute 'estimated-stack-usage' := '<estimated stack size in bytes>'} est fourni, l'avertissement du compilateur est supprimé. Dans le chapitre Attribut 'estimated-stack-usage voir un exemple d'implémentation.

Dans cette section: