Blocs fonctions convertis en une fonction définie par l’utilisateur

Convertir un bloc fonction en une fonction définie par l’utilisateur pour réduire le nombre de pas de programme.

Sujet parent : Blocs fonctions

Utilisation

Le but principal de ces fonctions est de faciliter le remplacement des blocs fonctions (FB) par des fonctions (FUN). De multiples instances FB dans des sous-programmes séparés sont remplacées par une seule fonction dans un sous-programme.

Exemple

Bloc fonction

Fonction convertie

Restrictions :

Toutes les instructions Panasonic ne peuvent pas être utilisées dans une fonction commune. Exemples d’instructions qui ne peuvent pas être utilisées dans une fonction commune :

  • Certaines instructions compteurs rapides telles que F166_HighSpeedCounter_Set, F165_HighSpeedCounter_Cam

  • Certaines instructions de positionnement telles que F166_PulseOutput_Set, F171_PulseOutput_Trapezoidal

À vérifier en détails.

Avantages :

  • Beaucoup moins de code programme peut être requis.

  • Beaucoup moins de drapeaux (R) peuvent être nécessaires.

  • Utilisation possible dans des boucles avec tableaux (arrays) de DUT mémoires

Inconvénients :

  • Travail supplémentaire pour le développement et l’entretien

  • La fonction convertie doit être testée prudemment

  • Plus d’efforts demandés à l’utilisateur

  • Monitoring plus difficile car aucune instance ne peut être supervisée, seul le dernier appel peut être supervisé

  • Plus de registres de données (DT) peuvent être nécessaires

  • Baisse de performance de l’automate et augmentation du temps de scrutation

NOTA

  • Le comportement des fonctions de temporisation peut varier légèrement par rapport aux blocs fonctions de temporisation.

  • Vérifiez bien que le comportement de la nouvelle fonction corresponde à celui du bloc fonction, en particulier si la nouvelle fonction doit être appelée plusieurs fois.

Recommandations d’utilisation :

  • Utilisez des fonctions à la place de blocs fonctions uniquement lorsque c’est nécessaire.

  • N’utilisez pas plus de fonctions à la place de blocs fonctions que nécessaire.

  • Faites une analyse précise pour savoir quel bloc fonction doit être converti pour en tirer le meilleur profit avec un minimum de travail.

  • Les critères principaux permettant de décider si un bloc fonction doit être converti sont les suivants : combien de fois le bloc fonction est-il appelé, de combien de pas le bloc fonction a-t-il besoin ?

Estimation des pas de code programme économisés

La formule ci-dessous permet de calculer combien de pas de code programme peuvent être économisés.

La situation actuelle est la suivante :

  • Un bloc fonction donné

  • Est appelé X fois

  • Utilise Y pas => nombre total de pas : X * Y pas

  • Utilise TON, SR, drapeaux d’impulsion

Le bloc fonction donné peut être remplacé par une fonction nécessitant ce qui suit :

  • Des pas supplémentaires pour X appels pour copier deux fois les données du DUT mémoire, c.-à-d. X * 2 * 7 pas environ (par ex. pour deux FP10_BKMV)

  • Y * 2 pas pour un appel d’une fonction commune (des pas supplémentaires sont supposés)

  • Un appel commun de :

    • TON_FUN utilisant xxx pas

    • SR_FUN utilisant xxx pas

    • R_TRIG_FUN utilisant xxx pas

Exemple de calcul pour FP0H

Cet exemple de calcul ne donne que des chiffres approximatifs.

  • Un bloc fonction donné

  • Est appelé 30 fois

  • Utilise 750 pas => nombre total de pas : 30 * 750 pas = 22500 pas

  • Utilise TON, SR, drapeaux d’impulsion

Le bloc fonction donné peut être remplacé par une fonction nécessitant ce qui suit :

  • Des pas supplémentaires pour 30 appels pour copier deux fois les données du DUT mémoire, c.-à-d. 30 * 2 * 7 pas = 420 pas (par ex. pour deux FP10_BKMV)

  • 750 * 2 pas pour un appel d’une fonction commune = 1500 pas (des pas supplémentaires sont supposés)

  • Un appel commun de :

    • TON_FUN utilisant 200 pas

    • SR_FUN utilisant 35 pas

    • R_TRIG_FUN utilisant 35 pas

Nombre total de pas : 420 pas + 1500 pas + 200 pas + 35 pas + 35 pas = 2190 pas

Résultat : Avec cette fonction, vous économisez environ 22500 pas - 2190 pas = 20310 pas.

Comment convertir un bloc fonction en une fonction définie par l’utilisateur

Procédure de conversion d’un bloc fonction utilisateur XXX en une fonction XXX_FUN

