SINAMICS V90 Torque Reading on S7-1200 via Telegram 3 and 750

Reading the actual torque of a SINAMICS V90 servo drive from an S7-1200 controller over PROFINET requires more than a single standard telegram. The drive reports smoothed torque through parameter r31, exposes torque-limit setpoints through the supplementary Telegram 750, and only delivers the actual torque value into the cyclic process image when that supplementary telegram is wired alongside a base telegram such as Telegram 3. This reference walks through the configuration in TIA Portal V17, the cyclic PZD layout, the acyclic parameter channel needed to fetch r31 when only the base telegram is wired, the limitations of the S7-1200 Technology Object, and the SCL code required to convert a raw torque word into a usable engineering value and trigger a digital output on a threshold event.

1. Problem Overview

The reported issue is that the actual torque value of a SINAMICS V90 cannot be seen inside TIA Portal V17 when the controller is an S7-1200 communicating over PROFINET with Telegrams 3 and 750 selected in the device configuration. Three things are usually happening at the same time:

1. Telegram 3 is the standard speed-control telegram. It carries STW1, NSOLL_B, STW2, and NIST_B in the 32-bit speed format, but it does not contain an actual torque word. It contains the smoothed speed and a 16-bit status word, not torque.
2. The torque value is reported by the V90 in two distinct places: in the supplementary Telegram 750 as M_ACT (smoothed torque, normalized to 0.1% of rated torque) and in the parameter image as r31 (smoothed torque, in the same engineering unit). Telegram 750 must be added to the slot mapping to see M_ACT in the cyclic I/O image; if it is not, the field is unavailable and only the acyclic channel will yield a value.
3. The S7-1200 Technology Object for SINAMICS V90 supports position and speed-controlled operation; it does not surface a torque-controlled axis object the way the S7-1500 does. Torque limits therefore cannot be written to the TO directly. They have to be written to the V90 over PROFINET either cyclically through Telegram 750 (M_LIMIT_POS and M_LIMIT_NEG) or acyclically through p29050 family parameters.

2. System Architecture: S7-1200, V90, and PROFINET

Reference topology for the configuration described in this article:

• Controller: SIMATIC S7-1200, firmware V4.4 or later (TIA Portal V17 supports firmware V4.4 and V4.5). PROFINET interface on the CPU, X1 port.
• Drive: SINAMICS V90 PN, firmware V2.0 or later. The PROFINET variant has two RJ45 ports (X1, X2) supporting PROFINET RT with a fixed 1 ms update class on telegram 1 / 3 / 102 / 105 and 4 ms on telegram 7.
• Servomotor: SIMOTICS S-1FL6 incremental encoder (single-turn) or absolute encoder variant. The encoder type does not change the telegram structure but does change whether the position actual value is meaningful for closed-loop applications.
• Topology: linear, single CPU and single V90. The V90 is a PROFINET IO Device and is added to the S7-1200 PROFINET IO System. The GSDML file for V90 must be installed in TIA Portal (Options → Manage general station description files (GSD)) before the device appears in the hardware catalog.
• Watchdog and update: send clock of the IO device is configured to 1 ms; the reduction ratio is set to 1. Telegram 3 is wired in slot 1, subslot 1; Telegram 750 is wired in slot 2, subslot 1.

3. Telegram Selection for Torque Feedback

The V90 supports the following PROFINET telegrams out of the box:

The standard recipe for a torque-threshold application on S7-1200 is Telegram 3 (slot 1) + Telegram 750 (slot 2). Telegram 3 owns the motion control words (STW1, NSOLL_B, STW2, NIST_B) and is what the S7-1200 TO binds to. Telegram 750 owns the torque data (M_LIMIT_POS, M_LIMIT_NEG, M_ACT, plus reserved / status words depending on firmware). Mounting them in separate slots keeps the S7-1200 axis object addressable while still exposing the torque process data to user program code.

4. Telegram 3 PZD Structure (Standard Speed Control)

Telegram 3 is the default for V90 PN speed control. Process data layout (PROFINET is big-endian over the wire, little-endian word order in the S7-1200 process image when little-endian byte swap is disabled):

None of the five PZDs in Telegram 3 carry the actual torque. The standard speed setpoint NSOLL_B drives the speed controller, and the speed controller output becomes the torque setpoint. The actual torque that the drive is producing at that moment is reported in the supplementary Telegram 750, not in Telegram 3 itself.

5. Telegram 750 PZD Structure (Supplementary Torque Telegram)

Telegram 750 is a vendor-specific (Siemens) supplementary telegram. The V90 PN implements it with three PZDs in each direction. Layout per the SINAMICS V90 PROFINET Operating Instructions:

