IMDHMIControls LibraryShop main store

How-to

Use SFK-P function blocks for Smart Function Kit Pressing

PLC programming Published 7 min read

Short answer

The SFK-P example project supplies four blocks for TIA Portal V16 on the S7-1200 and S7-1500, for Smart Function Kit Pressing from version 5.1.114 onward: pick by data path — SFK_Command for command and status, SFK_Fast_Variable_Access for variables, SFK_SerialNumberConverter before a serial number goes in, SFK_GetNotification for status data — and confirm the PROFINET connection before debugging any block.

On this page
  1. Which PLC and software versions do the SFK-P blocks support?
  2. What files ship in the SFK-P example package?
  3. Which SFK block handles which data path?
  4. How do you confirm PROFINET is carrying the SFK-P data?
  5. How do you send a command and get status back with SFK_Command?
  6. How do you read or write an SFK-P variable with SFK_Fast_Variable_Access?
  7. When does a serial number need SFK_SerialNumberConverter first?
  8. When do you call SFK_GetNotification?
  9. How do you integrate the blocks and verify them?
  10. Questions asked

Pick each block by the data path it serves and clear the version gates before you debug anything: the SFK-P example project supplies SFK_Command for commands with status feedback, SFK_Fast_Variable_Access for reading and writing variables, SFK_SerialNumberConverter for serial numbers, and SFK_GetNotification for status carried in fieldbus data. The set is documented for TIA Portal V16 on the S7-1200 and S7-1500, for Smart Function Kit Pressing from version 5.1.114 onward. Every one of them rides on PROFINET fieldbus data, so the device connection comes before block logic.

Which PLC and software versions do the SFK-P blocks support? #

The blocks are documented for TIA Portal V16 on the S7-1200 and S7-1500, with Smart Function Kit Pressing at version 5.1.114 or later; anything older on the kit side is outside the documented range.

Read three values before you touch the logic: the TIA Portal release you run, the CPU family of the target, and the installed kit version from the SFK-P device information. All three gates come from the example project's own description, so they are compatibility facts, not field tuning.

Worked version check: the device information reports 5.1.108. Compare it with the floor segment by segment — major 5 = 5, minor 1 = 1, build 108 < 114, short by 114 − 108 = 6 build numbers. Decision: update the kit before commissioning the blocks, because a block that misbehaves below 5.1.114 is a compatibility question, not a fieldbus fault. A kit reporting 5.2.40 passes on the second segment, 2 > 1, before the build number is even compared.

Outside those gates these blocks are not the documented path. On a CPU other than the two named families, work from the kit's fieldbus documentation for your controller. The kit itself also speaks EtherNet/IP and EtherCAT, and the EtherNet/IP route from an Omron PLC is covered in connecting an Omron PLC to Smart Function Kit Pressing.

What files ship in the SFK-P example package? #

The package carries a license file, a readme, a changelog and the TIA Portal project file, and the readme plus changelog decide whether the blocks match the kit version you read in the first check.

The license sets what you may do with the blocks. The readme holds the project-specific setup notes. The changelog lists what changed between kit software versions, so you can see whether a behavior you are chasing changed at or after your version. Read the readme and changelog before you open the project itself, because setup notes answered there settle questions that reverse-engineering the project will not.

Which SFK block handles which data path? #

Match the block to the data path you need: SFK_Command for command and status, SFK_Fast_Variable_Access for variables, SFK_SerialNumberConverter before a serial number enters the kit, SFK_GetNotification for status carried in fieldbus data.

Block Data path Use it when
SFK_Command Command out, status feedback back Your sequence must start or stop a kit function and confirm the result
SFK_Fast_Variable_Access Variable reads and writes through fieldbus data A value has to be read from or written to the kit over the connection
SFK_SerialNumberConverter String serial number in, kit-format value out A serial number arrives as a string and must be passed to the kit
SFK_GetNotification Status data out of the fieldbus data The application must display, alarm on or log kit status

The roles do not overlap. SFK_Command is not the variable path and SFK_Fast_Variable_Access is not the command path, so a stage of your logic that never executes is usually a wrong block choice rather than a fault in the kit.

How do you confirm PROFINET is carrying the SFK-P data? #

Check the device connection and the data areas before any block logic: the blocks only reshape bytes that PROFINET already moved, so a silent block usually means the data path, not the block.

Read the PROFINET device diagnostics in the CPU and confirm the SFK-P reports as connected. Then watch the input and output data areas the project maps — you are only checking that they update. Both checks pass before you judge any block. If the connection drops or the data sits still, the fix lives in device configuration or cabling, and on an S7-1200 that runs motion over PROFINET that family of faults has its own checklist in troubleshooting S7-1200 PROFINET servo motion control issues.

How do you send a command and get status back with SFK_Command? #

Call SFK_Command with the command your sequence needs and use the status feedback it returns as the confirmation that the kit received it; never assume the command landed from the logic state alone.

One safety note, placed where the first live command gets sent: confirm the press is guarded so an unexpected stroke cannot reach anyone before you hand control to the PLC.

