S7 1200: scalare ingresso analogico

[Domocla]

Buongiorno, 

la procedura per scalare gli ingressi analogici (es. 4-20mA) e' chiara.

 

A me piacerebbe realizzare un fb nel quale l'utente, tramite HMI, si setta autonomamente i riferimenti per tarare il suo strumento?

 

Mi piacerebbe trovare una soluzione affinche' il manutentore sia autonomo nel tararsi lo strumento e possa utilizzare qualsiasi strumento (ovviamente da 4-20 mA se l'ingresso e' tale) senza intervenire con TIA.

 

La mia idea e' prendere 6 riferimenti ( 4, 8, 12, 16, 20) introdurre i dati e scalare la misura.

 

Cosa consigliereste?

 

Grazie

[pigroplc]

La differenza la fa il fatto che la risposta sia lineare o no:

mi spiego meglio, se per esempio hai una pressione 4-20 mA che corrisponde a 400 BAR basta che prendi il numero che leggi (0-27648 per fare un esempio) e fai una proporzione.

Se invece la risposta non è lineare la cosa è ugualmente facile ma ti serve una funzione che linearizza la risposta in vari punti in modo che fai le spezzate. Io ho preso il codice di una funzione standard di Simotion e l'ho migrata sul 1500 in modo da avere la linearizzazione delle valvole proporzionali di pressione.

Fammi sapere se è questo che cerchi.

 

[pigroplc]

11:35 26/01/19FUNCTION "FC67 - (P) FCHelpCalculate" : Real
{ S7_Optimized_Access := 'FALSE' }
VERSION : 0.1
   VAR_INPUT 
      in : Real;
      xn : Real;
      xm : Real;
      yn : Real;
      ym : Real;
   END_VAR


