How-to
Connect an Omron PLC to Smart Function Kit Pressing
Short answer
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.
On this page
Connect the Smart Function Kit Pressing (SFK-P) to an Omron NX, NJ or NY series PLC over EtherNet/IP, using the Sysmac Studio example project and its four function blocks. EtherCAT is not an option on this pairing: Omron's EtherCAT interface uses the CAN Application Protocol over EtherCAT (CoE), while the kit's EtherCAT fieldbus uses the Servodrive Profile over EtherCAT (SoE), and the two application profiles cannot exchange data. Nothing in PLC logic changes that. The work is therefore straightforward: select EtherNet/IP on the kit, configure the built-in EtherNet/IP port on the controller, load the example project, and commission command, variable, notification and serial-number handling through the supplied blocks.
Why EtherCAT is off the table #
The incompatibility sits above the cable, in the application profile. Omron's EtherCAT interface, as documented for this integration, runs CoE, the CAN Application Protocol over EtherCAT: every data item lives in an object dictionary addressed by index and subindex. The kit's EtherCAT fieldbus runs SoE, the Servodrive Profile over EtherCAT: data lives in SERCOS-style identification-number attributes instead.
Both profiles sit in the IEC 61800-7 family of drive communication profiles, but they are separate mappings over the same wire, and a device implements one or the other. A CoE master has no way to address SoE attributes, and neither side translates between them, so no setting or function-block change closes the gap. The decision is architectural: an NX, NJ or NY controller talking to an SFK-P uses EtherNet/IP.
Worked example: deciding the link for an NX-series controller and an SFK-P #
The inputs, each with its source:
- Controller-side EtherCAT profile: CoE, per the example project documentation.
- Kit-side EtherCAT profile: SoE, per the same documentation.
- Fieldbus common to both devices: EtherNet/IP, per the same documentation.
- Controller families the example project supports: NX, NJ and NY.
- Toolchain floor: Sysmac Studio 1.20 or later, the point from which the built-in EtherNet/IP scanner and adapter interface is documented for NJ/NX controllers.
The rule in words: a path between two devices is viable only when both use the same network and the same application profile, so count the candidates that pass both tests.
The arithmetic:
- Candidate paths: EtherCAT and EtherNet/IP, so 2 candidates.
- EtherCAT: CoE on the controller against SoE on the kit, profiles differ, scores 0.
- EtherNet/IP: spoken at both ends, scores 1.
- Viable paths: 0 + 1 = 1.
- Toolchain: 1.20 available against 1.20 required, so the interface behind the one viable path exists on the controller.
Result: 1 of 2 candidate paths is viable, and it is EtherNet/IP.
The decision, with its threshold: at exactly 1 viable path the architecture is fixed, so configure EtherNet/IP and spend the remaining effort on the data mapping. A count of 0, which means a controller family outside NX/NJ/NY or a kit profile the controller cannot match, is the stop condition: no project work repairs that pairing.
What you need before you configure #
- An NX, NJ or NY series controller. The example project names these three families and nothing else.
- Sysmac Studio at 1.20 or later, so the built-in EtherNet/IP port exposes the scanner and adapter interface this link needs.
- The SFK-P with its fieldbus selection set to EtherNet/IP. If it sits on EtherCAT, change the selection: the two are not substitutes.
- The Sysmac Studio example project for the kit, which carries the four function blocks and the data mapping behind them.
- The NJ/NX built-in EtherNet/IP port user's manual (W506) on the bench, because connection configuration and tag data link settings live there.
Configuring the Omron side as the EtherNet/IP scanner is the same controller-side work as Configure a PowerFlex 525 on EtherNet/IP from an Omron NJ301: the far device changes, the scanner setup does not.
Configure the EtherNet/IP link #
- Set the kit's fieldbus selection to EtherNet/IP and confirm the kit reports that mode before going further.
- Put both devices on the same Ethernet network and give each node an address from your plan.
- In Sysmac Studio, open the built-in EtherNet/IP port configuration and build the connection to the kit as the example project defines it: controller as scanner, kit as the scanned device, with the project's tag data link entries.
- Download the example project with its data mapping intact. Do not substitute guessed tag names or offsets; the blocks expect the mapping the project ships with.
- Bring the connection online and confirm the kit's data is updating in the controller before any command logic runs.
The four function blocks in the example project #
| Block | Role | Check at commissioning |
|---|---|---|
| SFK_Command | Sends commands to the SFK-P and returns status feedback. | Confirm the returned status tracks kit state before trusting any command result. |
| SFK_Fast_Variable_Access | Reads and writes SFK-P variables through the fieldbus data. | Confirm the variable and its direction before relying on a value. |
| SFK_SerialNumberConverter | Converts a string serial number into the format the kit recognizes. | Confirm the logic consumes the converted output, not the raw string. |
| SFK_GetNotification | Gets SFK-P status data from the fieldbus data. | Compare it with SFK_Command status whenever the two disagree. |
The blocks are thin wrappers over the mapped fieldbus data, which is why mapping comes before logic debugging: a running program can move the wrong data without complaint.
Commissioning checks #
One safety note first: this logic drives a press, so clear the tooling area and confirm the safeguarding is active before the first SFK_Command. Commissioning is not simulation.
- Issue a command through SFK_Command and watch the status feedback. Stale status is a connection or mapping fault, not a logic fault.
- Read kit status through SFK_GetNotification and compare it with what SFK_Command reports. If they disagree, compare the mapped data feeding each block before concluding the kit ignored anything.
- Exercise SFK_Fast_Variable_Access with a read first, then a write, and verify the write through the project's feedback path. A completed call proves execution, not exchange.
- If identification is part of the application, trace the serial-number string into SFK_SerialNumberConverter and confirm the converted value is what the logic sends.
If the connection never establishes at all, treat it as a scanner-side EtherNet/IP fault, the territory of Fixing a TwinCAT EtherNet/IP slave connection from an Omron PLC, and resolve it there before touching the kit or the press logic.
Questions asked
Why can't the NX controller's EtherCAT master reach the SFK-P?
Because the two EtherCAT implementations speak different application profiles. The Omron master addresses data as CoE objects; the kit exposes its data as SoE attributes, so the master has nothing coherent to read or write. This is a profile-level mismatch, not a configuration error, and the supported path for this pairing is EtherNet/IP.
Does the example project support other Omron controller families?
The project's stated compatibility covers NX, NJ and NY series controllers. For any other family, this integration path does not apply: plan a different controller or a separate integration effort, because no setting inside this project extends it to hardware it was not built for.
Is SFK_SerialNumberConverter required in every application?
No. The block converts a string serial number into the format the kit recognizes, so it earns its place only when identification data is part of your application. Commands, variable access and notifications run through the other three blocks without it.
What does it mean when SFK_Command executes but status never changes?
Treat it as a connection or mapping fault until proven otherwise. Check that the EtherNet/IP connection is online and that the status data mapped to the block is updating, then compare against what SFK_GetNotification reads. Only after both show stale data should you suspect the command logic.