6. Wiring Telegram 3 + 750 in TIA Portal V17

1. Open the V90 PN device view in the project tree. Switch to Device view → Properties → PROFINET interface → Telegram configuration.
2. In Slot 1 / Subslot 1, set telegram to Standard Telegram 3. The S7-1200 Technology Object will bind to this slot when a speed-controlled axis is commissioned.
3. Click Add telegram. In Slot 2 / Subslot 1, set telegram to Supplementary Telegram 750. The drive now exposes a second I/O area of three words in each direction.
4. Mark Slot 2 in the device view. The Inspector → IO Tags tab will list all the PZDs. Drag the following into a global data block (DB "V90_IO") to get symbolic names: "V90".M_ACT, "V90".M_LIMIT_POS, "V90".M_LIMIT_NEG, "V90".M_ACT_Status, "V90".M_ACT_Current.
5. Set the send clock for the PROFINET IO system to 1.0 ms. The V90 update time on the supplementary telegram follows the same send clock; lowering it below 1 ms is rejected by the drive with a configuration fault.
6. Compile hardware. Watch the log for the warning "PROFINET IO: Telegram 750 requires V90 firmware ≥ V1.04". If it appears, update the drive.
7. Download hardware to the S7-1200. Confirm the V90 goes to RUN / green link on both ports with the cyclic I/O handshake ticking (Slot 1 and Slot 2 both have cyclic data).

7. Reading r31 (Smoothed Actual Torque) Acyclically

The cyclic M_ACT from Telegram 750 is the same physical quantity as parameter r31 in the V90. r31 is the smoothed torque actual value reported in 0.1% of M_max (16384 = 100% M_max on the PROFINET scale, 1000 = 100% M_max on the parameter scale). When the application cannot mount Telegram 750 – for example because the slot budget is full or because the V90 firmware is older – the same value can be fetched over the DPV1 acyclic parameter channel using the S7-1200's RDREC instruction. The mechanism is identical to what S7-1500 controllers do with the SINA_PARA_S library block; the S7-1200 path is a manual RDREC call.

Mechanics of the V90 acyclic channel:

• Logical address of the slot: the slot that the V90 occupies in the PROFINET IO system. In a Telegram 3 + 750 layout, slot 1 (Telegram 3) is the one bound by the TO; the acyclic request is normally pointed at slot 1 because Telegram 3 also accepts the parameter channel.
• Record index: 47 (0x002F) is the standard PROFINET record index for DPV1 parameter access. Some Siemens V90 firmwares also accept index 0xB02E (45006) for the legacy parameter channel – if 47 returns 0xDE80, fall back to 0xB02E.
• Record data layout (request, 8 bytes minimum):

  Byte	Value	Meaning
  0	0x01	Function = request parameter
  1	0x01	Number of parameters = 1
  2	0x01	Attribute = value (1) or text (2) or description (3)
  3	0x00	Number of elements = 1 (for non-array parameters)
  4	0x00	Parameter number high byte (r31 = 31, → 0x00)
  5	0x1F	Parameter number low byte (31 = 0x1F)
  6	0x00	Index high byte (subindex 0)
  7	0x00	Index low byte (subindex 0)

• Record data layout (response, 12 bytes for one parameter):

  Byte	Value	Meaning
  0	0x01	Function = response, no fault
  1	0x01	Number of parameters = 1
  2..3	format + count	0x02, 0x01 = one word (16-bit value)
  4	0x00	Parameter number high (r31 = 0x001F)
  5	0x1F	Parameter number low
  6..7	0x0000	Subindex
  8..9	0x0000	Reserved
  10..11	0xVVVV	Value (r31 raw, little-endian word, 0.1% units)

8. SCL Implementation: Generic Parameter Read

This block reads any single V90 parameter over the acyclic channel. The ID is the PROFINET hardware identifier of the V90's PROFINET interface; pick it from PLC tags → System constants → <PROFINET IO system> → <V90 PN> → <Interface_1> → Hardware identifier.

FUNCTION_BLOCK "FB_V90_ReadParam"
VAR_INPUT
  i_Execute        : BOOL;          // rising edge triggers a read
  i_HW_ID          : HW_IO;         // hardware identifier of the V90 PROFINET interface
  i_ParamNumber    : UINT;          // parameter number, e.g. 31 for r31
  i_ParamIndex     : UINT := 0;     // subindex, 0 for non-array parameters
