Implementing RPM to Percentage Scaling in Siemens STEP 7 STL

Overview

Speed setpoints in industrial automation are typically expressed in two ways: as an engineering unit (RPM, m/s, Hz) on the engineering and commissioning side, and as a percentage of rated speed on the operator HMI side. Converting between the two domains is a routine scaling task that lives in the PLC's logic, not in the HMI tag database. The reason is simple: the maximum rated RPM depends on the connected motor (or on a gearbox output shaft), and a motor change at commissioning time must propagate to every operator panel without rewriting HMI scripts.

This reference documents the canonical RPM-to-percentage conversion implemented in Siemens STEP 7 Statement List (STL) for the S7-300/S7-400 family, with direct equivalents for S7-1200/S7-1500 in TIA Portal using SCL. The same formula is portable to any IEC 61131-3 controller (ladder, FBD, structured text) and to any PLC vendor; only the operand syntax and integer/real conversion primitives change.

The mathematical relationship is linear:

% = 100 × RPM / RPMmax

Where RPM_max is the rated full-load speed of the motor (or the user-defined full-scale speed for the controlled shaft). The PLC stores RPM scaled by a factor of 10 (one decimal place) as a 16-bit integer; the conversion output stores percentage scaled by 100 (two decimal places) as a 16-bit integer. Both choices keep the maths inside the 16-bit signed range and avoid floating-point I/O at the fieldbus boundary.

Prerequisites

Before implementing the conversion block, confirm the following:

1. Hardware platform. S7-300 (CPU 31x), S7-400 (CPU 41x), or ET200S with a CPU that supports STL. For S7-1200/S7-1500, use SCL instead – STL is deprecated on those platforms but the algorithm is identical.
2. Firmware. STEP 7 V5.5 or V5.6 for the classic S7-300/400 line, or TIA Portal V16/V17/V18 for S7-1200/1500. Refer to the SIMATIC S7-300 Automation System manual and the SIMATIC S7-1500 Automation System manual for the firmware/OS update matrix.
3. Speed feedback source. Either an encoder wired to a fast counter module (FM 350-1/350-2, ET200S 1Count24V) or a PROFIdrive telegram from a SINAMICS drive (telegram 1/2/3/4 with NSOLL and NIST values). The encoder-to-RPM conversion is documented separately below.
4. Data block for constants. A DB block (often named CONST or Motor_Data) that holds RPM_MAX_x10 and other commissioning-tunable values.
5. HMI tag mapping. The percentage output is mapped to a tag displayed as a number with two decimal places on the HMI; the integer value (e.g., 11234) is interpreted by the HMI as 112.34 %.

Mathematical Foundation and Scaling Ranges

The conversion must be dimensionally consistent. Two scaling factors are used in the reference implementation:

Why RPM × 10 and % × 100? Because the smallest meaningful increment on the engineering side is 0.1 RPM (one decimal place on the HMI) and on the operator side is 0.01 % (two decimal places). Multiplying by these factors and rounding once at the end of the calculation preserves both resolutions inside a 16-bit signed word.

The signed range covers reversing drives and over-speed excursions up to ~327 % of rated. Most drives will fault before that, but the code handles bidirectional setpoints correctly without conditional branches.

For a typical 4-pole induction motor on 50 Hz mains, synchronous speed is 1500 RPM and full-load speed (after slip) is ~1468 RPM. Use 14680 as RPM_MAX_x10. For 60 Hz mains, full-load speed is ~1750 RPM and the constant becomes 17500. The motor data sheet or the SINAMICS parameter list (P0310 rated frequency, P0311 rated motor speed) is the authoritative source for these values.

STL Implementation (Reference Solution)

The following STL block is the original reference implementation, placed inside an FC (Function) so that the inputs and outputs are passed as parameters rather than read from absolute addresses. Constants are pulled from a dedicated data block called DB CONST.

// FC 100 — RPM_x10 to Percent_x100
// Input  : RPM_x10 (INT)      @ MW 100  // e.g., 14680 = 1468.0 RPM
// Output : Pct_x100 (INT)     @ MW 104  // e.g., 10000 = 100.00 %
// Constants from DB CONST (DB 200):
//   DB_CONST.RPM_MAX_x10 : INT = 14680  // rated RPM x 10

      L     MW 100                  // Load input RPM_x10
      ITD                          // INT -> DINT (sign-extend)
      DTR                          // DINT -> REAL
      L     DB200.DBD 0            // Load DINT RPM_MAX_x10
      DTR                          // DINT -> REAL
      /R                           // REAL division
      L     1.000000e+004          // Load 10000.0
      *R                           // Multiply (result in % x 100)
      RND                          // Round to nearest DINT
      T     MW 104                  // Transfer to output word

      SET                           // Set RLO = 1 (BR bit = 1)
      SAVE                          // Save RLO to BR

