Function block convertiti in un funzione definita dall'utente

Lo scopo principale di queste funzioni è di semplificare la sostituzione dei function block (FB) con le funzioni (FUN). Istanze multiple di FB in subroutine separate sono sostituite da una funzione in una subroutine.

Function block	Funzione convertita

Restrizioni:

Non tutte le istruzioni Panasonic possono essere utilizzate in una funzione comune. Esempi di istruzioni che non possono essere utilizzate in una funzione comune:

• Alcune istruzioni contatore veloce come F166_HighSpeedCounter_Set, F165_HighSpeedCounter_Cam

• Alcune istruzioni di posizionamento come F166_PulseOutput_Set, F171_PulseOutput_Trapezoidal

Deve essere controllato nel dettaglio.

Vantaggi:

• Può richiedere molti meno codici programma

• Può richiedere molti meno relè (R)

• Può essere utilizzato nei circuiti utilizzando gli array delle DUT di memoria

Svantaggi:

• Richiede un lavoro extra di sviluppo e manutenzione

• La funzione convertita deve essere testata molto attentamente

• Richiede più lavoro da parte dell'utente

• Il monitoraggio è più difficile perché non si ha un'istanza da monitorare: solo l'ultima chiamata viene monitorata

• Può richiedere più registri dati (DT)

• Le prestazioni del PLC diminuiscono, il tempo di scansione aumenta

Raccomandazioni per l'uso:

• Le funzioni al posto dei function block dovrebbero essere utilizzate solo se veramente necessarie

• Le funzioni al posto dei function block dovrebbero essere utilizzate solo nella misura realmente necessaria

• Analizzare molto attentamente quale function block convertire per ottenere il massimo beneficio con il minimo impegno

• I criteri principali per decidere se convertire un function block sono: Quanto spesso viene chiamato il function block, quanti passi richiede il function block?

Questa è la formula per calcolare quanti passi per codice programma possano essere salvati.

La situazione attuale è la seguente:

• Un determinato function block

• Viene chiamato X volte

• Utilizza Y passi => numero totale di passi: X * Y passi

• Utilizza TON, SR, flag impulsivi

Il FB dato può essere sostituito da una funzione che richiede quanto segue:

• Passi extra per X chiamate per copiare i dati di DUT di memoria due volte, p.es. X * 2 * 7 passi circa (p.es. per due FP10_BKMV)

• Y * 2 passi per una chiamata di funzione comune (sono probabili altri passi extra)

• Una chiamata comune di:

  • TON_FUN utilizzando xxx passi

  • SR_FUN utilizzando xxx passi

  • R_TRIG_FUN utilizzando xxx passi

Esempio di calcolo per FP0H

Questo calcolo esemplificativo presenta solo cifre approssimative.

• Un determinato function block

• Viene chiamato 30 volte

• Utilizza 750 passi => numero totale di passi: 30 * 750 passi = 22500 passi

• Utilizza TON, SR, flag impulsivi

Il FB dato può essere sostituito da una funzione che richiede quanto segue:

• Passi extra per 30 chiamate per copiare i dati di DUT di memoria due volte, p.es. 30 * 2 * 7 passi = 420 passi (p.es. per due FP10_BKMV)

• 750 * 2 passi per una chiamata di funzione comune = 1500 passi (sono probabili altri passi extra)

• Una chiamata comune di:

  • TON_FUN utilizzando 200 passi

  • SR_FUN utilizzando 35 passi

  • R_TRIG_FUN utilizzando 35 passi

Numero complessivo di passi: 420 passi + 1500 passi + 200 passi + 35 passi + 35 passi = 2119 passi

Risultato: Utilizzando questa funzione si risparmiano circa 22500 passi - 2190 passi = 20310 passi.

Ipotesi: una funzione XXX con una VAR_IN_OUTdutXXX del tipo di dato XXX_FUN_INSTANCE_DUT viene utilizzata in tutti gli esempi

Operazione	Esempio di programmazione originale	Esempio di programmazione convertito
	Chiamate
	FB Intestazione del POU	FUN Intestazione del POU
		DUT XXX_FUN_INSTANCE_DUT
Impostazione Reset
KEEP
Distribuzione condizionale, calcolo
Valori di variabile in incremento/calo
Flag impulsivi
Alla fine della funzione: Se necessario, assegnare alcune variabili di memoria alle variabili di uscita corrispondenti:
SR
RS
TON
TM_100ms

Ipotesi: una funzione XXX con una VAR_IN_OUTdutXXX del tipo di dato XXX_FUN_INSTANCE_DUT viene utilizzata in tutti gli esempi

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;

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

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

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;

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

dutInstance.di1:=dutInstance.di1+1;

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

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;

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

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

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

RS_1(S := bSet,
      R1 := bReset,
      Q1 => bRS2);

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

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_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);