Nous recommandons de respecter les conventions de noms.

  1. Faire une copie du bloc fonction défini par l’utilisateur XXX et le nommer XXX_FUN

    Gardez le bloc fonction XXX, ne le supprimez pas !

  2. Utiliser la boîte de dialogue Propriétés du POU pour modifier la copie du bloc fonction en une fonction
  3. Définir un DUT mémoire, par ex. XXX_FUN_INSTANCE_DUT qui contient toutes les variables avec mémoire et tous les DUT mémoires d’autres fonctions copies de FB appelées
  4. Définir une variable d’entrée/sortie VAR_IN_OUT avec ce DUT mémoire, par ex. dutXXX du type de données XXX_FUN_INSTANCE_DUT
  5. Dans le corps de fonction procéder de la façon suivante pour toutes les variables pour lesquelles une mémoire est nécessaire par ex. parce qu’elles sont utilisées dans les bobines SET/RESET, dans des calculs conditionnels ou des valeurs de variables croissantes/décroissantes :
    1. Définir la même variable dans le DUT mémoire XXX_FUN_INSTANCE_DUT
    2. Remplacer la variable par l’élément de DUT mémoire
    3. Si certaines des variables remplacées par des variables mémoires dans le DUT mémoire sont en sortie de fonction, elles doivent être affectées à la variable de sortie correspondante.
  6. Remplacez toutes les instances de bloc fonction par le DUT mémoire de la fonction correspondante, qui doit être défini dans le DUT mémoire XXX_FUN_INSTANCE_DUT
  7. Remplacer tous les appels d’instances de bloc fonction par l’appel de fonction correspondant avec le DUT mémoire correspondant

    Si un bloc fonction standard avec EN/ENO doit être remplacé, mettez la fonction correspondante dans une fonction EN/ENO et appelez cette fonction. Par exemple, mettez la fonction TON_FUN dans une fonction EN/ENO (E_TON_FUN) et appelez-la.

  8. Remplacez tous les drapeaux d’impulsion par l’appel de RTRIG_FUN/FTRIG_FUN correspondant
  9. Vérifier correctement que le comportement de la nouvelle fonction corresponde à celui du bloc fonction, en particulier si la nouvelle fonction doit être appelée plusieurs fois

Exemples de conversions LD/FBD

Une fonction XXX avec une variable VAR_IN_OUT et un DUT mémoire dutXXX de type de données XXX_FUN_INSTANCE_DUT est utilisée dans tous les exemples.

Opération

Programme d’origine

Programme avec FB converti en fonction
 

Appels
 

En-tête du POU bloc fonction

En-tête du POU fonction
   

DUT XXX_FUN_INSTANCE_DUT

Set

Reset

KEEP

Affectation, calcul conditionnels

Valeurs de variables croissantes/décroissantes

Drapeaux d’impulsion

À la fin de la fonction : si nécessaire, affectez des variables mémoires aux variables de sorties correspondantes :

SR

RS

TON

TM_100ms

Exemples de conversion ST

Une fonction XXX avec une variable VAR_IN_OUT et un DUT mémoire dutXXX de type de données XXX_FUN_INSTANCE_DUT est utilisée dans tous les exemples.

Opération

Programme d’origine

Programme avec FB converti en fonction

Set

Reset

 
if (bSet) then
	bSR1:=true;
elsif (bReset) then
	bSR1:=false;
end_if;
 
if (bSet) then
	dutInstance.bSR1:=true;
elsif (bReset) then
	dutInstance.bSR1:=false;
end_if;

KEEP

 
bRS1 := KEEP(SetTrigger := bSet,
             ResetTrigger := bReset);
 
dutInstance.bRS1 := KEEP(SetTrigger := bSet,
                         ResetTrigger := bReset);

Affectation, calcul conditionnels

 
if (bReset) then
	di1:=0;
end_if;
if (bTrig) then
	w1 := ROL(IN := w1, N := 1);
end_if;
 
if (bReset) then
	dutInstance.di1 :=0;
end_if;
if (bTrig) then
	dutInstance.w1 := ROL(IN := dutInstance.w1, N := 1);
end_if;

Valeurs de variables croissantes/décroissantes

 
di1:=di1+1;
w2:=w2 OR w1;
 
dutInstance.di1:=dutInstance.di1+1;

dutInstance.w2:=dutInstance.w2 OR dutInstance.w1;

Drapeaux d’impulsion

 
if (DF(bSet) OR DFN(bSet)) then
	di2:=di2+1;
end_if;
 
R_TRIG_FUN(CLK := bSet,
           dutInstance := dutInstance.dutRTrig1,
           Q => bQTemp1);
F_TRIG_FUN(CLK := bSet,
           dutInstance := dutInstance.dutFTrig1,
           Q => bQTemp2);
if (bQTemp1 OR bQTemp2) then
    dutInstance.di2:=dutInstance.di2+1;
end_if;

À la fin de la fonction : si nécessaire, affectez des variables mémoires aux variables de sorties correspondantes :

 
bSR1:=dutInstance.bSR1;
bRS1:=dutInstance.bRS1;
di1:=dutInstance.di1;
di2:=dutInstance.di2;
w1:=dutInstance.w1;
w2:=dutInstance.w2;

SR

 
SR_1(S1 := bSet,
     R := bReset,
     Q1 => bSR2);

SR_FUN(Set := bSet,
        Reset := bReset,
        dutInstance := dutInstance.dutSR_1, Q1 => bSR2);

RS

 
RS_1(S := bSet,
      R1 := bReset,
      Q1 => bRS2);
 
RS_FUN(Set := bSet,
        Reset := bReset,
        dutInstance := dutInstance.dutRS_1,
        Q1 => bRS2);

TON

 
TON1(IN := bIN,
      PT := T#10S,
      Q => bQ1, ET => tET1);
 
TON_FUN(IN := bIN,
        PT := T#10s,
        dutInstance := dutInstance.dutTon1,
        Q => bQ1, ET => dutInstance.tET1);

TM_100ms

 
TM_100ms_1(start := bIN,
            SV := 100,
            T => bT1,
            EV => iEV1);
 
TM_100ms_FUN(start := bIN,
              SV := 100,
              dutInstance := dutInstance.dutTM_100ms_1,
              T => bT1, EV => dutInstance.iEV1);
Thèmes apparentés

CT_FUN

CTD_FUN

CTU_FUN

CTUD_FUN

F_TRIG_FUN

R_TRIG_FUN

RS_FUN

SR_FUN

TM_100ms_FUN

TM_10ms_FUN

TM_1ms_FUN

TM_1s_FUN

TOF_FUN

TON_FUN

TP_FUN

Modifié le : 2023-03-08Commentaires sur cette pageAssistance téléphonique