Instruction notes (per the STEP 7 STL reference manual):

• L — Loads the operand into ACCU1.
• ITD — Integer (16-bit) to Double Integer (32-bit). Required before DTR to avoid overflow on values that exceed 32767.
• DTR — Double Integer to Real (IEEE 754 single precision). Result is in ACCU1 as a 32-bit float.
• /R — Real division: ACCU2 / ACCU1 → ACCU1.
• *R — Real multiplication: ACCU2 * ACCU1 → ACCU1.
• RND — Round to nearest integer; returns a DINT.
• T — Transfer from ACCU1 to operand. The high word of the DINT result is written first; in S7-300/400 the byte order is big-endian so a 16-bit transfer of ACCU1-L reads the rounded value if the result fits in INT range.
• SAVE — Sets the BR (binary result) bit so the calling block sees a clean ENO.

SCL Equivalent for S7-1200 / S7-1500 (TIA Portal)

The STL code translates almost verbatim into SCL. The syntax differences are the assignment operator (:=), the absence of explicit accumulator manipulation, and the fact that SCL uses REAL natively.

// FB "RPM_to_Pct" — TIA Portal V17 / S7-1500
// Input  : i_RPM_x10   : INT   // RPM x 10, e.g. 14680 = 1468.0 RPM
// Output : o_Pct_x100  : INT   // % x 100, e.g. 10000 = 100.00 %
// Static : s_RPMmax_x10 : INT := 14680;  // rated speed (commissioning tunable)

IF s_RPMmax_x10 <> 0 THEN
    o_Pct_x100 := REAL_TO_INT(
        INT_TO_REAL(i_RPM_x10) * 100.0 / INT_TO_REAL(s_RPMmax_x10) * 100.0
    );
ELSE
    o_Pct_x100 := 0;   // divide-by-zero guard
END_IF;

The REAL_TO_INT function rounds toward zero in SCL by default; if banker's rounding or round-half-up is required, use ROUND or CEIL/FLOOR explicitly. The same divide-by-zero guard is implicit in the STL code (a 0 denominator returns 0 because of the RND after /R with an undefined result; many CPUs substitute INF and the subsequent *R yields INF, which RND rounds to the largest representable value). Adding the explicit guard in SCL is the recommended hardening step.

Ladder Logic Equivalent (FBD/LAD)

Engineers who prefer graphical languages can build the same conversion using the following FBD network. The chain is:

1. MW100 → I_DI (INT to DINT) → DI_R (DINT to REAL)
2. Constant DB200.DBW0 → I_DI → DI_R
3. Real division block (DIV_R)
4. Constant 10000.0 (REAL)
5. Real multiplication block (MUL_R)
6. ROUND (REAL to DINT)
7. Transfer to MW104 via MOVE (DINT to INT with overflow check)

In LAD, the multiplication by a constant is performed by an *R block with the constant wired to one input. In FBD it is identical. Both languages will execute the network in a single OB1 scan provided that the floating-point math executes within the OB1 priority class — on older S7-300 CPUs (CPU 312/314) this is fine, but on a CPU 312 IFM (limited local data) keep the FC in a separate priority class to avoid OB1 overflow.

Data Block Layout for Commissioning Constants

Centralizing the rated-speed constant in a data block is the difference between a one-line motor swap and a four-hour code hunt. The recommended DB layout:

DATA_BLOCK "Motor_Constants"
  STRUCT
    RPM_MAX_x10    : INT  := 14680;   // 1468.0 RPM @ 50 Hz / 4-pole
    RPM_MAX_x10_BK : INT  := 17500;   // backup for 60 Hz / 4-pole (1750 RPM)
    PCT_FULL_SCALE : INT  := 10000;   // 100.00 % — usually left at default
    ENC_PPR        : INT  := 1024;    // encoder pulses per revolution
    GEAR_RATIO     : REAL := 1.0;     // gearbox ratio (output / input)
    REV_ENABLE     : BOOL := TRUE;    // permit negative setpoints
  END_STRUCT;
END_DATA_BLOCK

The constants can be made HMI-visible so that a maintenance engineer changes a single tag after a motor swap, rather than touching the FC source. Use the DB-only access attribute in the DB properties so that STEP 7 online monitoring shows the values but they remain read/write from the HMI.

Encoder Pulse-to-RPM Conversion

If RPM is not delivered directly by the drive, it must be calculated from encoder pulses. The standard relationship for a quadrature encoder is:

RPM = (fpulses / PPR) × 60 / (4 × G)

