def manualMove(parser, axis, distance, feedrate=0, absolute=False):
planner = parser.planner
printer = planner.printer
printer.sendPrinterInit()
assert(printer.isHomed())
# Get current pos from printer and set our virtual pos
getVirtualPos(parser)
if not feedrate:
feedrate = PrinterProfile.getMaxFeedrate(axis)
current_position = parser.getRealPos()
if absolute:
d = distance - current_position[A_AXIS]
assert(abs(d) <= 1000)
parser.execute_line("G0 F%d %s%f" % (feedrate*60, dimNames[axis], distance))
else:
assert(abs(distance) <= 1000)
parser.execute_line("G0 F%d %s%f" % (feedrate*60, dimNames[axis], current_position[axis] + distance))
planner.finishMoves()
printer.sendCommand(CmdEOT)
# time.sleep(1)
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.waitForState(StateIdle)
printer.readMore(10)
def changeNozzle(args, parser):
planner = parser.planner
printer = planner.printer
retract(args, parser, doCooldown = False)
feedrate = PrinterProfile.getMaxFeedrate(X_AXIS)
execSingleGcode(parser, "G0 F%d X%f Y%f" % (feedrate*60, planner.MAX_POS[X_AXIS]/2, planner.MAX_POS[Y_AXIS]*0.1))
raw_input("Now change nozzle, Press return to stop heating...")
execSingleGcode(parser, "G11")
if not args.noCoolDown:
printer.coolDown(HeaterEx1, wait=100)
def g11_retract_recover(self, line, values):
# print "g11_retract_recover", values
current_position = self.getPos()
rl = PrinterProfile.getRetractLength()
current_position[A_AXIS] += rl
self.planner.addMove(
TravelMove(line,
displacement_vector=Vector([0.0, 0.0, 0.0, rl, 0.0]),
displacement_vector_steps=[
0.0, 0.0, 0.0, rl * self.steps_per_mm[A_AXIS], 0.0
],
feedrate=min(PrinterProfile.getRetractFeedrate(),
PrinterProfile.getMaxFeedrate(3))))
self.setPos(current_position)
def zRepeatability(parser):
import random
printer.commandInit(args)
feedrate = PrinterProfile.getMaxFeedrate(Z_AXIS)
ddhome.home(parser, args.fakeendstop)
printer.sendPrinterInit()
for i in range(10):
parser.execute_line("G0 F%d X115 Y210 Z10" % (feedrate*60))
parser.execute_line("G0 F%d Z%f" % (feedrate*60, random.randint(20, 150)))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle)
def removeFilament(args, parser):
planner = parser.planner
printer = planner.printer
printer.commandInit(args)
ddhome.home(parser, args.fakeendstop)
printer.sendPrinterInit()
# Move to mid-position
# MAX_POS = (X_MAX_POS, Y_MAX_POS, Z_MAX_POS)
# feedrate = PrinterProfile.getMaxFeedrate(Z_AXIS)
# parser.execute_line("G0 F%d Z%f" % (feedrate*60, MAX_POS[Z_AXIS]))
feedrate = PrinterProfile.getMaxFeedrate(X_AXIS)
parser.execute_line("G0 F%d X%f Y%f" % (feedrate*60, planner.MAX_POS[X_AXIS]/2, planner.MAX_POS[Y_AXIS]/2))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle)
t1 = MatProfile.getHotendBaseTemp()
printer.heatUp(HeaterEx1, t1, wait=t1)
# Etwas vorwärts um den retract-pfropfen einzuschmelzen
manualMove(parser, A_AXIS, PrinterProfile.getRetractLength() + 5, 5)
manualMove(parser, A_AXIS, -1.3*FILAMENT_REVERSAL_LENGTH)
if not args.noCoolDown:
printer.coolDown(HeaterEx1,wait=150)
def home(parser, fakeHomingEndstops=False, force=False):
planner = parser.planner
printer = planner.printer
print "*"
print "* Start homing..."
print "*"
if printer.isHomed() and not force:
print "Printer is homed already..."
# Send init command
printer.sendPrinterInit()
# Get current pos from printer and set our virtual pos
curPosMM = util.getVirtualPos(parser)
(homePosMM, homePosStepped) = planner.getHomePos()
# print "Printer should be at [mm]: ", homePosMM, ", [steps]: ", homePosStepped
# Move to home
if not curPosMM.equal(homePosMM, "XYZ"):
#
# Z Achse isoliert und als erstes bewegen, um zusammenstoss mit den klammern
# der buildplatte oder mit objekten auf der druckplatte zu vermeiden.
#
if not curPosMM.equal(homePosMM, "Z"):
parser.execute_line("G0 F%d Z%f" % (
PrinterProfile.getMaxFeedrate(util.Z_AXIS)*60, homePosMM.Z))
if not curPosMM.equal(homePosMM, "XY"):
parser.execute_line("G0 F%d X%f Y%f" % (
PrinterProfile.getMaxFeedrate(util.X_AXIS)*60,
homePosMM.X, homePosMM.Y))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle, wait=0.05)
#
# Set Virtual E-pos 0:
#
parser.set_position(homePosMM)
print "*"
print "* Done homing..."
print "*"
return
#
# Z Achse isoliert und als erstes bewegen, um zusammenstoss mit den klammern
# der buildplatte oder mit einem modell zu vermeiden.
#
for dim in [util.Z_AXIS, util.X_AXIS, util.Y_AXIS]:
# Try fast home if endstop is pressed
if printer.endStopTriggered(dim, fakeHomingEndstops):
print "Homing: endstop %d is triggered, trying fast home." % dim
if homeBounce(parser, dim, fakeHomingEndstops):
continue
# Try fast home if head/bed is near the endstop
print "Homing: doing short/fast home."
if homeMove(parser, dim, 1, planner.MAX_POS[dim] / 10.0, fakeHomingEndstops): # Move towards endstop fast
print "Homing: endstop %d is triggered, trying fast home." % dim
if homeBounce(parser, dim, fakeHomingEndstops):
continue
# Do the full slow homing move
print "Homing: doing full/slow home."
if not homeMove(parser, dim, 1, planner.MAX_POS[dim] * 1.25, fakeHomingEndstops): # Move towards endstop fast
print "Error, Endstop %d NOT hit!" % dim
assert(0)
if not homeBounce(parser, dim, fakeHomingEndstops):
print "Error, Bounce %d!" % dim
assert(0)
#
# Set position in steps on the printer side and set our 'virtual position':
#
# xxx set end-of-print retraction e-pos also here?
#
# parser.set_position(planner.homePosMM)
# payload = struct.pack("<iiiii", *planner.homePosStepped)
(homePosMM, homePosStepped) = planner.getHomePos()
parser.set_position(homePosMM)
# print "Tell printer its position [steps]:", homePosStepped
payload = struct.pack("<iiiii", *homePosStepped)
printer.sendCommand(CmdSetHomePos, binPayload=payload)
print "*"
print "* Done homing..."
print "*"
def home(parser, fakeHomingEndstops=False, force=False):
planner = parser.planner
printer = planner.printer
print "*"
print "* Start homing..."
print "*"
if printer.isHomed() and not force:
print "Printer is homed already..."
# Send init command
printer.sendPrinterInit()
# Get current pos from printer and set our virtual pos
curPosMM = util.getVirtualPos(parser)
(homePosMM, homePosStepped) = planner.getHomePos()
# print "Printer should be at [mm]: ", homePosMM, ", [steps]: ", homePosStepped
# Move to home
if not curPosMM.equal(homePosMM, "XYZ"):
#
# Z Achse isoliert und als erstes bewegen, um zusammenstoss mit den klammern
# der buildplatte oder mit objekten auf der druckplatte zu vermeiden.
#
if not curPosMM.equal(homePosMM, "Z"):
parser.execute_line(
"G0 F%d Z%f" %
(PrinterProfile.getMaxFeedrate(util.Z_AXIS) * 60,
homePosMM.Z))
if not curPosMM.equal(homePosMM, "XY"):
parser.execute_line(
"G0 F%d X%f Y%f" %
(PrinterProfile.getMaxFeedrate(util.X_AXIS) * 60,
homePosMM.X, homePosMM.Y))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle, wait=0.05)
#
# Set Virtual E-pos 0:
#
parser.setPos(homePosMM)
print "*"
print "* Done homing..."
print "*"
return
#
# Z Achse isoliert und als erstes bewegen, um zusammenstoss mit den klammern
# der buildplatte oder mit einem modell zu vermeiden.
#
for dim in [util.Z_AXIS, util.X_AXIS, util.Y_AXIS]:
# Try fast home if endstop is pressed
if printer.endStopTriggered(dim, fakeHomingEndstops):
print "Homing: endstop %d is triggered, trying fast home." % dim
if homeBounce(parser, dim, fakeHomingEndstops):
continue
# Try fast home if head/bed is near the endstop
print "Homing: doing short/fast home."
if homeMove(parser, dim, 1, planner.MAX_POS[dim] / 10.0,
fakeHomingEndstops): # Move towards endstop fast
print "Homing: endstop %d is triggered, trying fast home." % dim
if homeBounce(parser, dim, fakeHomingEndstops):
continue
# Do the full slow homing move
print "Homing: doing full/slow home."
if not homeMove(parser, dim, 1, planner.MAX_POS[dim] * 1.25,
fakeHomingEndstops): # Move towards endstop fast
print "Error, Endstop %d NOT hit!" % dim
assert (0)
if not homeBounce(parser, dim, fakeHomingEndstops):
print "Error, Bounce %d!" % dim
assert (0)
#
# Set position in steps on the printer side and set our 'virtual position':
#
# xxx set end-of-print retraction e-pos also here?
#
# parser.setPos(planner.homePosMM)
# payload = struct.pack("<iiiii", *planner.homePosStepped)
(homePosMM, homePosStepped) = planner.getHomePos()
parser.setPos(homePosMM)
# print "Tell printer its position [steps]:", homePosStepped
payload = struct.pack("<iiiii", *homePosStepped)
printer.sendCommand(CmdSetHomePos, binPayload=payload)
print "*"
print "* Done homing..."
print "*"
def bedLeveling(args, parser):
planner = parser.planner
printer = planner.printer
printer.commandInit(args)
# Reset bedlevel offset in printer eeprom
payload = struct.pack("<%dpf" % (len("add_homeing_z")+1), "add_homeing_z", 0)
printer.sendCommand(CmdWriteEepromFloat, binPayload=payload)
ddhome.home(parser, args.fakeendstop, True)
zFeedrate = PrinterProfile.getMaxFeedrate(Z_AXIS)
kbd = GetChar("Enter (u)p (d)own (U)p 1mm (D)own 1mm (2-5) Up Xmm (q)uit")
def manualMoveZ():
current_position = parser.getRealPos()
zofs = current_position[Z_AXIS]
print "curz: ", zofs
ch = " "
while ch not in "q\n":
ch = kbd.getc()
print "ch: ", ch
if ch == "u": # head down, 'small' step
zofs -= 0.05
elif ch == "U": # head down, 'big' step
zofs -= 1
elif ch == "d": # head up, 'small' step
zofs += 0.05
elif ch == "D": # head up, 'big' step
zofs += 1
else:
try:
o = int(ch) # up x mmm
except ValueError:
continue
if o < 2 or o > 5:
continue
zofs -= o
printer.sendPrinterInit()
parser.execute_line("G0 F%d Z%f" % (zFeedrate*60, zofs))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle, wait=0.1)
feedrate = PrinterProfile.getMaxFeedrate(X_AXIS)
#######################################################################################################
print "Level point 1/3"
printer.sendPrinterInit()
parser.execute_line("G0 F%d X%f Y%f Z%f" % (feedrate*60, planner.X_MAX_POS/2, planner.Y_MAX_POS - 10, planner.HEAD_HEIGHT))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle, wait=0.1)
manualMoveZ()
current_position = parser.getRealPos()
print "curz: ", current_position[Z_AXIS]
add_homeing_z = -1 * current_position[Z_AXIS];
print "\nZ-Offset: ", add_homeing_z, "\n"
# Store into printer eeprom:
payload = struct.pack("<%dpf" % (len("add_homeing_z")+1), "add_homeing_z", add_homeing_z)
printer.sendCommand(CmdWriteEepromFloat, binPayload=payload)
# Finally we know the zero z position
# current_position[Z_AXIS] = 0
current_position[Z_AXIS] = planner.LEVELING_OFFSET;
# Adjust the virtual position
parser.set_position(current_position)
# Adjust the printer position
posStepped = vectorMul(current_position, parser.steps_per_mm)
payload = struct.pack("<iiiii", *posStepped)
printer.sendCommand(CmdSetHomePos, binPayload=payload)
#######################################################################################################
print "Level point 2/3", current_position
printer.sendPrinterInit()
parser.execute_line("G0 F%d Z5" % (zFeedrate*60))
parser.execute_line("G0 F%d X35 Y20" % (feedrate*60))
parser.execute_line("G0 F%d Z0.1" % (zFeedrate*60))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle, wait=0.1)
raw_input("\nAdjust left front buildplate screw and press <Return>\n")
#######################################################################################################
print "Level point 3/3", current_position
printer.sendPrinterInit()
parser.execute_line("G0 F%d Z5" % (zFeedrate*60))
parser.execute_line("G0 F%d X%f" % (feedrate*60, planner.X_MAX_POS-10))
parser.execute_line("G0 F%d Z0.1" % (zFeedrate*60))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle, wait=0.1)
raw_input("\nAdjust right fron buildplate screw and press <Return>\n")
ddhome.home(parser, args.fakeendstop)
def insertFilament(args, parser):
planner = parser.planner
printer = planner.printer
def manualMoveE():
current_position = parser.getRealPos()
aofs = current_position[A_AXIS]
print "cura: ", aofs
kbd = GetChar("Enter (f)orward (b)ackwards (F)orward 10mm (B)ackwards 10mm (q)uit")
ch = " "
while ch not in "q\n":
ch = kbd.getc()
print "ch: ", ch
if ch == "f": # filament forward, 'small' step
aofs += 1
elif ch == "F": # filament forward, 'big' step
aofs += 10
elif ch == "b": # filament backwards, 'small' step
aofs -= 1
elif ch == "B": # filament backwards, 'big' step
aofs -= 10
printer.sendPrinterInit()
# XXX hardcoded feedrate
parser.execute_line("G0 F%d A%f" % (5*60, aofs))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle, wait=0.1)
commonInit(args, parser)
# Move to mid-position
feedrate = PrinterProfile.getMaxFeedrate(X_AXIS)
parser.execute_line("G0 F%d X%f Y%f" % (feedrate*60, planner.MAX_POS[X_AXIS]/2, planner.MAX_POS[Y_AXIS]/2))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle)
t1 = MatProfile.getHotendBaseTemp()
printer.heatUp(HeaterEx1, t1, wait=t1 - 5)
print "\nInsert filament.\n"
manualMoveE()
print "\nForwarding filament.\n"
manualMove(parser, A_AXIS, FILAMENT_REVERSAL_LENGTH * 0.85)
print "\nExtrude filament.\n"
manualMoveE()
#
# Retract
#
printer.sendPrinterInit()
parser.execute_line("G10")
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle)
if not args.noCoolDown:
printer.coolDown(HeaterEx1, wait=150)
def measureTempFlowrateCurve(args, parser):
def writeDataSet(f, dataSet):
for dataStr in dataSet:
f.write(dataStr)
f.write("\n")
f.write("E\n")
fssteps_per_mm = 265.0 # xxx hardcoded, get from profile or printer...
planner = parser.planner
printer = planner.printer
printer.commandInit(args)
ddhome.home(parser, args.fakeendstop)
# Disable flowrate limit
printer.sendCommandParamV(CmdEnableFRLimit, [packedvalue.uint8_t(0)])
# Move to mid-position
printer.sendPrinterInit()
feedrate = PrinterProfile.getMaxFeedrate(X_AXIS)
parser.execute_line("G0 F%d X%f Y%f" % (feedrate*60, planner.MAX_POS[X_AXIS]/2, planner.MAX_POS[Y_AXIS]/2))
planner.finishMoves()
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.sendCommand(CmdEOT)
printer.waitForState(StateIdle)
current_position = parser.getRealPos()
apos = current_position[A_AXIS]
t1 = MatProfile.getHotendBaseTemp() # start temperature
area04 = pow(0.4, 2)*math.pi/4
flowrate = MatProfile.getBaseExtrusionRate() * (NozzleProfile.getArea() / area04)
aFilament = MatProfile.getMatArea()
print "t1: ", t1
print "flowrate: ", flowrate
print "aFilament: ", aFilament
print "feedrate: ", flowrate / aFilament
# xxx todo if using small nozzles
assert(flowrate > 2)
f = open("temp-flowrate-curve.gnuplot", "w")
f.write("""
set grid
set yrange [0:35]
# Startwert steigung
a=0.5
# Startwert y-achse
b=5
f(x)=b+a*(x-%d)
fit f(x) "-" using 1:3 noerror via a,b\n""" % t1)
dataSet = []
printer.sendCommandParamV(CmdFanSpeed, [packedvalue.uint8_t(100)])
retracted = False
while t1 <= MatProfile.getHotendMaxTemp():
print "Heating:", t1
printer.heatUp(HeaterEx1, t1, wait=t1)
# time.sleep(10) # temp settle
wait = 5
while wait:
time.sleep(1)
temps = printer.getTemps()
if abs(t1 - int(temps[HeaterEx1])) <= 1:
wait -= 1
else:
wait = 5
print "temp wait: ", wait
flowrate -= 1
ratio = 1.0
while ratio >= 0.9:
feedrate = flowrate / aFilament
# distance = 5 * feedrate # xxx
distance = 50
apos += distance
print "Feedrate for flowrate:", feedrate, flowrate
printer.sendPrinterInit()
if retracted:
parser.execute_line("G11")
parser.execute_line("G0 F%d %s%f" % (feedrate*60, dimNames[A_AXIS], apos))
parser.execute_line("G10")
planner.finishMoves()
printer.sendCommand(CmdEOT)
printer.sendCommandParamV(CmdMove, [MoveTypeNormal])
printer.waitForState(StateIdle)
time.sleep(0.25)
fssteps = printer.getFilSensor()
fsdist = fssteps / fssteps_per_mm
ratio = fsdist / distance
actualFlowrate = flowrate * ratio
print "t1, flowrate, fsdist, distance, ratio:", t1, flowrate, fsdist, distance, ratio
flowrate += 1
retracted = True
print "Feeder grip:", t1, flowrate-1, ratio
dataStr = "%f %f %.2f %.3f" % (t1, flowrate - 1, actualFlowrate, ratio)
f.write(dataStr + "\n")
f.flush()
dataSet.append(dataStr)
t1 += 2 # next temp
f.write("E\n")
f.write("""
plot "-" using 1:2 with linespoints title "Target Flowrate", \\
"-" using 1:3 with linespoints title "Actual Flowrate", \\
"-" using 1:3 with linespoints smooth bezier title "Actual Flowrate smooth", \\
f(x) title sprintf("y=B+A*x, A=%.2f, B=%.1f, TempFactor 1/A: %.2f", a, b, 1/a)\n""")
writeDataSet(f, dataSet)
writeDataSet(f, dataSet)
writeDataSet(f, dataSet)
f.close()
printer.coolDown(HeaterEx1)
# Enable flowrate limit
printer.sendCommandParamV(CmdEnableFRLimit, [packedvalue.uint8_t(1)])