END_VAR
VAR_OUTPUT
  o_Done           : BOOL;
  o_Busy           : BOOL;
  o_Error          : BOOL;
  o_Status         : WORD;          // RDREC status
  o_Value          : INT;           // returned 16-bit value (sign-extended to INT for torque)
  o_ValueUDInt     : UDINT;         // returned 32-bit value if format = 0x04
  o_Fault          : BOOL;
END_VAR
VAR
  s_Request        : ARRAY[0..15] OF BYTE; // request header
  s_Response       : ARRAY[0..31] OF BYTE; // response buffer
  s_RDREC_instance : RDREC;        // SFB / instruction instance
  s_State          : INT;          // 0 = idle, 1 = send, 2 = wait
  s_Tick           : TIME;
END_VAR
BEGIN
  IF s_State = 0 AND i_Execute THEN
    // Build DPV1 read request: function 01, count 1, attribute value (1), element count 1
    s_Request[0]  := 16#01;
    s_Request[1]  := 16#01;
    s_Request[2]  := 16#01;
    s_Request[3]  := 16#01;
    s_Request[4]  := WORD_TO_BYTE(SHR(IN:=INT_TO_WORD(i_ParamNumber), N:=8));
    s_Request[5]  := WORD_TO_BYTE(INT_TO_WORD(i_ParamNumber) AND 16#00FF);
    s_Request[6]  := WORD_TO_BYTE(SHR(IN:=INT_TO_WORD(i_ParamIndex), N:=8));
    s_Request[7]  := WORD_TO_BYTE(INT_TO_WORD(i_ParamIndex) AND 16#00FF);
    FOR n := 8 TO 15 DO s_Request[n] := 16#00; END_FOR;
    o_Busy := TRUE; o_Done := FALSE; o_Error := FALSE;
    s_State := 1;
  END_IF;

  IF s_State = 1 THEN
    s_RDREC(REQ := TRUE, ID := i_HW_ID, INDEX := 47,
            MLEN := 16, RECORD := s_Request,
            VALID => o_Done, BUSY => o_Busy, ERROR => o_Error, STATUS => o_Status);
    IF o_Done OR o_Error THEN
      s_State := 2;
    END_IF;
  END_IF;

  IF s_State = 2 THEN
    IF o_Error THEN
      o_Fault := TRUE;
    ELSE
      // Response: byte 0 = 0x81 means fault, otherwise 0x01 = OK
      IF s_Response[0] = 16#81 OR s_Response[0] = 16#82 THEN
        o_Fault := TRUE; o_Status := s_Response[8] OR (s_Response[7] * 256);
      ELSE
        // Value is at offset 10 (16-bit) or 10..13 (32-bit); format byte at offset 2
        IF s_Response[2] = 16#02 THEN
          o_Value      := WORD_TO_INT(BYTE_TO_WORD(s_Response[10]) + BYTE_TO_WORD(s_Response[11]) * 256);
        ELSIF s_Response[2] = 16#04 THEN
          o_ValueUDInt := DWORD_TO_UDINT(BYTE_TO_DWORD(s_Response[10])
                          + BYTE_TO_DWORD(s_Response[11]) * 256
                          + BYTE_TO_DWORD(s_Response[12]) * 65536
                          + BYTE_TO_DWORD(s_Response[13]) * 16777216);
        END_IF;
        o_Fault := FALSE;
      END_IF;
    END_IF;
    s_State := 0;
  END_IF;
END_FUNCTION_BLOCK

9. SCL Implementation: Torque Threshold Detection

The two typical uses of the V90 torque data are: a "torque reached" output for a press-fit or clamp application, and a torque-limit-monitor for a winding or tensioning application. The following code works on top of the cyclic M_ACT from Telegram 750, scaled in 0.1% units, with a configurable threshold and a hysteresis to prevent chatter.

FUNCTION_BLOCK "FB_Torque_Detect"
VAR_INPUT
  i_M_ACT_Raw      : INT;           // V90.IO.M_ACT (raw, 0.1% units, signed)
  i_ThresholdPct   : REAL := 80.0;  // trip threshold, percent of M_max
  i_HysteresisPct  : REAL := 2.0;   // release margin, percent of M_max
  i_Enable         : BOOL;
END_VAR
VAR_OUTPUT
  o_TorquePct      : REAL;          // engineering value, percent of M_max
  o_TorqueNm       : REAL;          // engineering value in Nm, if M_max known
  o_TorqueReached  : BOOL;
  o_TorqueLatched  : BOOL;          // set on trip, reset by i_Reset
END_VAR
VAR
  s_State          : BOOL;
END_VAR
BEGIN
  // 0.1% raw → percent: divide by 10.0
  o_TorquePct := INT_TO_REAL(i_M_ACT_Raw) / 10.0;
  o_TorqueNm  := 0.0; // populate externally if a M_max constant is known

  IF NOT i_Enable THEN
    o_TorqueReached := FALSE; o_TorqueLatched := FALSE; RETURN;
  END_IF;

  IF NOT s_State THEN
    // not yet tripped — trip on threshold
    IF o_TorquePct >= i_ThresholdPct THEN
      s_State := TRUE; o_TorqueReached := TRUE;
    END_IF;
  ELSE
    // already tripped — release on threshold minus hysteresis
    IF o_TorquePct <= (i_ThresholdPct - i_HysteresisPct) THEN
      s_State := FALSE; o_TorqueReached := FALSE;
    ELSE
      o_TorqueReached := TRUE;
    END_IF;
  END_IF;

  // Latch for "ever tripped since last reset" semantics
  IF o_TorqueReached THEN o_TorqueLatched := TRUE; END_IF;
END_FUNCTION_BLOCK

For a digital output assignment in OB1:

"FB_Torque_Detect"(i_M_ACT_Raw := "V90".M_ACT,
                   i_ThresholdPct := 75.0,
                   i_HysteresisPct := 3.0,
                   i_Enable := TRUE,
                   o_TorquePct => "dbRun".TorquePct,
                   o_TorqueReached => "dbRun".TorqueTrip,
                   o_TorqueLatched => "dbRun".TorqueLatched);

IF "dbRun".TorqueTrip THEN
  Q0.0 := TRUE;   // output "torque reached"
END_IF;
IF "dbRun".ResetLatch THEN
  "dbRun".TorqueLatched := FALSE; "dbRun".ResetLatch := FALSE;
END_IF;

10. Applying Torque Limits via Telegram 750

Two failure modes have to be addressed when writing M_LIMIT_POS and M_LIMIT_NEG from the S7-1200:

1. Limit is ignored. The V90 only honors the cyclic torque limits when p29050[0] (torque limit upper source) and p29050[1] (torque limit lower source) are set to a value that allows the PROFINET Telegram 750 to win. The default settings on V90 PN firmware V2.0 are p29050[0] = 4 (Telegram 750 M_LIMIT_POS) and p29050[1] = 5 (Telegram 750 M_LIMIT_NEG), but a V-Assistant import or a previous V90 test bench setup can leave them at 1 (fixed) or 3 (analog input). Verify with the V-Assistant parameter list or by reading p29050 acyclically before commissioning.
2. Limit applied, but motion stalls. Writing 0 as the limit stalls the axis. The drive will sit at I/t current limit and ZSW1 bit 11 (I x t warning) will be set. This is normal and is the only way the cyclic limit can force a stall; do not interpret it as a fault.

Safe-default write pattern (called once during startup or on parameter change):

// Convert a percent value (0..100) to 16-bit torque limit word (16384 = 100%)
"V90".M_LIMIT_POS := REAL_TO_INT(16384.0 * i_PosLimitPct / 100.0);
"V90".M_LIMIT_NEG := REAL_TO_INT(16384.0 * i_NegLimitPct / 100.0);
// Reserved word 3 stays at 0; the drive ignores it on V1.05 / V2.00
"V90".M_ADD := 0;

11. Alternative: Reading r27 (Actual Current) for Trip Detection

When the application only needs a current rise detector (jam detection, broken-tool detection) rather than a true torque trip, parameter r27 (smoothed actual current) is a faster signal and does not require the motor torque constant. r27 is reported in 0.1% of I_max, same scaling as r31. Telegram 105 (DS402) carries a current actual value in the cyclic image; Telegram 750's PZD 6 also carries a current-related value on the V2.00 firmware. The RDREC block in section 8 reads r27 with i_ParamNumber := 27 and no other changes.

Note that r27 is current, not torque. For a constant load torque, the two are related by I ∝ M, but during acceleration / deceleration the current actual value includes the dynamic component. For mechanical jam detection this is acceptable and often desirable. For an accurate torque trip, use r31 / M_ACT instead.

12. S7-1200 Technology Object Limitations

The S7-1200 axis object (TO) supports two modes against the V90 PN: position-controlled (positioning axis with Telegram 7) and speed-controlled (speed axis with Telegram 1 / 2 / 3). It does not support a torque-controlled axis object. The implications are:

• Torque limits must be written to the V90 by the user program (Telegram 750 or acyclic p29050). The TO has no "set torque limit" instruction.
• A torque-controlled motion (e.g. constant-torque winding) cannot be commanded from an S7-1200 TO. It can be approximated by limiting the speed setpoint inside Telegram 3 and accepting a velocity-controlled motion with torque saturation, or by closing the torque loop entirely in the S7-1200 user program against a polled r31 value.
• Real closed-loop torque control with a current / torque pre-control channel and a torque PI controller is only available on S7-1500 with the TControl TO and Telegram 5 (DSC) or Telegram 102. Move to an S7-1500 if true torque control is required.

13. V-Assistant Parameters: Importing to TIA Portal

The V-Assistant tool (Siemens part number 6SL3270-0CA00-0AG0 for the configuration version, distributed with Starter / Startdrive) configures the V90 offline and produces a parameter set in *.dnx or *.pdpx format. TIA Portal V17 does not import those files directly. The supported import path is:

1. Use the V-Assistant to identify the parameters that need to be set on the drive (p29050, p29060, p29075, p29076, encoder type, p29004 control mode, etc.).
2. Export the parameter set from V-Assistant as a CSV or text file.
3. Use the SINAMICS V90 PN function manual (the official source is the operating instructions linked below) to map each V-Assistant parameter to its corresponding TIA Portal device parameter view entry. The V90 parameter view in TIA Portal V17 is read-only – it shows what is currently in the drive – but it is the canonical source for the on-line configuration.
4. Apply the parameters in one of three ways: (a) upload from the drive to the project with Device → Upload to PG/PC after the V-Assistant has written them to the drive, (b) use the BOP (Basic Operator Panel) to enter them by hand, or (c) write them acyclically from the S7-1200 startup OB using RDREC's sibling instruction WRREC.

14. Commissioning and Verification Checklist

1. Drive powers up, both PROFINET ports show green link. CPU online diagnostics → V90 shows green check on all configured slots (slot 0 = the head module, slot 1 = Telegram 3, slot 2 = Telegram 750).
2. ZSW1 bit 0 (ready) and bit 2 (operation enabled) are both 1 after STW1 bit 0 and bit 3 are set. Without this, the actual torque word M_ACT reads 0 regardless of mechanical load.
3. Force the motor to a known mechanical load (e.g. clamp a hand-tight coupling). Read M_ACT and verify it changes with load. A change of less than 0.5% (5 raw LSBs) under hand pressure is acceptable. No change means Telegram 750 is not being read – check the slot mapping.
4. Write a small M_LIMIT_POS (e.g. 1638 = 10%). Accelerate the motor; verify that the speed actual stalls and ZSW1 bit 11 (I x t warning) is set. Restore the limit; the motor should resume.
5. Trigger an r31 acyclic read using FB_V90_ReadParam with i_ParamNumber := 31. Verify the returned word matches the cyclic M_ACT to within 2 LSB. If they disagree by more than 50 LSB, the acyclic record index is wrong (47 vs 0xB02E) or the slot is wrong.
6. Commission a small motion (a slow MC_MoveVelocity with v_target = 50 rpm). Verify that NIST_B follows NSOLL_B, ZSW1 bit 10 is set, and M_ACT remains within ±100% during the move.
7. Check the S7-1200 cycle time. With 1 ms PROFINET send clock and RDREC running every 50 ms, the OB1 cycle must stay below 8 ms on a CPU 1214C / 1215C. Higher OB1 cycle times cause PROFINET jitter and ZSW1 bit 3 (fault, communication failure) on the drive.

15. Fault and Diagnosis Matrix

Reference Material and Official Documentation

Authoritative Siemens documents to verify the behavior above against the active firmware revision:

• SINAMICS V90 PROFINET, SIMOTICS S-1FL6 Operating Instructions (06/2019, firmware V2.0) – primary source for Telegram 750 mapping, r31, and p29050.
• SINAMICS V90 Function Manual (firmware V1.05 and V2.00) – parameter list and acyclic record structure.
• SINAMICS V90 PN Firmware V2.00 Release Notes – revisions to Telegram 750 input PZDs 5/6.
• Acyclic communication between SIMATIC S7-1500 and SINAMICS V90 via PROFINET (entry 109749282) – record layout, slot/index conventions, library block reference for SINA_PARA_S.
• S7-1200 Programmable Controller System Manual (Edition 04/2017) – RDREC / WRREC instruction reference for the acyclic channel.
• SIMATIC S7-1200 Motion Control V17 Function Overview – Technology Object capability matrix showing the absence of a torque-controlled axis object on S7-1200.
• PROFINET Design Guidelines (Edition 2021) – send clock, watchdog, and update time rules for PROFINET IO.