Drive the command from your sequence logic and treat the returned feedback as the only acceptance criterion. When the feedback never changes, apply the split from the connection checks above: connection and data first, calling logic second.

How do you read or write an SFK-P variable with SFK_Fast_Variable_Access? #

Pass the variable request through SFK_Fast_Variable_Access and watch the corresponding fieldbus data change; if the data area moves and your value does not, the fault is in the request, not the network.

Reads and writes ride the fieldbus data the connection already carries, the same cyclic exchange that moves telegram data for a PROFINET servo drive; see controlling a PROFINET servo drive with cyclic telegram data for how that exchange is structured. For a variable that will not update, inspect the request first and the data area second: an area that moves while your value stands still points at the request, and an area that never moves sends you back to the connection checks.

When does a serial number need SFK_SerialNumberConverter first? #

Convert whenever a serial number starts as a string in your logic: SFK_SerialNumberConverter turns it into the representation the SFK-P recognizes, and passing the raw string instead is the usual reason the kit rejects it.

Feed the string in, inspect the converted output, and pass only the converted value onward. Comparing the two before the kit sees either one is the entire test, and a mismatch caught at the converter never reaches the press.

When do you call SFK_GetNotification? #

Call SFK_GetNotification whenever the application needs kit status carried in the fieldbus data for display or logging, because it is the documented path from raw status data to usable output.

Feed it the status data from the fieldbus image and use its output for operator display, alarm logic or a log. If the output looks wrong, check first whether the status data at its input is fresh. Fresh input with wrong output means the block's inputs are connected incorrectly, not that the kit misreports.

How do you integrate the blocks and verify them? #

Copy the blocks from the example project into your application, keep their ties to the fieldbus data intact, compile, then test one data path at a time until each block output tracks its input.

  1. Open the supplied project in the engineering environment it targets, after the readme, and copy only the blocks your application needs.
  2. Keep every tie between block inputs, block outputs and the fieldbus data exactly as the example shows, because the blocks consume that data rather than configure the network.
  3. Compile the project and clear every interface error before download.
  4. With the connection live, run one test per path you use: one command with its feedback observed, one variable read and one write, one serial number checked at the converter output, and one status retrieval compared against the fieldbus data.
  5. Accept the integration only when every block output tracks its input across a full sequence and the data areas keep updating.

That is the whole commissioning gate: versions pass, the connection holds steady, and each block proves its own path. Anything short of it is a fault with an address — kit version, connection, request format or block inputs — and the checks above tell you which one.

Questions asked

Can I open the SFK-P example project in a newer TIA Portal than V16?

Yes. A newer TIA Portal migrates an older project forward when you open it, and the migration is one-way, so work on a copy and keep the original. The blocks are documented for V16, so after migrating, compile the project and clear every interface error before download; a clean compile on your release is the practical compatibility test.

How do I read the installed SFK-P software version?

Read it from the kit's device information in its web-based software, then compare it with 5.1.114 segment by segment: major number first, then minor, then build. A report of 5.1.108 fails on the build segment, 108 against 114, while 5.2 or higher passes on the minor segment before the build number matters.

Do I need all four SFK blocks in my application?

No. Copy the subset your paths need: an application that commands the kit needs SFK_Command, variable access needs SFK_Fast_Variable_Access, status display or logging needs SFK_GetNotification, and SFK_SerialNumberConverter only where a serial number arrives as a string. The example project stays the reference for how each block ties to the fieldbus data.

Can I use these blocks on an S7-300 or another Siemens CPU?

No. The example project is documented for the S7-1200 and S7-1500, and on another CPU family these blocks are not the tested path. Work from the kit's fieldbus documentation for your controller instead; deciding that before you copy any block saves the whole rework.

Keep reading

  • How-to

    Connect an Omron PLC to Smart Function Kit Pressing

    Use EtherNet/IP between the Omron NX/NJ/NY PLC and the Smart Function Kit Pressing: Omron's EtherCAT runs CoE, the kit's runs SoE, and the two profiles cannot exchange data. Load the Sysmac Studio example project and drive the kit with the SFK_Command, SFK_Fast_Variable_Access, SFK_SerialNumberConverter and SFK_GetNotification blocks.

    Industrial networks

  • Troubleshooting

    Reading IO-Link ISDU parameters over PROFINET acyclic record data

    If cyclic IO-Link process data exchanges normally, leave out the connect section of IOL_CALL and address the identification and ISDU calls with the hardware ID of the proxy submodule for the target port, read straight from the PROFINET device configuration. A valid connect result such as 8 proves only that a lookup succeeded, not that it selected your port's submodule.

    PLC programming

  • How-to

    S7-300 PID control for a modulating burner motor

    Run one FB41 CONT_C loop on the hottest hood's PT100, scale all five probes to °C, and turn the 0-100% output into open/close pulses that follow the M941B's 0-10 V pot feedback to a 2% deadband, through 24 VAC interposing relays. The gas management system keeps the burner start sequence and its permissives; the PID never touches them.

    PLC programming