def joinMovesBwd(self, moves):
if debugMoves:
print "***** Start joinMovesBwd() *****"
index = len(moves) - 1
# index = len(moves) - 2
# for move in revMoves[:-1]:
while index >= 0:
move = moves[index]
index -= 1
if debugMoves:
move.pprint("joinMovesBwd")
# Check, if breaking between startspeed and endspeed of
# move is possible with the given acceleration and within the
# given distance:
endSpeedS = move.getEndFr()
allowedAccel = move.getAllowedAccel()
maxAllowedStartSpeed = util.vAccelPerDist(endSpeedS, allowedAccel, move.distance)
if maxAllowedStartSpeed >= move.getStartFr():
# good, move is ok
continue
if debugMoves:
print "Startspeed of %.5f is to high to reach the desired endspeed." % move.getStartFr()
print "Max. allowed startspeed: %.5f." % maxAllowedStartSpeed
if move.lastMove:
#
# Adjust endspeed of the previous move, also.
#
factor = maxAllowedStartSpeed / move.getStartFr()
# print "factor: ", factor
# Adjust endspeed of last move:
assert(factor < 1)
if move.lastMove.streamed:
move.lastMove.pprint("error-streamed")
assert( not move.lastMove.streamed )
# XXX einfacher algo, kann man das besser machen (z.b. mit jerk-berechnung,
# vector subtraktion oder so?)
move.lastMove.setTrueEndFr(move.lastMove.getEndFr() * factor)
# Adjust startspeed of this move:
move.setTrueStartFr(maxAllowedStartSpeed)
if debugMoves:
print "***** End joinMovesBwd() *****"
def isIsolationMove(self, lastMove):
#
# Alle vorgänger-moves können weiterverarbeitet werden, falls lastMove (nicht move, der ist noch nicht
# fertig geplant) die folgenden bedingung erfüllt:
#
# Es kann innerhalb des moves von der startgeschwindigkeit auf Jerk/2 (xxx 0) gebremst werden. In diesem fall
# wird dann eine verringerung der endgeschwindigkeit von Miso KEINE auswirkung mehr auf die
# startgeschwindigkeit von Miso (und dadurch evtl auf seine vorgänger) haben.
#
#
allowedAccel = lastMove.getAllowedAccel()
startSpeedS = lastMove.getStartFr()
#
# Abbremsen auf 0 ist zwar hartes kriterium, aber das beeinflusst ja nicht
# die erreichten geschwindigkeiten, sonder nur das segmentieren und streamen
# der moves.
#
endSpeedS = 0 # min(self.jerk.mul(0.5).len3(), lastMove.getEndFr())
deltaSpeedS = endSpeedS - startSpeedS
# print "Start, End, delta:", startSpeedS, endSpeedS, deltaSpeedS
if abs(deltaSpeedS) > 0.001:
if deltaSpeedS > 0:
# beschleunigung, gültiger iso-move
return True
# bremsen
minEndSpeed = util.vAccelPerDist(startSpeedS, -allowedAccel, lastMove.distance)
# print "minEndSpeed:", minEndSpeed
if minEndSpeed > endSpeedS:
# es kann nicht gebremst werden
return False
# es kann auf jeden fall gebremst werden
return True
# ebenfalls iso-move, da start geschwindigkeit schon so niedrig ist.
return True
def joinTravelMovesBwd(self, moves):
if debugMoves:
print "***** Start joinTravelMovesBwd() *****"
index = len(moves) - 1
while index >= 0:
move = moves[index]
index -= 1
if debugMoves:
move.pprint("joinTravelMovesBwd")
# Check, if deceleration between startspeed and endspeed of
# move is possible with the given acceleration and within the
# given distance:
startSpeed1 = move.startSpeed.speed()
startSpeed1S = startSpeed1.feedrate5()
endSpeed1 = move.endSpeed.speed()
endSpeed1S = endSpeed1.feedrate5()
allowedAccel5 = move.getMaxAllowedAccelNoAdv5()
maxAllowedStartSpeed = util.vAccelPerDist(endSpeed1S,
allowedAccel5,
move.distance5)
# print "joinMovesBwd, startspeed, max startspeed: ", startSpeedS, maxAllowedStartSpeed
if maxAllowedStartSpeed >= startSpeed1S:
# Join speeds ok
continue
if debugMoves:
print "Startspeed of %.5f is to high to reach the desired endspeed." % startSpeed1S
print "Max. allowed startspeed: %.5f." % maxAllowedStartSpeed
# Adjust startspeed of this move:
startSpeed1.setSpeed(maxAllowedStartSpeed)
move.startSpeed.setSpeed(startSpeed1,
"joinTravelMovesBwd - breaking")
if move.prevMove:
#
# Adjust endspeed of the previous move, also.
#
factor = maxAllowedStartSpeed / startSpeed1S
# print "factor: ", factor
# Adjust endspeed of last move:
assert (factor < 1)
# XXX einfacher algo, kann man das besser machen (z.b. mit jerk-berechnung,
# vector subtraktion oder so?)
endSpeed0 = move.prevMove.endSpeed.speed().scale(factor)
move.prevMove.endSpeed.setSpeed(
endSpeed0, "joinMovesBwd - prevMove breaking")
if debugMoves:
print "***** End joinTravelMovesBwd() *****"
def planTravelPath(self, path):
if debugMoves:
print "***** Start planTravelPath() *****"
jerk = self.getJerk()
# Set startspeed of first move
path[0].setPlannedJerkStartSpeed(jerk, "planTravelPath() first move")
prevMove = path[0]
# Step 1: join moves forward
for move in path[1:]:
util.joinTravelMoves(prevMove, move, jerk)
prevMove = move
for move in path:
move.state = 1
# Check max endspeed of last move
# Set endspeed of last move
lastMove = path[-1]
# Max reachable speed of last move
allowedAccel5 = lastMove.getMaxAllowedAccelNoAdv5()
maxEndSpeed = util.vAccelPerDist(
lastMove.startSpeed.speed().feedrate5(), allowedAccel5,
lastMove.distance5)
v = lastMove.getJerkSpeed(jerk) or lastMove.topSpeed.speed()
endSpeed = lastMove.endSpeed.speed()
endSpeed.setSpeed(min(v.feedrate5(), maxEndSpeed))
lastMove.endSpeed.setSpeed(endSpeed, "planTravelPath() - last move")
"""
# Sanity check
for move in path:
move.sanityCheck(jerk)
"""
# Step 2: join moves backwards
self.joinTravelMovesBwd(path)
"""
# Sanity check
for move in path:
move.sanityCheck(jerk)
"""
# Step 3: plan acceleration
for move in path:
self.planTravelAcceleration(move)
# Sanity check
for move in path:
move.sanityCheck(jerk)
# Step 4: plan steps and stream moves to printer
if debugMoves:
print "Streaming %d travel moves..." % len(path)
for move in path:
self.planTravelSteps(move)
if debugMoves:
print "Streaming travel-move:", move.moveNumber
self.streamMove(move)
# Help garbage collection
move.prevMove = util.StreamedMove()
move.nextMove = util.StreamedMove()
if debugMoves:
print "***** End planTravelPath() *****"
