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() *****"