BEGIN
	// ---------------------------------------------------------------------------
	//(A&D B18 / Köln)
	// ---------------------------------------------------------------------------
	//  functionality:  . function for FBInterpolate8Points
	//  assignment: Suite for the FB67 Interpolation 8 points for the main proportional valves
	//  for presses 
	// ---------------------------------------------------------------------------
	//  change log table:
	//  version     date        expert in charge        changes applied          
	//  01.00.00    13.06.18    pigroplc                created
	// =========================================================================== 
	// 
	(* check division by zero ? *)
	
	IF ((#xm - #xn) > 0) THEN
	    (* interpolate straight line *)   
	    #"FC67 - (P) FCHelpCalculate":= (#in - #xm) * (#ym - #yn) / (#xm - #xn) + #ym;
	ELSE
	    #"FC67 - (P) FCHelpCalculate":= #yn;
	END_IF;
	
END_FUNCTION

FUNCTION "FC68 - (P) FCInterpolate8Points" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      inXvalue : Real;   // (* input x-value *)
      xValueP1 : Real;   // (* x-value of point P1 *)
      xValueP2 : Real;   // (* x-value of point P2 *)
      xValueP3 : Real;   // (* x-value of point P3 *)
      xValueP4 : Real;   // (* x-value of point P4 *)
      xValueP5 : Real;   // (* x-value of point P5 *)
      xValueP6 : Real;   // (* x-value of point P6 *)
      xValueP7 : Real;   // (* x-value of point P7 *)
      xValueP8 : Real;   // (* x-value of point P8 *)
      yValueP1 : Real;   // (* y-value of point P1 *)
      yValueP2 : Real;   // (* y-value of point P2 *)
      yValueP3 : Real;   // (* y-value of point P3 *)
      yValueP4 : Real;   // (* y-value of point P4 *)
      yValueP5 : Real;   // (* y-value of point P5 *)
      yValueP6 : Real;   // (* y-value of point P6 *)
      yValueP7 : Real;   // (* y-value of point P7 *)
      yValueP8 : Real;   // (* y-value of point P8 *)
   END_VAR

   VAR_OUTPUT 
      PAW : Word;   // (* PAW periphery output *)
      error : Bool;   // (* error x-values *)
   END_VAR

   VAR_TEMP 
      outYvalue : Real;   // (* output: y-value of input x-value *)
      outYvalueInt : Int;
   END_VAR


BEGIN
	// ---------------------------------------------------------------------------
	//(A&D B18 / Köln)
	// ---------------------------------------------------------------------------
	//  functionality:  interpolate straight line by eight points with limitation
	//  assignment: used for press output main pressure proportional valve linearization
	//  in case of limited points leave the unused point same as the upper valid one
	// ---------------------------------------------------------------------------
	//  change log table:
	//  version     date        expert in charge        changes applied          
	//  01.01.00    14.06.18    pigroplc                created
	// ===========================================================================
	
	(* check connector x-values *)
	
	IF ((#xValueP8 < #xValueP7)
	    OR (#xValueP7 < #xValueP6)
	    OR (#xValueP6 < #xValueP5)
	    OR (#xValueP5 < #xValueP4)
	    OR (#xValueP4 < #xValueP3)
	    OR (#xValueP3 < #xValueP2)
	    OR (#xValueP2 < #xValueP1)) THEN
	(* x-values not increasing *)
	    #error := TRUE;
	    #outYvalue := #yValueP1;
	ELSE
	(* x-values correct *)
	    #error := FALSE;
	    IF (#inXvalue <= #xValueP1) THEN
	        #outYvalue := #yValueP1;
	        (* inXvalue between xValueP1, xValueP2 *)
	        
	    ELSIF (#inXvalue <= #xValueP2) THEN
	        #outYvalue := "FC67 - (P) FCHelpCalculate"(in := #inXvalue,
	                                                   xn := #xValueP1,
	                                                   xm := #xValueP2,
	                                                   yn := #yValueP1,
	                                                   ym := #yValueP2);
	        (* inXvalue between xValueP2, x3 *)
	        
	    ELSIF (#inXvalue <= #xValueP3) THEN
	        #outYvalue := "FC67 - (P) FCHelpCalculate"(in := #inXvalue,
	                                                   xn := #xValueP2,
	                                                   xm := #xValueP3,
	                                                   yn := #yValueP2,
	                                                   ym := #yValueP3);
	        (* inXvalue between xValueP3, xValueP4 *)
	        
	    ELSIF (#inXvalue <= #xValueP4) THEN
	        #outYvalue := "FC67 - (P) FCHelpCalculate"(in := #inXvalue,
	                                                   xn := #xValueP3,
	                                                   xm := #xValueP4,
	                                                   yn := #yValueP3,
	                                                   ym := #yValueP4);
	        
	        (* inXvalue between xValueP4, xValueP5 *)
	        
	    ELSIF (#inXvalue <= #xValueP5) THEN
	        #outYvalue := "FC67 - (P) FCHelpCalculate"(in := #inXvalue,
	                                                   xn := #xValueP4,
	                                                   xm := #xValueP5,
	                                                   yn := #yValueP4,
	                                                   ym := #yValueP5);
	        
	        (* inXvalue between xValueP5, xValueP6 *)
	        
	    ELSIF (#inXvalue <= #xValueP6) THEN
	        #outYvalue := "FC67 - (P) FCHelpCalculate"(in := #inXvalue,
	                                                   xn := #xValueP5,
	                                                   xm := #xValueP6,
	                                                   yn := #yValueP5,
	                                                   ym := #yValueP6);
	        
	        (* inXvalue between xValueP6, xValueP7 *)
	        
	    ELSIF (#inXvalue <= #xValueP7) THEN
	        #outYvalue := "FC67 - (P) FCHelpCalculate"(in := #inXvalue,
	                                                   xn := #xValueP6,
	                                                   xm := #xValueP7,
	                                                   yn := #yValueP6,
	                                                   ym := #yValueP7);
	        
	        (* inXvalue between xValueP7, xValueP8 *)
	        
	    ELSIF (#inXvalue <= #xValueP8) THEN
	        #outYvalue := "FC67 - (P) FCHelpCalculate"(in := #inXvalue,
	                                                   xn := #xValueP7,
	                                                   xm := #xValueP8,
	                                                   yn := #yValueP7,
	                                                   ym := #yValueP8);
	        
	    ELSE
	        #outYvalue := #yValueP8;
	    END_IF; (* IF (inXvalue <= xValueP1) *)
	    
	END_IF; (* IF (xValueP8 < xValueP7 OR xValueP7 < xValueP6 OR xValueP6 < xValueP5 OR xValueP5 < xValueP4 OR xValueP4 < xValueP3 OR xValueP3 < xValueP2 OR xValueP2 < xValueP1) *)
	
	
	(* convert to output card format outgoing signal from real to int *)
	#outYvalueInt := REAL_TO_INT( #outYvalue);
	#PAW :=  #outYvalueInt;
	
	
	
	
END_FUNCTION

Beccati questo codice salvalo come estensione SCL e importalo da TIA. 

1) copiarlo mi esonera da qualsiasi responsabilità in caso di errati malfunzionamenti o incomprensioni
2) Non cambiare il nome dello sviluppatore ma se ti serve cambiare qualcosa aggiungi una riga al commento

Modificato: 26 gennaio 2019 da pigroplc
3) richiama la FC68 con i parametri della linearizzazione

[Domocla]

Che efficienza. 

Testo e vi tengo informati.

Grazie

[pigroplc]

57 minuti fa, Domocla scrisse:

Che efficienza. 

Nei paesi arabi oggi è come se fosse lunedì, magari fossi a casa in Italia.....

[Domocla]

10 ore fa, pigroplc scrisse:

Nei paesi arabi oggi è come se fosse lunedì, magari fossi a casa in Italia.....

Pensa che io sono in Italia e lavoro. Tranquillo, non sei solo 😜.

Grazie.

[max.bocca]

Soluzione ottima, soluzione che adottò per lasciare massima libertà nella sostituzione dei sensori. Può capitare che durante una stagione si guasta un sensore e si trova in scorta uno adattabile con range diverso.

Io prevedo due campi per quelli lineari, il valore Min e Max (equ 4 e 20mA esempio per sensori 4/20mA)

Quindi calcolo l'equivalente ad un 1mA > EmA = (Max - Min)/16 ecc 

[pigroplc]

Max,

la soluzione che ho postato ha il vantaggio di linearizzare un sensore o il pilotaggio di una valvola per ottenere il risultato preciso lungo tutto il campo di lavoro.

Nello specifico dovevo garantire la precisione di pressata in una linea presse fatta col 1500. Siccome io uso normalmente Simotion, non ho fatto che migrare il codice SCL del blocco di mamma Siemens e l'ho adattato al mio fabbisogno.

Ovviamente avere 8 spezzate consente di andare dietro alla valvola e ottenere il valore in TON/BAR preciso, forse anche troppo.....

Sono sicuro che col tempo servirà pure a qualcun altro.