Skip to main content
Blogs Gallery Manuals Videos
+91-9175475416
Siemens · Drive Logic

Siemens Standard Telegram Logic: STW1, ZSW1 and Speed Scaling with Copy-Paste SCL and DB Code

How the PLC builds the control word, reads the status word and scales speed for a SINAMICS G120 on PROFINET, explained bit by bit, with an animated test bench for each telegram and every SCL and DB source file on the page, ready to copy into TIA Portal.

Copy the CodeView All Blogs
2,500+ engineers trained 4.9/5 Google rating 21+ years, Chinchwad, Pune Next batch: contact for dates
Quick answer

Siemens standard telegram logic is the PLC code that packs commands into the control word STW1, sends a speed setpoint scaled so 16#4000 = 100 % of p2000, and unpacks the drive's status word ZSW1 and actual values. The drive starts on 16#047E then 16#047F, stops on 16#047E, and acknowledges faults with a rising edge on bit 7 (16#04FE). Every block for Telegram 1, Telegram 20 and free telegram 999 is below as copy-paste SCL and DB source.

  • Bits 1, 2, 3, 4, 5, 6 and 10 of STW1 are held at 1; only ON (bit 0) and acknowledge (bit 7) change in normal running.
  • OFF2 and OFF3 are active-low: a 0 stops the drive, so a broken signal fails safe.
  • Read “running” from ZSW1 bit 2, never from your own Run command.
  • Every scaled value is a percentage of a drive reference parameter; match p2000, p2002, p2003 and r2004 in the PLC.

    • Try it first: the Live PLC–VFD Simulator runs the same control and status words.

What Standard Telegram Logic Means

A PROFIdrive standard telegram is a fixed list of 16-bit process data words (PZD) that the PLC and the SINAMICS drive exchange every PROFINET cycle. The telegram itself only moves the words; the logic is what your PLC program does with them: build the control word from machine commands, convert rpm into a drive percentage, and turn the status word back into Ready, Running, Fault and actual speed.

The same logic serves every telegram on this page. Telegram 1 (PZD-2/2) carries control word and speed; Telegram 20 (PZD-2/6) adds current, torque, power and a fault word; free telegram 999 (PZD-8/8 or 16/16) keeps the first two words and lets you choose the rest.

TelegramPLC → driveDrive → PLCDrive setting
Standard 1 PZD-2/2STW1, NSOLL_AZSW1, NIST_Ap0922 = 1
Standard 20 PZD-2/6STW1, NSOLL_AZSW1, NIST_A, current, torque, power, NAMUR wordp0922 = 20
Free 999 PZD-8/8STW1, speed + 6 freeZSW1, speed + 6 freep0922 = 999
Free 999 PZD-16/16STW1, speed + 14 freeZSW1, speed + 14 freep0922 = 999

Animated Telegram Flow

Pick a telegram to see its words move between PLC and drive. The lower panel replays the start-up logic that every block on this page follows.

S7-1200 / S7-1500DPWR_DAT · DPRD_DAT
PLC → Drive4 bytes
Drive → PLC4 bytes
SINAMICS G120p0922 = 1
STW116#0000
Speed0 rpm
InhibitRdyRunFault

Power up: ZSW1 bit 6 “switching on inhibited” is set.

Every FB on this page writes the whole PLC → drive telegram with DPWR_DAT and reads the whole drive → PLC telegram with DPRD_DAT in one call, using the telegram's hardware ID.

Control Word Logic (STW1)

STW1 is identical in Telegram 1, 20 and the free telegram. The logic has three kinds of bit: commands you switch (ON, acknowledge, reverse), active-low stops that must stay 1 to run (OFF2, OFF3), and enables held at 1 permanently.

BitSignalLogic in the FB
0ON / OFF1Run AND NOT AckFault AND NOT SwitchOnInhibit
1No OFF2 (coast stop)NOT CoastStop — 0 removes pulses, motor coasts
2No OFF3 (quick stop)NOT QuickStop — 0 stops on the fast ramp p1135
3Enable operationHeld TRUE
4Enable ramp-function generatorHeld TRUE
5Continue ramp-function generatorHeld TRUE
6Enable speed setpointHeld TRUE
7Acknowledge faultAckFault — acts on the 0 → 1 edge
10Control by PLCHeld TRUE — without it the drive ignores the telegram
8, 9, 11–15Drive-specificLeft 0; reverse is done with a negative setpoint instead

Try it: STW1 logic builder

