Send live axis position with ethercat to PLC < 12ms

What real world application requires external axis position update that is so fast?

After all it takes some time for axis to reach the target position and this is always boing to be THE bottleneck.

What is your PLC scan time? What is the real handshake logic? For example do you know in advance what the next target position will be?

If you are going to control the axis from Submit, this is always going to be tied to 12ms interpolation time regardless of used transport mechanism (fieldbus type).

EKI is slow.

RSI is faster

FSD is fastest but... It us only the one way (sends position from robot to external system, cannot send anything in the other direction).

Robot is too complex and too slow for direct control of the single axis. Power of robot is complex, coordinated and geometrically constrained motion of multiple axes.

If you want fast control of some simple axis, do not use robot, use own motion controller or perhaps a plc. Avoid fieldbus by connecting motor to your own servo drive. Then you can have sub millisecond turnaround time.

How fast do you need the control when plc is controlling the axis?

If you don't need it faster than those 12ms, you can go the other way round.

Connect the axis to the robot, when plc has to control it, set it to asynchronous, send the target values from plc to robot and control it from Sps.sub. This only works for external kinematics, not if you have a rail where the robot is mounted on.

Jm2c

Quote from sloopkogel

If the update only happens every 12ms the motion is 'stuttering' (for lack of a better word..),

Ah. Yeah, that's an issue when coupling different control loops with different update rates.

I'm not an expert in this field, but usually I see this resolved by giving the lower-level, faster control loop greater autonomy.

For example, in a KRC, the main processor only updates the servo amps every 12ms. However, those servo amps run an internal loop that is much faster. So the main process drops by, leaves a command that says "Move this direction, this fast, with this much acceleration", and leaves. The servo amp then carries out that instruction multiple times over the next 12ms, doing its own internal checking for following error, over-current, etc, then when the main process swings back by for an update, the servo amp hands over its most recent status report, and the main process says "okay, good, now change the destination/vel/accel by this much," and leaves again.

(I don't have to mention that I'm grossly oversimplifying here, do I?)

Your 12ms filter is a very basic application of this principle. Another thing to try might be to, every 12ms, take the new commanded position from the robot, subtract the actual position at that moment, divide the difference by 12, then have the PLC loop apply each 1/12 slice at 1ms intervals until the next PLC/robot handshake to get a new commanded position. Or build a PID loop in the PLC (which would probably require some degree of input filtering).

There's probably no way to eliminate that motion lag, but it's probably possible to reduce it below 12ms, with a nontrivial amount of coding and tuning. How far? That's a very parametric question.

you would be lucky to get 12ms. the update is slower than 12ms - always...

12ms is just the interpolation time of the Submit and it does not even account for spillovers due CPU quotas. on top of that there are other delays like fieldbus refresh.

if you need fast response, you need own servo drive controlled directly from the motion controller (without fieldbus, without submit..)

the async axis is meant for indexing positioner. there is no need to 'stream position profile' peace-meal to it - just give it the target position and trigger it. the motion profile will be calculated by the KSS.

btw, i do not recall seeing external axis (synchronous or not) where 12ms made any meaningful difference since positioning of the axis takes orders of magnitude longer to complete. from cycle time perspective that is simply insignificant. setting load correctly, tuning axis, planning motion, buffering data etc. allows for much greater optimization.