Where is the difference - 10 times X1 vs 1 times X10

arhi

@gtj0 said in Where is the difference - 10 times X1 vs 1 times X10:

Acceleration and jerk are applied to each move. The firmware would have to read ahead to optimize that and that's not always possible nor would the optimization algorithm be trivial.

In this particular case, yes, if you send 100 times G1 from console with break between them it will do 100 moves with accel, travel, decel; but if this is in gcode file you are executing it's actually firmware's job to read ahead, see that it's moving in same direction at same speed so that deceleration is not required nor that there is any jerk so 100 times G1 should be executed 100% identical as single G1 doing the same move. I have not tested this with RRF, always assumed it works like that, but I did test this with number of cnc controllers (mach3, linuxcnc...) and they behave exactly like that (assuming relative moves in the op's example), I doubt RRF would behave differently

arhi

@ChrisP said in Where is the difference - 10 times X1 vs 1 times X10:

Because its not the machines/firmwares job to do such optimisation. That's the slicers task.

Actually, no. It is controller's task (RRF in this case). It is firmware that decides how to perform the move and by looking ahead knows that there will be no change in direction/speed so no need to decelerate till the final move. Yes, slicer in 3D printing application should not generate such code but that's irrelevant, if it does the firmware needs to handle it properly. The only issue with this type of code with 8bit boards is the memory size and cpu speed so having this many short moves can overload the parser and the planner so it can be slow for that reason but it should not be a problem with 32bit controllers

JBisc

@arhi I share arhi's opinion. That could the job of the firmware to avoid these unnessesary decelerations.

ChrisP

It think it's a matter of wording here. Should the firmware be able to execute the commands given accurately - yes!
Optimisation implies that the firmware should be able to see (in this case) a series of G1 X1, recognise what's happening and convert it into G1 X100, for example. So I maintain that no, the slicer should optimise and the firmware should execute the commands correctly as if whatever had generated the gcode had optimised it.

Danal

@ChrisP said in Where is the difference - 10 times X1 vs 1 times X10:

accurately

Very interesting word when it comes to motion control.

G1 X0     Y0
G1 X100   Y0
G1 X100   Y100

In a world where machines have inertia, the only way to execute line 2 and 3 of the above 'accurately' is to come to a full stop at the end of line 2. All motion planners that look ahead use various approximations to go around that corner, and can be tuned with acceleration, jerk, or good ol Mach 3 even had a way to 'turn off' what they called 'constant velocity' when a change of angle exceeded a configurable value.

All such tuning trades time-to-cut vs accuracy-at-direction-changes. Regardless of which motion planner is involved. I remember tuning mach to make visually decent shapes in a particular cut, and seeing cut time (for about 100 repeats, on a 24 x 48 sheet of material) vary from one hour to as much a four hours, depending on all those settings. Unfortunately the one hour cuts were unusable.

Better motion planners to a better job of direction changes, and/or are more tune-able.

Anyway...

The point being that experimentation with repeated G1 X1 vs G1 X20 vs G1 X50, etc, etc, are well warranted. FROM A FILE. Only.

arhi

@ChrisP that example firmware should execute exactly the same move (10x X1 vs 1x X100), no "replacement" need to take place, that should just be normal behavior of the firmware. And yes, as danal said, from a file only, if you execute that from console there is no way to do look ahead

arhi

@Danal ah, the cornering is the everlasting story but I don't think it applies to op's question. What is better, how to do it better, what works for milling, what works for laser, what works for FDM ... not the same things for sure, and even identically named algorithms in different controllers work differently, let alone different algorithms for same thing :). But what OP asked, as you too agree if I understood you correctly, the firmware will execute an identical move in both cases assuming it's reading from a file and not getting it from the console with pauses (the way RRF put stuff in queue IIRC even from the console if sent fast enough look ahead will work).

I'm still hoping slicers will start to use G2/G3. The work Brad (formerlurker) put into that plugin is great. I hope some slicer maker will hire him to embed that into it, so far it is very promissing.

Danal

I agree that moving in a straight line seems as though it would involve none of the cornering effects. So X10 twenty times should be the same as X200.

However... that's us as humans. The various algorithms are going to look ahead and calculate the 'juncture' and they will absolutely calculate the angle as zero... but, that may or may not mean all that much. Still could be undesired differences.

And let me be clear: I absolutely don't know what any of the planners are going to do with a zero angle juncture, much less what Duet specifically does. That's why the experiments...

Danal

Just for a super quick test, I ran the following on a CoreXY:

G1 X10 Y10 F10000
G91
G1 X10
... repeat enough times to move 300...
G90 
G1 Y20
G1 X10

So 30 G1 X10 moves relative moves for 300mm, then a sidestep to force two 90 degree corners on the planner, and then a single move 300mm back. All at F10000 , roughly 167mm/sec.

Listening to this, each move sounds IDENTICAL.

Then ran:

G1 X10 Y10 F10000
G91
G1 X1
... repeat enough times to move 300...
G90 
G1 Y20
G1 X10

That is 300 individual X1 moves.

This was interesting. Started the same, then sagged, badly, then dipped even more, then came back up just a little and finished with less change, but VERY clearly slowed down, maybe half, from the single long moves or the X10 moves.

Not scientific, but VERY clear.

Duet 3 + Pi, running RC8 and DSF 2.0.0