Tick bits to build a control word, or load one of the values the FB sends.

STW1 = 16#0000

Status Word Logic (ZSW1)

ZSW1 is the drive's answer. The FB copies each useful bit to a named BOOL output, so the rest of your program and the HMI never deal with bit numbers.

BitMeaning when 1FB output
0Ready to switch onReadyToSwitchOn
1Ready for operationReady
2Operation enabled (running)Running
3Fault presentFault
4 / 5OFF2 / OFF3 not active—
6Switching on inhibitedSwitchOnInhibit
7Alarm (warning) presentAlarm
8Speed setpoint and actual within toleranceAtSetpoint
9Control requested from PLC—
10–15Comparison value reached, limits, brake, temperature, direction, overload (drive-specific)Read from ZSW1 word

Try it: ZSW1 decoder

    Start-Up State Logic: 16#047E to 16#047F

    The drive follows the PROFIdrive state machine, so the order of control words matters. Sending 16#047F straight after power-up leaves the drive in “switching on inhibited”. The FB solves this in one line: ON is held at 0 while ZSW1 bit 6 is set, so the drive always sees 16#047E first.

    StepPLC sends STW1Drive reports in ZSW1
    1. Power up16#047E (ON forced to 0)Bit 6 switching on inhibited
    2. Ready16#047EBit 0 ready to switch on
    3. Run16#047F + speed setpointBits 1 and 2, motor ramps up
    4. Stop (OFF1)16#047EBit 2 drops after the ramp-down
    5. Fault—Bit 3 fault present
    6. Acknowledge16#04FE for one scan, then 16#047EBit 3 clears, back to step 1 or 2

    Test Each Telegram: Animated Test Bench

    Choose a telegram and drive it like the PLC would. The bench runs the same STW1 logic as the FBs below, a simulated G120 answers through ZSW1 and the actual-value words, and the checklist ticks off each test as the drive passes it. Press Run automatic test to watch the full sequence play by itself.

    PLC commands p2000 = 1500 rpm in this simulation.
    PLC → Drive
    Drive → PLC
    SINAMICS G120
    0 rpm
    Switching on inhibited
    Rdy onRunningFaultInhibitAt SPFwd
    p0922 = 1
    Test checklist0 / 6 passed
    Get Telegram 1 · 2/2 files

      Power up: the drive reports “switching on inhibited”. The FB holds STW1 at 16#047E until it clears.

      Training simulation. The PLC side uses the same STW1 logic and 16#4000 scaling as the FBs on this page; current, torque, power and DC-link values come from a simple motor model (p2002 = 10 A, p2003 = 10 Nm, r2004 = 4 kW), and the NAMUR word is a demo value. A real drive returns its own values.

      Speed and Actual-Value Scaling Logic

      The drive does not understand rpm. Every analog word is a signed percentage where 16#4000 (16384) is 100 % of a reference parameter in the drive.

      Scaling formulas — Telegram 1, 20 and free telegram
      // Speed setpoint (Telegram 1, 20, free word 2)
NSOLL_A  = Speed_rpm / p2000 * 16384        // 16#4000 = 100 %

// Actual values back from the drive
Speed_rpm   = NIST_A / 16384 * p2000
Current_A   = IAIST  / 16384 * p2002        // Telegram 20, word 3
Torque_Nm   = MIST   / 16384 * p2003        // Telegram 20, word 4
Power_kW    = PIST   / 16384 * r2004        // Telegram 20, word 5

// Limits: -32768 .. +32767  =  about -200 % .. +200 % of the reference

      Worked example: p2000 = 1500 rpm, setpoint 750 rpm → 750 / 1500 × 16384 = 8192 = 16#2000. If the drive returns NIST_A = 16#2000, the FB shows 750.0 rpm. A negative value runs the motor in reverse, which is how the FB's Reverse input works.

      Copy-Paste Code: Separate .scl and .db Package for Each Telegram

      Each telegram has its own package of three source files, so you can download, import and test one telegram on its own without touching the others. Every package uses unique block names (DB_Tel1_HMI, DB_Tel20_HMI, DB_Free8_HMI, DB_Free16_HMI and so on), so two or more packages can also live in the same PLC.

      Telegram 1 (PZD-2/2) package

      p0922 = 1 · 3 source files · blocks FB_G120_Tel1_PZD2x2, DB_Tel1_HMI, IDB_Tel1_Drv01, FC_Tel1_Call

      Download .zip
      1. FB_G120_Tel1_PZD2x2.scl function block
      2. DB_Tel1_PZD2x2.db HMI DB + instance DB
      3. FC_Tel1_Call.scl call FC, then "FC_Tel1_Call"(); in OB1

      Step 1 · Function block

      FB_G120_Tel1_PZD2x2.scl
      FUNCTION_BLOCK "FB_G120_Tel1_PZD2x2"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 1.0
