//以下FC105；
FUNCTION "SCALE" : WORD
TITLE =SCALING VALUES
//
AUTHOR : SEA
FAMILY : CONVERT
NAME : SCALE
VERSION : 2.1


VAR_INPUT
IN : INT ; // input value to be scaled
HI_LIM : REAL ; // upper limit in engineering units
LO_LIM : REAL ; // lower limit in engineering units
BIPOLAR : BOOL ; // 1=bipolar; 0=unipolar
END_VAR
VAR_OUTPUT
OUT : REAL ; // result of the scale conversion
END_VAR
VAR_TEMP
IN_REAL : REAL ; // input value as a REAL number
K1 : REAL ; // low limit for input value
K2 : REAL ; // high limit for input value
SPAN : REAL ; // HI_LIM - LO_LIM
TEMP1 : REAL ; // temporary result
END_VAR
BEGIN
NETWORK
TITLE =
//
// set K1 and K2 constants based upon BIPOLAR
//
SET ; // if(BIPOLAR=0)
A #BIPOLAR; // .
JC EL01; // {
L 0.000000e+000; // K1=0
T #K1; // .
JU EI01; // } else {
EL01: L -2.764800e+004; // K1=-27648.0
T #K1; // .
EI01: NOP 0; // }
L 2.764800e+004; // K2=+27648.0
T #K2; // .
//
// convert input (IN) to real
//
L #IN; // ACC1=IN
ITD ; // convert to double integer
DTR ; // convert to real
T #IN_REAL; // IN_REAL-IN as a real
//
// determine SPAN = HI_LIM - LO_LIM
//
L #HI_LIM; // SPAN=HI_LIM-LO_LIM
L #LO_LIM; // .
-R ; // .
T #SPAN; // .
//
// If the input value is outside the K1 and K2 range, the output
// is clamped to the nearer of either the LO_LIM or the HI_LIM
// and an error is logged. If the input value is exactly at a limit the
// output will be set to the computed limit with no error returned.
// changed 2/14/00 by ERI per RQ210693
L #IN_REAL; // if(IN_REAL L #K1; // .
>=R ; // .
JC EL02; // {
L 8; // error
T #RET_VAL; // .
L #LO_LIM; // ACC1=LO_LIM
T #OUT; // OUT=ACC1
JU FAIL; // error
EL02: POP ; // } else {
L #K2; // if(IN_REAL>K2)
<=R ; // .
JC EI04; // {
L 8; // error
T #RET_VAL; // .
L #HI_LIM; // ACC1=HI_LIM
T #OUT; // OUT=ACC1
JU FAIL; // error
EI04: NOP 0; // }
NOP 0; // }
//
// scale the input
//
L #K2; // TEMP1=K2-K1
L #K1; // .
-R ; // .
T #TEMP1; // .
L #IN_REAL; // IN_REAL-K1
L #K1; // .
-R ; // .
L #TEMP1; // divide by TEMP1
/R ; // .
L #SPAN; // multiply by SPAN
*R ; // .
L #LO_LIM; // add LO_LIM
+R ; // .
T #OUT; // OUT=scale(IN_REAL)
//
// set BR bit : no error-set BR bit to 1; with error-set BR bit to 0.
//
L 0; // return error code 0
T #RET_VAL; //
SET ; // RLO = 1 (NO ERROR)
JU SVBR; //
FAIL: CLR ; // RLO = 0 (ERROR)
SVBR: SAVE ; // BR = RLO
END_FUNCTION


//以下FC106；
FUNCTION "UNSCALE" : WORD
TITLE =UNSCALING VALUES
//
AUTHOR : SEA
FAMILY : CONVERT
NAME : UNSCALE
VERSION : 2.0


VAR_INPUT
IN : REAL ; // input value to be unscaled
HI_LIM : REAL ; // upper limit in engineering units
LO_LIM : REAL ; // lower limit in engineering units
BIPOLAR : BOOL ; // 1=bipolar; 0=unipolar
END_VAR
VAR_OUTPUT
OUT : INT ; // result of the unscale conversion
END_VAR
VAR_TEMP
K1 : REAL ; // low limit for output value
K2 : REAL ; // high limit for output value
SPAN : REAL ; // HI_LIM - LO_LIM
TEMP1 : REAL ; // temporary result
END_VAR
BEGIN
NETWORK
TITLE =
//
// set K1 and K2 constants based upon BIPOLAR
//
SET ; // if(BIPOLAR=0)
A #BIPOLAR; // .
JC EL01; // {
L 0.000000e+000; // K1=0
T #K1; // .
JU EI01; // } else {
EL01: L -2.764800e+004; // K1=-27648.0
T #K1; // .
EI01: NOP 0; // }
L 2.764800e+004; // K2=+27648.0
T #K2; // .
//
// determine SPAN = HI_LIM - LO_LIM
//
L #HI_LIM; // SPAN=HI_LIM-LO_LIM
L #LO_LIM; // .
-R ; // .
T #SPAN; // .
//
// If the input value is outside the HI_LIM and LO_LIM range, the output
// is clamped to the nearer of either K1 or K2 and an error is logged.
// If the input value is exactly at a limit the output will be set to
// the computed limit with no error returned.
//
L #SPAN; // if(SPAN<0) reverse scaling
L 0.000000e+000; // .
JCN EL02; // {
L #IN; // if(IN L #HI_LIM; // .
>=R ; // .
JC EI03; // {
L 8; // error
T #RET_VAL; // .
L #K1; // ACC1=K1
JU WRIT; // write OUT
EI03: NOP 0; // }
POP ; // if(IN>LO_LIM)
L #LO_LIM; // .
<=R ; // .
JC EI04; // {
L 8; // error
T #RET_VAL; // .
L #K2; // ACC1=K2
JU WRIT; // write OUT
EI04: NOP 0; // }
JU EI02; // } else { direct scaling
EL02: L #IN; // if(IN L #LO_LIM; // .
>=R ; // .
JC EI05; // {
L 8; // error
T #RET_VAL; // .
L #K1; // ACC1=K1
JU WRIT; // write OUT
EI05: NOP 0; // }
POP ; // if(IN>HI_LIM)
L #HI_LIM; // .
<=R ; // .
JC EI06; // {
L 8; // error
T #RET_VAL; // .
L #K2; // ACC1=K2
JU WRIT; // write OUT
EI06: NOP 0; // }
EI02: NOP 0; // }
JU CALC; // perform unscale calculation
WRIT: TRUNC ; // convert to integer
T #OUT; // OUT=ACC1
JU FAIL; // error
//
// unscale the input
//
CALC: L #K2; // TEMP1=K2-K1
L #K1; // .
-R ; // .
T #TEMP1; // .
L #IN; // IN-LO_LIM
L #LO_LIM; // .
-R ; // .
L #SPAN; // divide by SPAN
/R ; // .
L #TEMP1; // multiply by TEMP1
*R ; // .
L #K1; // add K1
+R ; // .
TRUNC ; // convert to DINT
T #OUT; // OUT=unscale(IN)
//
// set BR bit : no error-set BR bit to 1; with error-set BR bit to 0.
//
L 0; // return error code 0
T #RET_VAL; //
SET ; // RLO = 1 (NO ERROR)
JU SVBR; //
FAIL: CLR ; // RLO = 0 (ERROR)
SVBR: SAVE ; // BR = RLO
END_FUNCTION