SINAMICS S120 Torque Limit Setting p1520/p1521 from TIA Portal

1. Problem Overview

Setting the upper and lower torque limits on a SINAMICS S120 drive directly from a TIA Portal HMI fails for most engineers on the first attempt because of how SINAMICS drive parameters must be addressed through the controller, not by binding the IO field directly to the parameter number. The typical symptom: an IO field wired to CU.Axis.Parameter[1520] accepts a value at runtime, but the drive rejects the write and the value does not latch — or the field shows the read-back value but the operator cannot modify it.

This article documents the correct procedure for writing p1520[0] (upper torque limit) and p1521[0] (lower torque limit) from a SIMATIC HMI, plus the read-only display of actual torque via r0081. The procedure is the same for SIMOTION, SIMATIC S7-1500 with TO Axis, and the older SIMATIC S7-300/400 with a standard axis control block, with minor addressing differences noted in the integration sections.

Reference documentation used throughout this article:

• SINAMICS S120 Function Manual — Drive Functions (torque limiting chapter)
• SIMATIC S7-1500 with SINAMICS S120 — Torque limiting with MC_TorqueLimiting
• FAQ: Accessing SINAMICS drive parameters from a SIMATIC HMI (Entry ID 109481157)

2. Prerequisites

Configure the drive in TIA Portal using SINAMICS Startdrive. After adding the drive to the project, the drive object becomes available in the device tree as [Drive name] > Drive axis > ... and exposes its parameter list. Verify that the controller is online with the drive and that cyclic communication is green before attempting parameter writes.

3. SINAMICS S120 Torque Limit Parameters

The torque limit function in SINAMICS S120 is a closed-loop limit on the torque setpoint. There are several layers:

The values are entered in Nm, not in percent, when typed via p1520/p1521 directly. The S120 normalizes them internally against p2003 (reference torque) for telegram scaling. Per the SINAMICS S120 Function Manual: "The value specifies the maximum permissible torque whereby different limits can be parameterized for motor and regenerative mode." This means the upper limit p1520 protects motoring operation and p1521 protects regenerative (braking) operation. Both default to the maximum motor torque and are active immediately on power-up unless overridden by p1522/p1523 sources.

4. Why Direct CU.Axis.Parameter Writes Fail

Many engineers drag an IO field onto the screen and bind it to the drive's parameter number. In TIA Portal the path looks correct: DriveAxis > Parameters > p1520[0]. The compile passes. At runtime the field is read-only or the write returns 0x8001 (PROFIdrive error: parameter write protected by controller).

The cause is the PROFIdrive PKW (Parameter-Kennung-Wert) channel. Parameter writes must be initiated by the controller using an acyclic record read/write on the PROFIdrive channel, or the drive must be configured to expose the parameter through a free telegram slot. The HMI tag linked to CU.Axis.Parameter[1520] reads on each cycle but cannot be written without an explicit acyclic job from the PLC program.

The HMI tags in TIA Portal are not equivalent to PLC acyclic parameter access jobs. The HMI tag binding generates a cyclic read of the parameter at the configured update rate. Writes via the same binding route to the drive object interface, but the drive rejects them when the parameter write protection is active or when the controller holds a lock on the parameter set.

5. Step-by-Step: Writing p1520 and p1521 from HMI

Step 1 — Define PLC tags

Create two HMI-visible tags in the PLC tag table of the S7-1500 CPU. These tags are the interface between the HMI and the controller program that actually drives the parameter job.

TYPE "HMI_TorqueLimit"
VERSION : 0.1
   STRUCT
      UpperLimit_Nm   : REAL;   // p1520[0] in Nm
      LowerLimit_Nm   : REAL;   // p1521[0] in Nm
      UpperScale_pct  : REAL;   // p1524[0] in %
      LowerScale_pct  : REAL;   // p1525[0] in %
      WriteTrigger    : BOOL;   // rising edge writes the values
      WriteBusy       : BOOL;
      WriteDone       : BOOL;
      WriteError      : BOOL;
      ErrorId         : DWORD;  // PROFIdrive DPV1 error code
   END_STRUCT;
END_TYPE

Mark the tag structure as accessible from HMI (right-click → "Accessible from HMI").

Step 2 — Implement acyclic parameter write in SCL