//Softwell Automation - SINAMICS G120, Standard Telegram 1 (PZD-2/2)
//PLC -> Drive : PZD1 STW1, PZD2 NSOLL_A (16#4000 = 100 % of p2000)
//Drive -> PLC : PZD1 ZSW1, PZD2 NIST_A_GLATT
//Drive setting : p0922 = 1
   VAR_INPUT 
      Run : Bool;   // TRUE = run (STW1.0 ON / OFF1)
      Reverse : Bool;   // TRUE = negative speed setpoint
      AckFault : Bool;   // pulse TRUE to acknowledge a fault (STW1.7)
      CoastStop : Bool;   // TRUE = OFF2, pulses off, motor coasts
      QuickStop : Bool;   // TRUE = OFF3, fast ramp stop (p1135)
      SpeedSP_rpm : Real;   // speed setpoint in rpm (positive)
      RefSpeed_rpm : Real := 1500.0;   // MUST equal drive p2000
      HW_ID : HW_IO;   // hardware ID of the telegram (system constant)
   END_VAR

   VAR_OUTPUT 
      ReadyToSwitchOn : Bool;   // ZSW1.0
      Ready : Bool;   // ZSW1.1
      Running : Bool;   // ZSW1.2 operation enabled
      Fault : Bool;   // ZSW1.3
      SwitchOnInhibit : Bool;   // ZSW1.6
      Alarm : Bool;   // ZSW1.7
      AtSetpoint : Bool;   // ZSW1.8
      ActSpeed_rpm : Real;   // actual speed in rpm
      STW1 : Word;   // control word sent (for watch table)
      ZSW1 : Word;   // status word received (for watch table)
      CommError : Bool;   // TRUE = DPRD_DAT / DPWR_DAT error
      RdStatus : Int;   // 0 = read OK
      WrStatus : Int;   // 0 = write OK
   END_VAR

   VAR 
      Tx : Array[1..2] of Word;   // PZD1..2 to drive
      Rx : Array[1..2] of Word;   // PZD1..2 from drive
   END_VAR

   VAR_TEMP 
      tStw1 : Word;
      tSp : LReal;
   END_VAR


BEGIN
   // 1. Read the complete telegram from the drive (consistent)
   #RdStatus := DPRD_DAT(LADDR := #HW_ID, RECORD => #Rx);
   #ZSW1 := #Rx[1];
   
   // 2. Decode status word ZSW1
   #ReadyToSwitchOn := #ZSW1.%X0;
   #Ready := #ZSW1.%X1;
   #Running := #ZSW1.%X2;
   #Fault := #ZSW1.%X3;
   #SwitchOnInhibit := #ZSW1.%X6;
   #Alarm := #ZSW1.%X7;
   #AtSetpoint := #ZSW1.%X8;
   
   // 3. Build control word STW1 (base 16#047E, ON adds bit 0 = 16#047F)
   //    ON is held at 0 while "switching on inhibited" so the drive always
   //    passes through 16#047E first, even if Run is already TRUE at power-up.
   #tStw1 := 16#0000;
   #tStw1.%X0 := #Run AND NOT #AckFault AND NOT #SwitchOnInhibit;   // ON / OFF1
   #tStw1.%X1 := NOT #CoastStop;   // OFF2 (active low)
   #tStw1.%X2 := NOT #QuickStop;   // OFF3 (active low)
   #tStw1.%X3 := TRUE;   // enable operation
   #tStw1.%X4 := TRUE;   // enable ramp-function generator
   #tStw1.%X5 := TRUE;   // continue ramp-function generator
   #tStw1.%X6 := TRUE;   // enable speed setpoint
   #tStw1.%X7 := #AckFault;   // acknowledge on rising edge
   #tStw1.%X10 := TRUE;   // control by PLC
   #STW1 := #tStw1;
   #Tx[1] := #tStw1;
   
   // 4. Speed setpoint: rpm -> NSOLL_A (16#4000 = 16384 = 100 % of p2000)
   IF #RefSpeed_rpm > 0.0 THEN
       #tSp := REAL_TO_LREAL(#SpeedSP_rpm) / REAL_TO_LREAL(#RefSpeed_rpm) * 16384.0;
       IF #Reverse THEN
           #tSp := -#tSp;
       END_IF;
       #tSp := LIMIT(MN := -32767.0, IN := #tSp, MX := 32767.0);
       #Tx[2] := INT_TO_WORD(LREAL_TO_INT(#tSp));
       
       // 5. Actual speed: NIST_A -> rpm
       #ActSpeed_rpm := INT_TO_REAL(WORD_TO_INT(#Rx[2])) / 16384.0 * #RefSpeed_rpm;
   ELSE
       #Tx[2] := 16#0000;
       #ActSpeed_rpm := 0.0;
   END_IF;
   
   // 6. Write the complete telegram to the drive (consistent)
   #WrStatus := DPWR_DAT(LADDR := #HW_ID, RECORD := #Tx);
   #CommError := (#RdStatus <> 0) OR (#WrStatus <> 0);
   
