org.openpnp.model

Class AbstractMotionPath

java.lang.Object

org.openpnp.model.AbstractMotionPath

All Implemented Interfaces:

java.lang.Iterable<MotionProfile[]>

Direct Known Subclasses:

ReferenceAdvancedMotionPlanner.PlannerPath

public abstract class AbstractMotionPath
extends java.lang.Object
implements java.lang.Iterable<MotionProfile[]>

Field Summary

Fields

Modifier and Type	Field and Description
protected static int	segments

Constructor Summary

Constructors

Constructor and Description
AbstractMotionPath()

Method Summary

Modifier and Type	Method and Description
protected static boolean	controlOvershoot(MotionProfile[] prevProfiles, MotionProfile[] entryProfiles, MotionProfile[] exitProfiles, MotionProfile[] nextProfiles, int axis, MotionProfile solverProfile, double approximation, int iteration) Helper for the optimizer: reduces excess overshoot into uncoordinated moves.
abstract MotionProfile[]	get(int i)
java.util.Iterator<MotionProfile[]>	iterator()
abstract int	size()
void	solve()
void	solve(double approximation, int iterations) Simplified "PnP use case" heuristics for continuous smoothed motion path optimization.
void	toSvg(java.lang.String title, double zr)
void	validate(java.lang.String title) Validate the path for seamless continuity.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Field Detail

segments

protected static final int segments

See Also:

Constant Field Values

Constructor Detail

AbstractMotionPath

public AbstractMotionPath()

Method Detail

size

public abstract int size()

get

public abstract MotionProfile[] get(int i)

iterator

public java.util.Iterator<MotionProfile[]> iterator()

Specified by:

iterator in interface java.lang.Iterable<MotionProfile[]>

solve

public void solve()
           throws java.lang.Exception

Throws:

java.lang.Exception

solve

public void solve(double approximation,
                  int iterations)
           throws java.lang.Exception

Simplified "PnP use case" heuristics for continuous smoothed motion path optimization.

The solver can find a partially optimized path for the typical moveToLocationAtSaveZ() moving pattern of OpenPnP. It will gracefully revert to unoptimized moving when confronted with more complex motion sequences.

Moves are distinguished to be coordinated or not. A coordinated move follows a strict straight line from A to B while an uncoordinated moves may stray from that line to allow for a more smoothed-out motion. OpenPnP will handle all below Safe Z moves as coordinated, while handling everything within the Safe Z zone as uncoordinated.Code may override this default heuristic.

Subsequent straight coordinated moves are combined into one. Coordinated moves will overshoot into uncoordinated moves to smooth the path. The path is then iteratively refined to reduce overshooting where it is wasteful. However this is done in a very crude form with very few iterations to keep computation times useful. Subsequent uncoordinated moves are not yet optimized, i.e. corners are not smoothed-out. These moves are rare in OpenPnP.

The heuristics works as follows:

1. Path begin/end and corners between subsequent coordinated moves are handled as zero speed and acceleration junctions.
2. Multiple subsequent co-linear moves are solved as one overall move with the most restrictive limits applied. Each partial move is then cut out from the overall profile. TODO: Moves which reach the most restrictive V max at one or both ends are re-solved with their proper V max, if higher (this is not 100% optimal but not so bad for practical use cases).
3. Coordinated moves that are followed by an uncoordinated move are handled in two ways:
   a) if there is an applicable s limit, the move is handled as if it extends to the limit and then cropped
   b) if there is no applicable s limit, the move is handled as half-sided profile and then extended or cropped.
4. Coordinated moves that are preceded by an uncoordinated move are handled as in 3. (in reverse).
5. Coordinated moves that are both preceded and followed by an uncoordinated move are left unoptimized at the moment.

Parameters:

approximation - Determines by what rate it should approximate the estimated best solution, per iteration.

iterations - How many iterations should be computed.

Throws:

java.lang.Exception

controlOvershoot

protected static boolean controlOvershoot(MotionProfile[] prevProfiles,
                                          MotionProfile[] entryProfiles,
                                          MotionProfile[] exitProfiles,
                                          MotionProfile[] nextProfiles,
                                          int axis,
                                          MotionProfile solverProfile,
                                          double approximation,
                                          int iteration)

Helper for the optimizer: reduces excess overshoot into uncoordinated moves. This is a simple heuristic controlled by excess time detected in the uncoordinated move. Excess time is assumed when the move takes longer that the straight line move from/to still-stand.

validate

public void validate(java.lang.String title)
              throws java.lang.Exception

Validate the path for seamless continuity.

Parameters:

title -

Throws:

java.lang.Exception

toSvg

public void toSvg(java.lang.String title,
                  double zr)