Use the S7-1500 WRIT_DPM instruction (formerly DPRD_DAT / DPWR_DAT blocks) to write parameters acyclically. For S7-1500 + Startdrive, the recommended instruction is "WRREC / RREC pattern with the Drive object handle, or use the S7-1500 Motion Control MC_WriteDriveParameter block available in the SINAMICS drive object library.

// SCL sample — write p1520 and p1521 via MC_WriteDriveParameter
// Requires: SINAMICS S120 axis object "Axis_1" in TIA Portal
// HMI writes to: HMI_TorqueLimit.UpperLimit_Nm and .LowerLimit_Nm

IF "HMI_TorqueLimit".WriteTrigger AND NOT "HMI_TorqueLimit".WriteBusy THEN
    "HMI_TorqueLimit".WriteBusy := TRUE;
    "HMI_TorqueLimit".WriteDone := FALSE;
    "HMI_TorqueLimit".WriteError := FALSE;

    // Write p1520[0] (upper torque limit, Nm)
    "dbParamJob".ParameterNumber := 1520;
    "dbParamJob".Index            := 0;     // Index 0
    "dbParamJob".Value            := "HMI_TorqueLimit".UpperLimit_Nm;
    "inst_MC_WriteDriveParameter"(Axis := "Axis_1",
                                  ParameterNumber := 1520,
                                  Index := 0,
                                  Value := "HMI_TorqueLimit".UpperLimit_Nm,
                                  Execute := TRUE,
                                  Done => "HMI_TorqueLimit".WriteDone_1,
                                  Busy  => "HMI_TorqueLimit".WriteBusy_1,
                                  Error => "HMI_TorqueLimit".WriteError_1,
                                  ErrorId => "HMI_TorqueLimit".ErrorId_1);

    // Write p1521[0] (lower torque limit, Nm)
    "inst_MC_WriteDriveParameter_2"(Axis := "Axis_1",
                                  ParameterNumber := 1521,
                                  Index := 0,
                                  Value := "HMI_TorqueLimit".LowerLimit_Nm,
                                  Execute := TRUE,
                                  Done => "HMI_TorqueLimit".WriteDone_2,
                                  Busy  => "HMI_TorqueLimit".WriteBusy_2,
                                  Error => "HMI_TorqueLimit".WriteError_2,
                                  ErrorId => "HMI_TorqueLimit".ErrorId_2);
END_IF;

Reset the trigger on completion. Use a state machine or a simple TON timer to debounce the HMI input. The complete state machine pattern is documented in the S7-1500 / S120 torque limiting application document.

Step 3 — Configure the HMI IO field

On the Comfort Panel screen, drop an IO field and bind its process tag to HMI_TorqueLimit.UpperLimit_Nm. Configure:

• Mode: Input/output (operator can write)
• Format: 9999.99 (one decimal place is enough for Nm)
• Limits: min = -M_max(pump) for the lower IO field; max = +M_max for the upper IO field
• OnChange event: Set HMI_TorqueLimit.WriteTrigger = TRUE on a rising edge of "Value changed". Reset the trigger after the WriteDone flag in the PLC becomes TRUE.

Use a momentary pushbutton to apply the values, or set the trigger from a "value changed" event of the IO field with a 500 ms debounce.

Step 4 — Read p1520/p1521 back for display

Use MC_ReadDriveParameter to populate the read-back tags every second. Show the current latched value next to the input field so the operator sees confirmation of the write.

// Periodic read of p1520 and p1521 back to HMI
"inst_MC_ReadDriveParameter"(Axis := "Axis_1",
                              ParameterNumber := 1520,
                              Index := 0,
                              ReadOnce := FALSE,
                              CyclicRead := TRUE,
                              Value => "HMI_TorqueLimit".UpperLimit_Nm_Readback);

6. Visualizing Real-Time Torque on the HMI

Three useful read-only parameters for real-time torque display:

To display r0081[0] in an HMI gauge or numeric field, add a free parameter tag bound to r0081 in the HMI tag table. The Startdrive configuration exposes all drive parameters under the drive object — expand the drive axis, expand "Parameters", filter "r0081", drag it to the HMI tags. The HMI updates the value at the configured refresh rate (default 1 s; minimum 100 ms in Comfort Panel).