END_FUNCTION_BLOCK

      Step 2 · Data blocks

      DB_Tel1_PZD2x2.db
      DATA_BLOCK "DB_Tel1_HMI"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 1.0
NON_RETAIN
//Softwell Automation - HMI command / status DB, Telegram 1 (PZD-2/2)
//Generate "FB_G120_Tel1_PZD2x2" from its .scl source BEFORE this file.
//Edit Ref_rpm (= p2000) and the other reference values to match the drive.
   VAR 
      Drv01 : Struct   // Telegram 1 (PZD-2/2)
         Cmd_Run : Bool;
         Cmd_Reverse : Bool;
         Cmd_Ack : Bool;
         Cmd_Coast : Bool;
         Cmd_QuickStop : Bool;
         SP_rpm : Real;
         Ref_rpm : Real := 1500.0;   // = p2000
         Sts_Ready : Bool;
         Sts_Running : Bool;
         Sts_Fault : Bool;
         Sts_Alarm : Bool;
         Sts_CommError : Bool;
         Act_rpm : Real;
         STW1 : Word;
         ZSW1 : Word;
      END_STRUCT;
   END_VAR


BEGIN

END_DATA_BLOCK

DATA_BLOCK "IDB_Tel1_Drv01"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 1.0
NON_RETAIN
"FB_G120_Tel1_PZD2x2"

BEGIN

END_DATA_BLOCK

      Step 3 · Call function

      FC_Tel1_Call.scl
      FUNCTION "FC_Tel1_Call" : Void
{ S7_Optimized_Access := 'TRUE' }
VERSION : 1.0
//Softwell Automation - calls drive 01 on Telegram 1 (PZD-2/2).
//Generate order: FB_G120_Tel1_PZD2x2.scl, then DB_Tel1_PZD2x2.db, then this file.
//Call this FC from OB1:   "FC_Tel1_Call"();
//HW_ID: replace 269 with the hardware identifier of the telegram
//(Device view > telegram row > Properties > System constants), or drag the
//system constant (e.g. "Drive_1~...telegram...") onto the pin.
BEGIN
   "IDB_Tel1_Drv01"(Run := "DB_Tel1_HMI".Drv01.Cmd_Run,
                    Reverse := "DB_Tel1_HMI".Drv01.Cmd_Reverse,
                    AckFault := "DB_Tel1_HMI".Drv01.Cmd_Ack,
                    CoastStop := "DB_Tel1_HMI".Drv01.Cmd_Coast,
                    QuickStop := "DB_Tel1_HMI".Drv01.Cmd_QuickStop,
                    SpeedSP_rpm := "DB_Tel1_HMI".Drv01.SP_rpm,
                    RefSpeed_rpm := "DB_Tel1_HMI".Drv01.Ref_rpm,
                    HW_ID := 269,
                    Ready => "DB_Tel1_HMI".Drv01.Sts_Ready,
                    Running => "DB_Tel1_HMI".Drv01.Sts_Running,
                    Fault => "DB_Tel1_HMI".Drv01.Sts_Fault,
                    Alarm => "DB_Tel1_HMI".Drv01.Sts_Alarm,
                    ActSpeed_rpm => "DB_Tel1_HMI".Drv01.Act_rpm,
                    STW1 => "DB_Tel1_HMI".Drv01.STW1,
                    ZSW1 => "DB_Tel1_HMI".Drv01.ZSW1,
                    CommError => "DB_Tel1_HMI".Drv01.Sts_CommError);
   
END_FUNCTION

      OB1 call for each package

      OB1 — SCL network
      // OB1 - add the line for each package you imported
