Con Udt Le Fc O Fb Aumentano La Memoria Lavoro Del 70%

[a.rezzan]

Salve,

ho fatto una prova. Ho scritto una FB che gestisce un motore (niente di che).

Inizialmente ho usato i parametri IN, OUT, IN-OUT, STAT e TEMP, come normalmente si fa.

La inserisco in OB1 per utilizzarla e mi accorgo che esteticamente è veramente troppo lunga a causa dei numerosi parametri che utilizza.

Allora mi viene in mente di accorpare i parametri in un UDT e passarlo come parametro proprio per ridurre l'estetica della FB.

Fino a qui niente di nuovo, la FB si ridotta drasticamente e io sono contento.....fino a quando mi accorgo che la dimensione della memoria lavoro aumentata.

Ho verificato e dopo i cambiamenti dovuti all'utilizzo dell'UDT ho constatato che la memoria è aumentata del 72%, solo dovuta al fatto di utilizzare l'UDT.

Da sapere che la FB è stata scritta in KOP.

Perchè questa differenza? E se l'avessi scritta in AWL (ma non lo conosco) avrei avuto lo stesso "spreco" di memoria?

Grazie a tutti.

[dan64100]

proprio per ridurre l'estetica della FB

E hai fai fatto bene, l'estetica in questo caso è "leggibilità", praticamente la base della manutenzione (secondo me).

Se hai fatto un programmino di test ed hai praticamente solo quella FB un'aumento del 72% mi fa pensare ad un raddoppio della memoria utilizzata, anche se non dovrebbe essere così in quanto tu lavori sui campi dell'udt (che passi come puntatore) e non sulla memoria interna dell'FB giusto ?

In soldoni se hai la variabile real speed come campo della tua variabile di tipo udt, questa è allocata come 4 byte di memoria solo nella DB che contiene la variabile struttura. Dai un'occhiata alla DB d'istanza generata, non dovresti trovarne traccia, in caso contrario hai una duplicazione della memoria allocata.

Le variabili temporanee le continui a mantenere nell'FB ?

Ovviamente sono ipotesi non conoscendo il tuo codice.

Fra KOP e AWL non c'è molta differenza.

[a.rezzan]

Scusa ma non riesco a capire quando dici "lavori sui campi dell'udt (che passi come puntatore) e non sulla memoria interna dell'FB giusto ?"

Faccio un esempio nella speranza di aiutare la comprensione, anche se ridotto all'osso.

Creo FB_Motore con:

- INPUT

• "I_PulsanteAvanti" (Bool)
• "I_PulsanteIndietro" (Bool)
• "I_SensoreRallentamento" (Bool)
• "I_SensoreStop" (Bool)
• "I_Velocita" (int)
• "I_Accelerazione" (Int)

- OUTPUT

• "O_Avanti" (Bool)
• "O_Indietro" (Bool)
• "O_Velocita" (Bool)
• "O_Accelerazione" (Bool)

e al suo interno dei conti ... (che non ci interessano)

Creo il DB di istanza e lo chiamo DB_MotCatena.

Nell'OB1 istanzio FB_Motore e la allaccio a DB_MotCatena.

Osservazione: Posso utilizzare le variabili della DB_MotCatena nell'OB1 così: DB_MotCatena.I_PulsanteAvanti, ma personalmente lo evito.

Lo evito perchè se un domani dovessi modificare la composizione e l'ordine dei parametri di FB_MotCatena in OB1 succederebbe un macello a livello di indirizzi.

Allora ho pensato di crearmi in aggiunta un UDT contenente gli stessi parametri della FB_MotCatena, ossia:

UDT_Motore così composto:

• "I_PulsanteAvanti" (Bool)
• "I_PulsanteIndietro" (Bool)
• "I_SensoreRallentamento" (Bool)
• "I_SensoreStop" (Bool)
• "I_Velocita" (int)
• "I_Accelerazione" (Int)
• "O_Avanti" (Bool)
• "O_Indietro" (Bool)
• "O_Velocita" (Bool)
• "O_Accelerazione" (Bool)

poi creo un DB derivato da UDT_Motore e lo chiamo DB_DatiMotCatena.

A questo punto ai parametri IN e OUT della FB_Motore (che ha come DB di istanza DB_MotCatena) associo i dati di UDT_Motore.

Ex.

DB_MotCatena

|----------------------------------------------------------------|

| FB_Motore |

| |

DB_DatiMotCatena.I_PulsanteAvanti | I_PulsanteAvanti O_Avanti |

.......

|----------------------------------------------------------------|

I dati di DB_DatiMotCatena li uso nell'OB1, al posto di quelli di DB_MotCatena (che sarebbe un doppione!!).

Il vantaggio principale è che se un domani modifico la truttura dei parametri della FB non mi si incasina l'OB1.

La prova che ho fatto e stata quella di sostituire i parametri di FB_Motore con:

- INPUT_OUTPUT

• Dati (di tipo UDT_Motore)

che apparentemente dovrebbe essere la stessa cosa, ma a livello di occupazione di memoria lavoro direi prorio di no.

Spero di essere stato un tantino più chiaro.

Grazie.

[a.rezzan]

Ho capito la causa, ma non me la spiego.

La memoria aumenta perchè ho inserito l'UDT nei parametri INPUT_OUTPUT!

Mentre se li metto in INPUT o OUTPUT la memoria non cambia.

[JumpMan]

Osservazione: Posso utilizzare le variabili della DB_MotCatena nell'OB1 così: DB_MotCatena.I_PulsanteAvanti, ma personalmente lo evito.

Lo evito perchè se un domani dovessi modificare la composizione e l'ordine dei parametri di FB_MotCatena in OB1 succederebbe un macello a livello di indirizzi.

Solo una precisazione: se scegli preferenza simbolo per tutti gli accessi (dopo aver premuto tasto dx sulla cartella blocchi) il software ragiona in simbolico e non incasina più niente quando modifichi le DB. Il rovescio della medaglia è che devi ricompilare dopo ogni modifica.

Io uso spesso questo sistema quando devo modificare parecchi indirizzi e/o dati nelle DB, poi quando ho finito rimetto preferenza assoluto, il ricablaggio lo uso solo se si tratta di pochi operandi.

ciao