Where fpulses is the pulse frequency in Hz, PPR is the pulses per revolution of the encoder, the leading 4 accounts for quadrature decoding (x1, x2, x4), and G is the gearbox ratio. A typical calculation table:

The conversion between RPM and count rate is reciprocal: 1 RPM ↔ PPR / 60 × 4 counts/second. Common shortcuts used in the field:

• 1 RPM = 600 counts for 10 PPR at x4 decode (1 × 10 × 60 = 600)
• 2 RPM = 300 counts
• 5 RPM = 120 counts
• 10 RPM = 60 counts
• 60 RPM = 10 counts
• 600 RPM = 1 count — resolution floor for 10 PPR

For Siemens FM 350-1/350-2 counters, the measured count is loaded directly into a DB word via the assigned load value. The CPU then scales by gate time internally if you use the FM 350 function blocks. For ET200S 1Count24V, the user is responsible for the gate-time logic — a 1 Hz cyclic interrupt (OB35 with 1000 ms period) is the standard approach.

Linearization and Non-Linear Curves

The RPM-to-percentage mapping is linear by definition. What is not always linear is the underlying physics of the actuator:

• PWM duty cycle to fan RPM. Below the motor's natural commutation threshold the fan stalls or runs at a fraction of the duty-cycle-predicted speed. Empirically, a 50 % duty cycle on a small DC fan may produce only ~25-40 % of the rated RPM because the back-EMF dominates the low-end torque. Plot the measured curve and apply a piecewise linear lookup or a polynomial correction in a separate FC.
• Hydraulic proportional valves. Valve spool position is roughly proportional to current, but flow is not proportional to spool position because of orifice area curves. For RPM conversion this rarely matters, but for any speed-derived setpoint downstream of the same analogue output it does.
• V/f drives at low frequency. A SINAMICS V20 in linear V/f mode boosts voltage below 5 Hz to maintain torque. The resulting RPM at 10 % setpoint may be 4 % rather than the 10 % the formula predicts. Switch to sensorless vector control (SLVC) if closed-loop accuracy below 10 % is required.

For these cases, leave the FC as the linear scaling engine and insert a linearization FC between the RPM input and the FC's RPM_x10 input. Keeping the math in one place and the corrections in another is the only sustainable architecture.

Edge Cases, Limits, and Fault Handling

A robust pattern is to put the FC inside a wrapper FB that performs input clamping, divide-by-zero detection, output saturation, and life-sign monitoring. The wrapper raises a structured fault (S7-300/400 via SFC 36/37 MSG_LOCK / MSG_UNLOCK for diagnostics; S7-1500 via GET_DIAG or the diagnostic buffer) so that the HMI can display a colour-coded alarm.

Verification and Commissioning

Use the following commissioning checklist before sign-off:

1. Static test (motor de-energized, drive disabled). Force MW100 to known values: 0, 1000 (100.0 RPM), 14680 (rated RPM), -14680 (reverse rated). Verify MW104 reads 0, ~681 (6.81 %), 10000 (100.00 %), -10000 (-100.00 %).
2. Ramp test. Use the S7-PLCSIM or PLCSIM Advanced simulator to feed a linearly increasing MW100 from 0 to 16383 (1638.3 RPM). Verify the output ramps linearly and saturates near 11000 (111.55 %) without wrap.
3. Round-trip test. Build the inverse FC (percentage-to-RPM) and chain the two. Apply a known percentage; the resulting RPM_x10 should equal the input RPM_x10 within ±1 LSB.
4. Cross-check against drive actual. With the drive running at a fixed setpoint (e.g., 50 % on the HMI), read r0021 (actual speed smoothed) on the SINAMICS and compare to the PLC's MW104. Acceptable error: ±0.5 %.
5. Motor swap simulation. Change DB200.DBW0 from 14680 to 17500 and verify the operator's 50 % setpoint now commands 875 RPM instead of 734 RPM. This is the principal reason for putting the constant in a DB rather than hard-coding it in the FC.
6. Fault injection. Force DB200.DBW0 to 0 and verify the divide-by-zero fault is raised and the HMI displays the configured alarm.

Cross-Platform and Vendor Portability Notes

The formula is universal. The implementation details that change between vendors:

When porting the STL block to Allen-Bradley Structured Text, the equivalent is:

// AOI or routine in Studio 5000
Pct_x100 := REAL_TO_DINT(
    (DINT_TO_REAL(RPM_x10) * 100.0) / DINT_TO_REAL(RPMmax_x10) * 100.0
);

Note that Studio 5000's REAL_TO_DINT truncates rather than rounds. For symmetric rounding, use ROUND from the Math Functions Add-On or pre-bias the value: Pct_x100 := REAL_TO_DINT(value + 0.5); for positive-only values, and a separate branch for negatives.

FAQ