"FC_Tel1_Call"();      // Telegram 1, PZD-2/2
"FC_Tel20_Call"();     // Telegram 20, PZD-2/6
"FC_Free8_Call"();     // Free telegram, PZD-8/8
"FC_Free16_Call"();    // Free telegram, PZD-16/16

      Single Telegram 1 drive without the HMI DB

      OB1 — one Telegram 1 drive
      // OB1 - SCL network: one Telegram 1 drive, instance DB "IDB_Drive_1"
"IDB_Drive_1"(Run := "Motor1_Run",
              AckFault := "Motor1_Reset",
              SpeedSP_rpm := "HMI_Set_RPM",
              RefSpeed_rpm := 1500.0,          // = p2000
              HW_ID := "Drive_1~Standard_telegram_1",
              Running => "Motor1_Running",
              Fault => "Motor1_Fault",
              ActSpeed_rpm => "HMI_Act_RPM");

      Free telegram drive parameters (BICO)

      Set these in the drive after p0922 = 999. Receive words are r2050[x], bits of word 1 are r2090.x, send words are p2051[x]; index 0 is PZD1. Confirm parameter numbers in your control unit's list manual.

      Drive BICO list — free telegram 999
      // Free telegram 999 - receive (PLC -> drive)
p0922    = 999          // free telegram
p0840[0] = r2090.0      // ON / OFF1
p0844[0] = r2090.1      // OFF2
p0848[0] = r2090.2      // OFF3
p0852[0] = r2090.3      // enable operation
p1140[0] = r2090.4      // enable ramp-function generator
p1141[0] = r2090.5      // continue ramp-function generator
p1142[0] = r2090.6      // enable setpoint
p2103[0] = r2090.7      // acknowledge fault
p0854[0] = r2090.10     // control by PLC
p1070[0] = r2050[1]     // main speed setpoint (word 2)

// Free telegram 999 - send (drive -> PLC)
p2051[0] = r2089[0]     // word 1: ZSW1
p2051[1] = r0063        // word 2: actual speed
p2051[2] = r0027        // word 3: current (example)
p2051[3] = r0031        // word 4: torque (example)
p2051[4] = r0032        // word 5: power (example)
p2051[5] = r0026        // word 6: DC-link voltage (example)
// save: copy RAM to ROM

      Watch table for testing a package

      Watch table entries — drive 01
      // Telegram 1 package - use DB_Tel20_HMI, DB_Free8_HMI or DB_Free16_HMI for the others