7. MC_TorqueLimiting — Programmatic Torque Limiting

For dynamic, application-dependent torque limits (winder, force-controlled press, hoisting), use the Motion Control instruction MC_TorqueLimiting from the S7-1500 MotionControl library. The instruction allows activation and deactivation of force/torque limits at runtime, including override of p1520/p1521 from the PLC program.

"inst_MC_TorqueLimiting"(
   Axis              := "Axis_1",
   Enable            := "HMI_TorqueLimit".EnableDynamic,
   LimitUpper        := "HMI_TorqueLimit".UpperLimit_Nm,
   LimitLower        := "HMI_TorqueLimit".LowerLimit_Nm,
   Mode              := MC_TORQUELIMITING_LIMIT_BOTH,
   InOperation       => "HMI_TorqueLimit".LimiterActive,
   Busy              => "HMI_TorqueLimit".LimiterBusy,
   Error             => "HMI_TorqueLimit".LimiterError,
   ErrorId           => "HMI_TorqueLimit".LimiterErrorId
);

Per Siemens: "With the Motion Control instruction 'MC_TorqueLimiting' you can limit the torque effective on the drive. You can activate and deactivate the force/torque limiting at runtime." When the instruction is enabled, it overrides p1520/p1521 with the values provided at LimitUpper / LimitLower. When disabled, the drive returns to the static values stored in p1520/p1521.

The TIA Portal example project linked in the S7-1500 / S120 torque limiting application document includes a ready-to-use SCL FB and HMI screen.

8. Scaling and Reference Values

When you set p1520[0] = 50.0 Nm on a 100 Nm motor, the drive's internal representation is 50.0 / 100.0 = 0.5 (50 %). This is the value seen on the fieldbus when the parameter is read via PROFIdrive in the standard telegram. If you write the value via the PLC tag and the value shows as if scaled by 1/1000, check that the controller's normalization factor matches p2003 — sometimes Startdrive defaults to a different scaling mode for older firmware (< 4.6).

9. PROFIdrive / Telegram Considerations

The torque limit p1520/p1521 is normally written acyclically, not via the standard telegram. However, several control words in extended telegrams allow limiting from the controller in real time:

• Standard telegram 1: STW1/ZSW1 + NSOLL/NIST — no torque limit word
• SIEMENS telegram 102: Includes torque limit, similar to standard 6 with extra addends
• Standard telegram 6: Includes M_LIM (torque limit scaling) and M_ADD (additive torque setpoint)
• Standard telegram 9: Includes M_LIM with finer resolution

For real-time closed-loop torque control with sub-millisecond latency, use telegram 9 or 102. The HMI write procedure documented above remains valid for slow setpoint changes (operator adjustments, recipe downloads); the cyclic telegram path is reserved for the PLC's own closed-loop logic.

10. Verification Procedure

1. Go online with the S7-1500 in TIA Portal.
2. Open the HMI Runtime (Start WinCC RT on the engineering station or run on the panel).
3. Enter 25.0 Nm into the upper torque limit IO field; click Apply.
4. In Startdrive, monitor p1520[0] under the drive axis. Verify it reads 25.00 Nm.
5. Open a trace on the drive. Record r0079 (torque setpoint). Command a torque-controlled motion and confirm the trace plateaus at 25 Nm.
6. Enter a negative value (e.g. -30.0) in the lower limit field. Verify p1521[0] = -30.00.
7. Watch the r0081[0] indicator. At full p1520 limit utilization, the bar gauge should read near 100 %.
8. Force an overshoot: command 150 % of p1520 momentarily. Verify the drive applies the limit and faults off only if the limit is exceeded for the time defined in p1526[0] (torque limit time).

11. Troubleshooting Matrix

12. Field-Commissioning Checklist

• Verify the drive is in "Ready to switch on" state (r0002 = 0x21) before writing torque limits
• Confirm the safe torque off (STO) channel is not active when MC_TorqueLimiting is enabled
• Test with a small load first: set p1520 = 5 % of M_max, command 50 % torque, confirm clamp
• Document the HMI tag list with scaling, units, and limits in the project documentation
• Enable the user-defined parameter set (p0970 = 1) and save the project to retain the torque limits across power cycles
• Save the RAM to ROM (p0977 = 1) after commissioning to make the values persistent in the CF card