Funzione ENT

[cobe72]

Salve a tutti,

Dovrei eliminare la funzione ENT usata in un FC per la serie 400 per poterlo usare in S7-300.

La ENT non è supportata da s7-300 in quanto questa serie ha solo 2 accumulatori mentre la serie 400 ne ha 4.

Ho 2 parti di codice in cui dovrei applicare la modifica;

      UN    #S_INC
      UN    #S_DEC
      SPB   L401
      L     #S_ABS
      UN    #S_DEC
      SPB   L402
      NEGR  
L402: T     #Abs_Value
      L     "AUX_FD_001"
      LAR1  
      L     MD     4
      LAR2  
      L     MW     8
      +AR1  
      +AR2  
      L     D [AR1,P#0.0]
      L     #Abs_Value
      ENT   
      +R    
      L     D [AR2,P#0.0]
      >R    
      SPB   L403
      TAK   
      L     #MIN_VAL
      <R    
      SPB   L403
      TAK   
L403: T     D [AR1,P#0.0]
      BEA   
L401: NOP   0
 

 

mentre l'altra parte è la seguente:

      AUF   DB [#DB_ENABLE]
      L     #DB_ENABLE_ADDR
      L     #CNT_GB
      +D    
      LAR1  
      U     DBX [AR1,P#0.0]
      SPB   OKV

      L     #MEM_AR1
      LAR1  
      SPA   SKIP

OKV:  AUF   DB [#Var_DB_Nr]
      L     #MEM_AR1
      LAR1  

      L     D [AR1,P#0.0]
      L     #Prp_Factor
      ENT   
      *R    
      +R    
      L     D [AR2,P#0.0]
      >R    
      SPB   L504
      TAK   
      L     #MIN_VAL
      <R    
      SPB   L504
      TAK   
L504: T     D [AR1,P#0.0]
 

 

Qualcuno sarebbe così gentile da aiutarmi nella conversione?

 

Grazie

Saluti

 

 

[DesmoGiec]

Secondo me quel codice non funziona come dovrebbe (o meglio, non funziona per come secondo me avevano pensato funzionasse)

Ent memorizza accu3 in accu4,accu2 in accu3

Serve per non fare il passaggio intermedio di appoggiare valori in word di appoggio, sfruttando i 2 accu in più dei 400.

Ma in questo caso..

      L     D [AR1,P#0.0]	// Qui carica la dword di ar1 in p#0.0 in accu1
      L     #Abs_Value		// Qui memorizza accu1 in accu2, carica in accu1 il valore di Abs_Value
      ENT			// Qui memorizza accu3 in accu4 e accu2 in accu3   
      +R    			// Qui somma Accu1 + Accu2, memorizza il risultato in accu1 e ricarica in accu2 il valore memorizzato in accu3
      L     D [AR2,P#0.0]	// Qui memorizz accu1 (quindi la somma fatta prima) in accu2 e carica in accu1 il valore della dword in p#0.0 di ar2.

Quindi il valore memorizzato in accu3 per poi riusarlo successivamente in accu2, te lo sei perso quando sei andato a caricare il valore di ar2.

Ti riporto un esempio pratico.

Come vedi, il programma carica il valore di md4(11) in accu1

Successivamente memorizza md4(11) in accu2, e carica in accu1 il valore di md0(10)

Con ent copia ac3 in ac4, ac2 in ac3

Somma poi ac1 con ac2 (10+11), e memorizza in ac1 (21). In ac2 memorizza il contenuto di ac3

Qui l'errore, al momento che deve fare il confronto.

Ac1 = somma fatta precedentemente, ac2= valore ripescato da ac3.

Caricando il valore di ar2 (la mia md8 in esempio), succede che memorizza ac1 (la somma) in ac2, e in ac1 memorizza il valore di md8.

Di fatto, il vecchio valore di ac2 preso da ac3, te lo perdi.

 

In conclusione, ENT, usato come lo vedo, non ha senso.

Per la conversione (per quanto riguarda la prima porzione di programma) ti basta cancellarlo. Non serve altro codice sostitutivo..

ENT è invece usato correttamente nella seconda parte di codice che hai postato.

Ti riporto un esempio pratico e più leggibile

 

(i valori in parentesi indicano i valori di accu1 e accu2 rispettivamente)

Carico md100 in accu1 (9 0)

Copio accu1 in accu2, carico md104 in accu1 (8 9)

sommo accu1 con accu2 e memorizzo in accu1 (accu2 si libera) (17 0)

copio accu1 in accu2, carico in accu2 md108 (7 17)

copio accu3 in accu4, accu2 in accu3 (7 17) (accu3 = 17)

Copio accu1 in accu2, carico in accu1 md112 (6 7) (accu3 = 17)

Sottraggo accu1(6) da accu2(7), memorizzo in accu1, ricarico in accu2 il valore di accu3 (1 17)

Moltiplico accu1 con accu2, memorizzo in accu1, accu2 si libera (17 0)

Trasferisco in md116

 

Ent è quindi usato per:

ho fatto la somma ed ho ottenuto il valore 17. Ent mi memorizza il 17.

Vado poi a fare 7-6, e moltiplico il risultato per il 17 precedentemente memorizzato.

Risparmio al programma questa operazione:

(colonna sinistra = funzionamento con ent, colonna destra = funzionamento senza ent con 2 accu classici)

L MD100		// L MD100
L MD104		// L MD104
+D		// +D
-----		// T #APP
L MD108		// L MD108
ENT		// -----
L MD112		// L MD112
-D		// -D
*D		// L #APP
T MD116		// *D
-----		// T MD116

Ed il suo corrispettivo esempio a plc

Prima parte con ENT, seconda parte con sistema "tradizionale"

 

 

Ent, quindi, funziona in caso di operazioni.

Se usi ent e poi vai a fare dei load, il plc va a sovrascrivere i valori e l'uso di ent è inutile. (prima parte di codice da te postata)

 

Per la seconda parte, fai come ho fatto qui sopra, ossia:

      L     D [AR1,P#0.0]
      L     #Prp_Factor
      ENT   
      *R    
      +R    
      L     D [AR2,P#0.0]

 

diventa

 

      L     D [AR1,P#0.0]
      L     #Prp_Factor
      *R    

      L     D [AR1,P#0.0]
      +R    
      L     D [AR2,P#0.0]

 

 

 

Scusa la lunghezza estrema del post, ma scriverti la soluzione senza fornirti una spiegazione ti avrebbe risolto il problema senza farti capire il funzionamento di ent