Advanced Search

Thanks, Rod, for your fast answer.

I have a general question regarding following error (FERROR) when controlling servo drives via EtherCAT.

Is there a generally expected/inevitable following error caused by the EtherCAT cycle time (latency/jitter), even in a properly configured system?
Or would a noticeable following error usually indicate a configuration/implementation issue?

For reference: my servos are tuned and run with a very small following error of about 20 encoder counts in the Delta software (24-bit encoder, so basically negligible).
However, in LinuxCNC the reported following error increases with speed and can reach about 1–2 mm.

What would be a typical/acceptable following error range in a properly configured EtherCAT servo system? Any ideas?

rodw wrote:

I thought jerk limiting was purely about acceleration. To extend it to varying the path seems to me is really scope creep. Get it working without changing the path and include path optimisations at a future time and write better gcode for now.

jerk limiting may permit higher maximum acceleration. Currently MAX_ACELERATION is set from a combination of motor dynamics and physics by the machine builder Eg the inertia in a heavy moving table may require a lower acceleration than what the motors are capable of so they are not overcome by inertia on deceleration and cause following errors. Its probably valid on a jerk limited machine to increase acceleration. In this context, some violations may be valid.

Absolutely correct. 
It is a constant fight to keep people from mixing jerk - 3rd order motion - with G64 constant velocity algorithms. These are 2 entirely independent topics and should be kept as such.

One thing I also keep seeing is the idea you just "augment" the existing trajectory for jerk limiting - rounding corners and such. This is not gonna be the route to success. Jerk (snap, crackle, pop - yes those are the real terms) needs to be in the core motion planning with velocity and acceleration.

grandixximo wrote:

You cannot maintain velocity, follow the exact programmed path, AND have smooth jerk.

This is physically impossible. What I am saying is I would sacrifice velocity rather than programmed path on G2/G3 programmed arcs. At the moment if you run something with tangent arcs even with G61 the velocity is kept, this messes with jerk. G61 with jerk will have to slow down more.
For many line segments G64 Pxx it also slow down more, the more tight the tolerance, the smaller blending arcs the slower you have to move.
Béziers will give you better speed, because you can run them faster, but they are NOT arcs, meaning when you program a square for example, just 4 lines, you set G64 to 0.5 let's say, what kind of path error would you accept? A 0.5mm perfect radius which I have to slow down more to make smooth, or a squashed up Béziers which I can run faster?

Considering option 2, your set your priorities.

So for example the P value says you need to stay within 0.001mm, then that is your upper restriction for corner rounding, no matter what method you use. your lower restriction is then velocity.

So if I'm taking a corner at 20m/m and my p value and acceleration/jerk values mean I need to slow down, I need to slow down. HOWEVER, if I am taking the same corner with the same p value but only moving 1m/m then the p value is reduced until we hit 1m/m. You do NOT automatically round all corners up to the P value (something i think grotius' version did).

But like I said, I would focus on option 1, and when that work, fully, completely, bug free, we can look towards a new ground up TP with multiple jerk limited constant velocity strategies and more advanced look ahead (which is kinda what tormach did for the 1500).

The brother speedio C00 is a good example to look at. They have SEVERAL constant velocity modes you can choose in g code depending on the operation. some hold tighter paths for finishing, others hold higher speeds for roughing.

Another one to look at is fanuc and siemens, who use spline fitting.

But like is said, this should not be the focus right now. This is phase 2.


 

What I mean it it becomes development hell and the project dies, and it is the least critical part of the system we need.

Sure, it is absolutely what we want in the end, but getting there is just not happening.

Option 1 is likely a completable project and "good enough for now".

Peter at Mesa has had the XY2-100 galvo protocol working for quite some time:

forum.linuxcnc.org/additive-manufacturin...ead-protocol-xy2-100

Doesn't use LCNC but it could be easily converted with little effort: sls4all.com/  
It currently uses Klipper.

This project got delayed due to some health issues. Ask away for tech questions.

Using PNCconf – the Mesa card configuration wizard, you can complete the configuration.

7I97 config for 7I89 daughtercard:

 

 

 

The PKTUART pins are on the two RS-485 capable 7I52 channels (the ones with TX Enables)

 

Jerk limit to the point of seeing your machine move sluggishly? Béziers are Just to be able to get better cornering speeds, because tangent arcs are not optimal for covering with jerk limit.
Scope of planner type 1 is jerk limit to a crawl if necessary? Like the 0.0001 G2 curves that ruediger123 shared. Done with small G64P tolerance, I agree those should just slow down as much as you need to follow path within tolerance, BUT for a square with NO programmed corners, blend with arcs and parabolas are acceptable? Just slow down as much as we need to follow the blend arc? Point cloud line to line is another issue, slow down to keep everything smooth? but then you will see the machine smoothly follow your point cloud, but it will speed up and slow down, speed up and slow down, because we are not trying to maintain velocity, we are sacrificing it, and because we work mostly segment by segment, I don't see an easy way out, Béziers could give us a better path, but we will need to figure out where and how to stitch them smoothly. and how to do it while the machine is in execution, we can't plan the whole thing offline.

Greetings,

I too have a fc01 and have just started to try rs485. I have had no luck using the python code supplied from the manufacturer. One inconsistency that i noticed in their code as well as the code in this thread is:

The parameter is set P14.02 = 0 , from the manual p64 this is "0: No check (N,8,1)for RTU" but in the code above parity is specified as E.

Sorry if I have missed something. Thanks bruce

I will to get your python working on my pi5 or my desktop.

After a quick look it seems the deasda driver includes a layer that kind of resembles the cia402 driver.
The drive itself is cia402.
deasda gives a large set of hal pins, with "generic" and cia402 one needs to puzzle that together self.

These drivers don't do very much more than translate between pdos and hal names, there is no real processing.
Some logic is in there, but there is no performance reason to select one or the other.


 

Wow, You are amazing Thank You .Drive is communicating with LCNC.
Next step is to create proper config.I will do an update in a few days.

Yes, now understandable.
You see the problem? lcec.0.0.cia-statusword
Numbering is lcec.<master id>.<slave id>.variable-name
Your slave id is number 1, at least that's what it says in ethercat-conf.xml
Must match numbering from "ethercat slaves"

OK I hope that now is much more clear, thanks.