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               //   .

      <R                                //   .

      JCN   EL02                        // {

      L     #IN                         //   if(IN<HI_LIM)

      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<LO_LIM)

      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