arhi

@Danal I would call that a bug ... I'm some ~12 hours to finish the print and will check myself on the cartesian

I'm not familiar with RRF source yet but for e.g. if you look how smoothieware (the one I am kinda familiar with) does it if the angle between the lines is less than ~1 degree ( cos(theta) +-0.95 ) it will not at all calculate junction deviation, no deceleration, it will go through the junction full speed; If the angle is larger than ~1 degree then corner speed is approx
sqrt( acceleration * junction_deviation * sin_theta / (1.0 - sin_theta))

there used to be a bug, don't remember if in this calculation or another one where the calculation was not done only if the angle was zero but floating point is ugly about zero so this was changed to be larger value

(EDIT: I see they changed this to 0.9999 cos(theta) some years ago )

ChrisP

@arhi said in Where is the difference - 10 times X1 vs 1 times X10:

@ChrisP that example firmware should execute exactly the same move (10x X1 vs 1x X100), no "replacement" need to take place, that should just be normal behavior of the firmware.

Yup, we agree then.

@Danal Interesting test. And agree that is a bug. Are you able to try it standalone without the Pi? It's also be interesting to try at slower feedrates to see it there's a limit.

deckingman

Out of curiosity, I can't imagine a scenario where a slicer would generate multiple segmented moves for what would be a single, longer move. So what are the circumstances where such multiple, short, single axis, segmented moves would need to be accomplished? Does CAD software generate such moves and if so why?

dc42

It's a question of throughput. A lot of work has to be done to process each of those G1 X1 commands, and there is a limit to the rate at which the Duet+firmware can read and process a long run of them and stitch them together.

There is also a limit to the length of the movement queue, and all the time the firmware has to allow for the possibility that it may have to decelerate to zero speed when it reaches the end of the queue, because there may be no more moves. On Duet 3 the movement queue is 60 moves long. So with 1mm long moves, the speed won't exceed sqrt(2 * 60 * A) where A is the configured X acceleration.

DaBit

I am not aware of CAM-software that generates such moves. However, just like slicers they might generate short line segment code. Deskproto does that, Fusion360 does that too in some circumstances (user error, that is). LinuxCNC has a special path following setting called 'the naive CAM detector' to cope with that.

I like LinuxCNC's method; they replace part of adjacent line segments with a tangent arc. Allows nice and smooth fullspeed traversal of splines chopped into many short segments without violating acceleration constraints.

DocTrucker

The slicer is about generating paths. In my opinion the machine should deal with as much machine specific stuff as possible. I would say gold standard is to be able to take a build file and run it on any machine. This of course means slicing and path generation on the machine which would of course allow much better control over segmentation.

This is a good use case for a python parsing script running on the single board computer as there are also issues from making the vectors/segmentation too large. This is a machine level problem that needs to be delt with as close to the coal face as possible, as that is where the information on instant speed, junction deviation, acceleration or intergrals/derivatives thereof reside.

@deckingman many perfectly straight vectors are unlikely but I've seen plenty of instances where contours around a curved feature have been broken down into hundreds, if not thousands of submicron length vectors with only a tiny angle between them.

dc42

@DocTrucker said in Where is the difference - 10 times X1 vs 1 times X10:

@deckingman many perfectly straight vectors are unlikely but I've seen plenty of instances where contours around a curved feature have been broken down into hundreds, if not thousands of submicron length vectors with only a tiny angle between them.

Most slicers are aware of the limitations of GCode throughput, which is of course worse on older electronics and much worse when printing over USB on older electronics; so they have a minimum length of output segment. If you produce a curved object (e.g. cylinder) with very tiny segments in the STL file, the slicer will attempt to combine segments until the minimum segment length is reached.

If users hit the GCode throughput limit on real prints, then I'm willing to look at improving it.

DocTrucker

@dc42 that's logical, you need not fix a 'problem' until it presents itself in a real world example. I had plenty of cases presented to me that were obscure and twisted scenarios to demonstrate 'a serious problem' which were nothing of the sort. More a weakness under certain circumstances that operators needed to be aware of until the point where all the bigger issues had been resolved and the less frequent issues could be tackled.

I do think this sort of problem is best dealt with on the computer - rather than the controller - as there is no need for this to be done real time.

gloomyandy

I wonder how klipper would handle this? In theory it should be able to use a much longer gcode queue. Similarly I suppose the the SBC version of RRF could in theory pre-process the gcode inside of dsf to merge the line segments. Whether it is worth it or not is of course another question.

On a related note, is there a description anywhere of what processing of gcode is performed by dsf (if any)?

dc42

On Duet 3 we have enough RAM to use a longer queue too. However, we limit the number of moves in the queue to 2 seconds of moves + 1 move, to prevent pauses being delayed too much in the event that we can't schedule a pause between moves already in the queue.

arhi

@dc42 said in Where is the difference - 10 times X1 vs 1 times X10:

If users hit the GCode throughput limit on real prints, then I'm willing to look at improving it.

I tested some rather "bad" g-code generated by s3d from "too precise" stl that would kill octoprint+marlin combo (stutters, blobs, crazy bad print quality), and sometimes even marlin from sd card without octoprint and duet ate it without a problem printed it perfectly (duet2eth, 3.01RC1) so I don't think RRF is anywhere close to the problem here