"DB_Tel1_HMI".Drv01.Cmd_Run          Bool      TRUE / FALSE
"DB_Tel1_HMI".Drv01.SP_rpm           Real      750.0
"DB_Tel1_HMI".Drv01.STW1             Hex       16#047E stopped, 16#047F running
"DB_Tel1_HMI".Drv01.ZSW1             Hex       from drive
"DB_Tel1_HMI".Drv01.Sts_Running      Bool      ZSW1 bit 2
"DB_Tel1_HMI".Drv01.Sts_Fault        Bool      ZSW1 bit 3
"DB_Tel1_HMI".Drv01.Act_rpm          Real      about 750.0 when running
"DB_Tel1_HMI".Drv01.Sts_CommError    Bool      must be FALSE

      Import the Code into TIA Portal

      1. In the project tree, open the PLC, expand External source files and double-click Add new external file.
      2. Select the saved .scl or .db file, right-click it and choose Generate blocks from source.
      3. For each telegram, generate its three files in the package order: the FB .scl, then the .db (HMI DB + instance DB), then the call FC .scl.
      4. In the package's call FC, replace the example hardware ID (269, 270, 271 or 272) with each telegram's hardware identifier (Device view → telegram row → Properties → System constants).
      5. Enter p2000 (and p2002, p2003, r2004 for Telegram 20) in that package's HMI DB (for example DB_Tel1_HMI), set p0922 in the drive, then download.
      Note: import only the packages for the telegrams you use. Generate the .db after its FB and the call FC last; an FC that refers to a block that was not generated will not compile.

      Troubleshooting the Telegram Logic

      SymptomLikely causeFix
      STW1 stays 16#047E with Run TRUEZSW1 bit 6 still set, or drive faultCheck ZSW1; acknowledge any fault
      STW1 16#047F, motor does not turnSpeed setpoint 0 or p0922 different from TIACheck SP_rpm and the drive's telegram
      Speed half or doubleRef_rpm ≠ p2000Copy p2000 into the DB
      RdStatus 16#8090Wrong hardware IDUse the telegram row's system constant
      RdStatus 16#80B1FB length ≠ configured telegramUse the FB that matches the telegram
      Fault will not clearCmd_Ack held TRUEPulse it for one scan

      Step-by-Step Lab: Standard Telegram Logic on Live Hardware

      Hands-on
      Before you start
      • An S7-1200 (firmware V4+) or S7-1500 and a G120 with a PROFINET control unit in one TIA Portal project.
      • p2000 known and the motor uncoupled or on a test bench.
      • Estimated time: 45 minutes.
      1

      Generate the blocks

      Download the Telegram 1 package and generate FB_G120_Tel1_PZD2x2.scl, DB_Tel1_PZD2x2.db and FC_Tel1_Call.scl in that order. Add "FC_Tel1_Call"(); to OB1.

      The blocks appear under Program blocks and compile.
      2

      Check the ready logic

      Download, go online and watch STW1 and ZSW1 in hexadecimal with no command.

      STW1 reads 16#047E and ZSW1 bit 6 clears within a second.
      3

      Run and verify scaling

      Set SP_rpm to 750.0 and Cmd_Run to TRUE.

      STW1 becomes 16#047F, Sts_Running goes TRUE and Act_rpm settles close to 750.
      4

      Test the stops and acknowledge

      Try Cmd_Coast, Cmd_QuickStop and Cmd_Run = FALSE in turn, then force a fault and pulse Cmd_Ack.

      Each stop behaves as its bit table describes and the fault clears on the acknowledge pulse.
      Checkpoint — how to know you did it right

      You can predict the hex value of STW1 before you change a command, and read the drive state from ZSW1 without looking it up.

      For the same Telegram 1 logic in Ladder, see the G120 PROFINET standard FB, and for every bit in detail, SINAMICS G120 STW1 and ZSW1 bits.

      Frequently asked questions

      What is Siemens standard telegram logic?

      It is the PLC program logic that builds the STW1 control word from machine commands, scales the speed setpoint so that 16#4000 equals 100 percent of p2000, and decodes the ZSW1 status word and actual values coming back from a SINAMICS drive.

      Why does the drive need 16#047E before 16#047F?

      After power-up or a fault the drive is in switching on inhibited (ZSW1 bit 6). It only leaves that state when it sees ON = 0 with the stop and enable bits set, which is 16#047E. Then 16#047F switches it on.

      How do I acknowledge a fault with the standard telegram?

      Set STW1 bit 7 for at least one scan to give a 0 to 1 edge, which is 16#04FE with ON at 0, then return to 16#047E. Holding bit 7 permanently does not acknowledge a new fault.

      What does 16#4000 mean in the speed word?

      16#4000 (16384) is 100 percent of the drive reference speed p2000. With p2000 = 1500 rpm, 16#2000 is 750 rpm and a negative value runs in reverse.

      Can I copy the SCL and DB code straight into TIA Portal?

      Yes. Each telegram has its own package of three files. Save each box with the file name shown, add it under External source files and choose Generate blocks from source: the FB .scl first, then the .db, then the call FC .scl.

      Which telegram should I use, 1, 20 or 999?

      Use Telegram 1 for start, stop and speed. Use Telegram 20 when you also want current, torque, power and a fault word. Use free telegram 999 when you need to choose the signals yourself.

      Reviewed by Bhawesh Kumar SinghIndustrial Automation Trainer and Industry 4.0 Consultant · Softwell Automation · 21+ years industry experience
      Siemens PLC, VFD & SCADA TrainingTelegram logic, drive state machines and PROFINET control on real S7 and SINAMICS hardware.View syllabus → SCL Programming TrainingWrite, import and debug reusable SCL function blocks like the ones on this page.View syllabus → Online Siemens VFD TrainingLive G120 commissioning and PLC control with remote hardware access.View syllabus →

      Get the full syllabus + free demo class

      Share your details — a Softwell training advisor will call you within 24 hours with batch dates, fees and hardware access options.

      No spam. Used only to share course details for this enquiry.

      Learn with practical industrial examples

      Join live online, Pune classroom or corporate in-plant automation training.

      Request Course Details
      Verified learning pathway

      Discuss Your Automation Requirement

      Get guidance for training, corporate programs, projects or technical resources.

      Content reviewed: 31 October 2026

      Training ProgramsVideosContactContact Softwell Automation
      ☎ Call WhatsApp ✉ Email Enquire Now