Пример #1
0
def deleteGcodeFile():
    if "filename" in request.values.keys():
        filename = request.values["filename"]
        sd = "target" in request.values.keys(
        ) and request.values["target"] == "sd"

        currentJob = printer.getCurrentJob()
        currentFilename = None
        currentSd = None
        if currentJob is not None and "filename" in currentJob.keys(
        ) and "sd" in currentJob.keys():
            currentFilename = currentJob["filename"]
            currentSd = currentJob["sd"]

        if currentFilename is not None and filename == currentFilename and not (
                printer.isPrinting() or printer.isPaused()):
            printer.unselectFile()

        if not (currentFilename == filename and currentSd == sd and
                (printer.isPrinting() or printer.isPaused())):
            if sd:
                printer.deleteSdFile(filename)
            else:
                gcodeManager.removeFile(filename)
    return readGcodeFiles()
Пример #2
0
def deleteGcodeFile(filename, target):
	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
		return make_response("Unknown target: %s" % target, 404)

	if not _verifyFileExists(target, filename):
		return make_response("File not found on '%s': %s" % (target, filename), 404)

	sd = target == FileDestinations.SDCARD

	currentJob = printer.getCurrentJob()
	currentFilename = None
	currentSd = None
	if currentJob is not None and "filename" in currentJob.keys() and "sd" in currentJob.keys():
		currentFilename = currentJob["filename"]
		currentSd = currentJob["sd"]

	# prohibit deleting the file that is currently being printed
	if currentFilename == filename and currentSd == sd and (printer.isPrinting() or printer.isPaused()):
		make_response("Trying to delete file that is currently being printed: %s" % filename, 409)

	# deselect the file if it's currently selected
	if currentFilename is not None and filename == currentFilename:
		printer.unselectFile()

	# delete it
	if sd:
		printer.deleteSdFile(filename)
	else:
		gcodeManager.removeFile(filename)

	return NO_CONTENT
Пример #3
0
def deleteGcodeFile(filename, target):
	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
		return make_response("Unknown target: %s" % target, 404)

	if not _verifyFileExists(target, filename):
		return make_response("File not found on '%s': %s" % (target, filename), 404)

	# prohibit deleting files that are currently in use
	currentOrigin, currentFilename = _getCurrentFile()
	if currentFilename == filename and currentOrigin == target and (printer.isPrinting() or printer.isPaused()):
		make_response("Trying to delete file that is currently being printed: %s" % filename, 409)

	if (target, filename) in fileManager.get_busy_files():
		make_response("Trying to delete a file that is currently in use: %s" % filename, 409)

	# deselect the file if it's currently selected
	if currentFilename is not None and filename == currentFilename:
		printer.unselectFile()

	# delete it
	if target == FileDestinations.SDCARD:
		printer.deleteSdFile(filename)
	else:
		fileManager.remove_file(target, filename)

	return NO_CONTENT
Пример #4
0
def deleteGcodeFile(filename, target):
    if not target in [
            FileDestinations.LOCAL, FileDestinations.SDCARD,
            FileDestinations.FastbotSDCARD
    ]:
        return make_response("Unknown target: %s" % target, 404)

    if not _verifyFileExists(target, filename):
        return make_response("File not found on '%s': %s" % (target, filename),
                             404)

    # prohibit deleting files that are currently in use
    currentOrigin, currentFilename = _getCurrentFile()
    if currentFilename == filename and currentOrigin == target and (
            printer.isPrinting() or printer.isPaused()):
        make_response(
            "Trying to delete file that is currently being printed: %s" %
            filename, 409)

    if (target, filename) in fileManager.get_busy_files():
        make_response(
            "Trying to delete a file that is currently in use: %s" % filename,
            409)

    # deselect the file if it's currently selected
    if currentFilename is not None and filename == currentFilename:
        printer.unselectFile()

    # delete it
    if target == FileDestinations.SDCARD:
        printer.deleteSdFile(filename)
    else:
        fileManager.remove_file(target, filename)

    return NO_CONTENT
Пример #5
0
def jog():
	if not printer.isOperational() or printer.isPrinting():
		# do not jog when a print job is running or we don't have a connection
		return jsonify(SUCCESS)

	(movementSpeedX, movementSpeedY, movementSpeedZ, movementSpeedE) = settings().get(["printerParameters", "movementSpeed", ["x", "y", "z", "e"]])
	if "x" in request.values.keys():
		# jog x
		x = request.values["x"]
		printer.commands(["G91", "G1 X%s F%d" % (x, movementSpeedX), "G90", "M114"])
	if "y" in request.values.keys():
		# jog y
		y = request.values["y"]
		printer.commands(["G91", "G1 Y%s F%d" % (y, movementSpeedY), "G90", "M114"])
	if "z" in request.values.keys():
		# jog z
		z = request.values["z"]
		printer.commands(["G91", "G1 Z%s F%d" % (z, movementSpeedZ), "G90", "M114"])
	if "homeXY" in request.values.keys():
		# home x/y
		printer.command("G28 X0 Y0")
	if "posX" in request.values.keys() and "posY" in request.values.keys():
		# go to position
		printer.commands(["G1 X%s Y%s F%d" % (request.values["posX"], request.values["posY"], movementSpeedX), "M114"])
	if "homeZ" in request.values.keys():
		# home z
		printer.command("G28 Z0")
	if "extrude" in request.values.keys():
		# extrude/retract
		length = request.values["extrude"]
		printer.commands(["G91", "G1 E%s F%d" % (length, movementSpeedE), "G90"])

	return jsonify(SUCCESS)
Пример #6
0
def deleteGcodeFile(filename, target):
	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
		return make_response("Unknown target: %s" % target, 404)

	if not _verifyFileExists(target, filename):
		return make_response("File not found on '%s': %s" % (target, filename), 404)

	sd = target == FileDestinations.SDCARD

	currentJob = printer.getCurrentJob()
	currentFilename = None
	currentSd = None
	if currentJob is not None and "filename" in currentJob.keys() and "sd" in currentJob.keys():
		currentFilename = currentJob["filename"]
		currentSd = currentJob["sd"]

	# prohibit deleting the file that is currently being printed
	if currentFilename == filename and currentSd == sd and (printer.isPrinting() or printer.isPaused()):
		make_response("Trying to delete file that is currently being printed: %s" % filename, 409)

	# deselect the file if it's currently selected
	if currentFilename is not None and filename == currentFilename:
		printer.unselectFile()

	# delete it
	if sd:
		printer.deleteSdFile(filename)
	else:
		gcodeManager.removeFile(filename)

	return NO_CONTENT
Пример #7
0
def jog():
    if not printer.isOperational() or printer.isPrinting():
        # do not jog when a print job is running or we don't have a connection
        return jsonify(SUCCESS)

    (movementSpeedX, movementSpeedY, movementSpeedZ,
     movementSpeedE) = settings().get(
         ["printerParameters", "movementSpeed", ["x", "y", "z", "e"]])
    if "x" in request.values.keys():
        # jog x
        x = request.values["x"]
        printer.commands(["G91", "G1 X%s F%d" % (x, movementSpeedX), "G90"])
    if "y" in request.values.keys():
        # jog y
        y = request.values["y"]
        printer.commands(["G91", "G1 Y%s F%d" % (y, movementSpeedY), "G90"])
    if "z" in request.values.keys():
        # jog z
        z = request.values["z"]
        printer.commands(["G91", "G1 Z%s F%d" % (z, movementSpeedZ), "G90"])
    if "homeXY" in request.values.keys():
        # home x/y
        printer.command("G28 X0 Y0")
    if "homeZ" in request.values.keys():
        # home z
        printer.command("G28 Z0")
    if "extrude" in request.values.keys():
        # extrude/retract
        length = request.values["extrude"]
        printer.commands(
            ["G91", "G1 E%s F%d" % (length, movementSpeedE), "G90"])

    return jsonify(SUCCESS)
Пример #8
0
def jog():
    if not printer.isOperational() or printer.isPrinting():
        # do not jog when a print job is running or we don't have a connection
        return jsonify(SUCCESS)

    (movementSpeedX, movementSpeedY, movementSpeedZ, movementSpeedE) = (
            settings.get('movement_speed', s) for s in 'xyze')
    if "x" in request.values.keys():
        # jog x
        x = request.values["x"]
        printer.commands(["G91", "G1 X%s F%d" % (x, movementSpeedX), "G90"])
    if "y" in request.values.keys():
        # jog y
        y = request.values["y"]
        printer.commands(["G91", "G1 Y%s F%d" % (y, movementSpeedY), "G90"])
    if "z" in request.values.keys():
        # jog z
        z = request.values["z"]
        printer.commands(["G91", "G1 Z%s F%d" % (z, movementSpeedZ), "G90"])
    if "homeXY" in request.values.keys():
        # home x/y
        printer.command("G28 X0 Y0")
    if "homeZ" in request.values.keys():
        # home z
        printer.command("G28 Z0")
    if "extrude" in request.values.keys():
        # extrude/retract
        length = request.values["extrude"]
        printer.commands(
            ["G91", "G1 E%s F%d" % (length, movementSpeedE), "G90"])
    return jsonify(SUCCESS)
Пример #9
0
def controlJob():
	if not printer.isOperational():
		return make_response("Printer is not operational", 409)

	valid_commands = {
		"start": [],
		"restart": [],
		"pause": [],
		"cancel": []
	}

	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	activePrintjob = printer.isPrinting() or printer.isPaused()

	if command == "start":
		if activePrintjob:
			return make_response("Printer already has an active print job, did you mean 'restart'?", 409)
		printer.startPrint()
	elif command == "restart":
		if not printer.isPaused():
			return make_response("Printer does not have an active print job or is not paused", 409)
		printer.startPrint()
	elif command == "pause":
		if not activePrintjob:
			return make_response("Printer is neither printing nor paused, 'pause' command cannot be performed", 409)
		printer.togglePausePrint()
	elif command == "cancel":
		if not activePrintjob:
			return make_response("Printer is neither printing nor paused, 'cancel' command cannot be performed", 409)
		printer.cancelPrint()
	return NO_CONTENT
Пример #10
0
def printerPrintheadCommand():

	valid_commands = {
		"jog": [],
	        "fastbot":[],  #lkj
		"home": ["axes"]
	}
	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response
	
	if not printer.isOperational() or ( printer.isPrinting() and command != "fastbot"):
		# do not jog when a print job is running or we don't have a connection
		return make_response("Printer is not operational or currently printing", 409)
	

	valid_axes = ["x", "y", "z"]
	speedTarget = 0
	##~~ jog command
	if command == "jog":
		# validate all jog instructions, make sure that the values are numbers
		validated_values = {}
		for axis in valid_axes:
			if axis in data:
				value = data[axis]
				if not isinstance(value, (int, long, float)):
					return make_response("Not a number for axis %s: %r" % (axis, value), 400)
				validated_values[axis] = value
			#lkj add
			if "speed" in data:
				speedTarget = data["speed"]
			
		print("speed=%s" % str(speedTarget))
		# execute the jog commands
		for axis, value in validated_values.iteritems():
			#lkj printer.jog(axis, value)
			printer.jogSpeed(axis, value, speedTarget)

	##~~ home command
	elif command == "home":
		validated_values = []
		axes = data["axes"]
		for axis in axes:
			if not axis in valid_axes:
				return make_response("Invalid axis: %s" % axis, 400)
			validated_values.append(axis)

		# execute the home command
		printer.home(validated_values)
	elif command == "fastbot": #lkj
		if "FeedSpeed" in data:
			print("FeedSpeed=%s" % str(data["FeedSpeed"]))
			printer.feedSpeed(data["FeedSpeed"])
		if "FanID" in data:
			print("FanID=%s" % str(data["FanID"]))
			print("on=%s" % str(data["on"]))
			printer.fanControl(data["FanID"], data["on"])			
	return NO_CONTENT
Пример #11
0
def controlJob(request=None):
    if not printer.isOperational():
        return make_response("Printer is not operational", 409)

    valid_commands = {
        "start": [],
        "restart": [],
        "pause": [],
        "cancel": [],
        "stop": []  #add by kevin, for emergency stop
    }

    command, data, response = util.getJsonCommandFromRequest(
        request, valid_commands)
    if response is not None:
        return response

    activePrintjob = printer.isPrinting() or printer.isPaused()

    if command == "start":
        if activePrintjob:
            return make_response(
                "Printer already has an active print job, did you mean 'restart'?",
                409)
        printer.startPrint()
    elif command == "restart":
        if not printer.isPaused():
            return make_response(
                "Printer does not have an active print job or is not paused",
                409)
        printer.startPrint()
    elif command == "pause":
        if not activePrintjob:
            return make_response(
                "Printer is neither printing nor paused, 'pause' command cannot be performed",
                409)
        printer.togglePausePrint()
    elif command == "cancel":
        if not activePrintjob:
            return make_response(
                "Printer is neither printing nor paused, 'cancel' command cannot be performed",
                409)
        printer.cancelPrint()
    #add by kevin, for emergency stop
    elif "stop" == command:
        printer.stopPrint()
        if not activePrintjob:
            return make_response(
                "Printer is neither printing nor paused, 'cancel' command cannot be performed",
                409)
        printer.cancelPrint()
    #add end, stop
    return NO_CONTENT
Пример #12
0
def deleteGcodeFile():
	if "filename" in request.values.keys():
		filename = request.values["filename"]
		sd = "target" in request.values.keys() and request.values["target"] == "sd"

		currentJob = printer.getCurrentJob()
		currentFilename = None
		currentSd = None
		if currentJob is not None and "filename" in currentJob.keys() and "sd" in currentJob.keys():
			currentFilename = currentJob["filename"]
			currentSd = currentJob["sd"]

		if currentFilename is not None and filename == currentFilename and not (printer.isPrinting() or printer.isPaused()):
			printer.unselectFile()

		if not (currentFilename == filename and currentSd == sd and (printer.isPrinting() or printer.isPaused())):
			if sd:
				printer.deleteSdFile(filename)
			else:
				gcodeManager.removeFile(filename)
	return readGcodeFiles()
Пример #13
0
def deleteGcodeFile(filename, target):
	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
		return make_response("Invalid target: %s" % target, 400)

	sd = target == FileDestinations.SDCARD

	currentJob = printer.getCurrentJob()
	currentFilename = None
	currentSd = None
	if currentJob is not None and "filename" in currentJob.keys() and "sd" in currentJob.keys():
		currentFilename = currentJob["filename"]
		currentSd = currentJob["sd"]

	if currentFilename is not None and filename == currentFilename and not (printer.isPrinting() or printer.isPaused()):
		printer.unselectFile()

	if not (currentFilename == filename and currentSd == sd and (printer.isPrinting() or printer.isPaused())):
		if sd:
			printer.deleteSdFile(filename)
		else:
			gcodeManager.removeFile(filename)
	return readGcodeFiles()
Пример #14
0
def sdCommand():
    if not settings.get("feature", "sd_support") or not printer.isOperational() or printer.isPrinting():
        return jsonify(SUCCESS)

    if "command" in request.values.keys():
        command = request.values["command"]
        if command == "init":
            printer.initSdCard()
        elif command == "refresh":
            printer.refreshSdFiles()
        elif command == "release":
            printer.releaseSdCard()

    return jsonify(SUCCESS)
Пример #15
0
def sdCommand():
    if not settings().getBoolean([
            "feature", "sdSupport"
    ]) or not printer.isOperational() or printer.isPrinting():
        return jsonify(SUCCESS)

    if "command" in request.values.keys():
        command = request.values["command"]
        if command == "init":
            printer.initSdCard()
        elif command == "refresh":
            printer.refreshSdFiles()
        elif command == "release":
            printer.releaseSdCard()

    return jsonify(SUCCESS)
Пример #16
0
def controlPrinterPrinthead():
	if not printer.isOperational() or printer.isPrinting():
		# do not jog when a print job is running or we don't have a connection
		return make_response("Printer is not operational or currently printing", 403)

	valid_commands = {
		"jog": [],
		"home": ["axes"]
	}
	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	movementSpeed = settings().get(["printerParameters", "movementSpeed", ["x", "y", "z"]], asdict=True)

	valid_axes = ["x", "y", "z"]
	##~~ jog command
	if command == "jog":
		# validate all jog instructions, make sure that the values are numbers
		validated_values = {}
		for axis in valid_axes:
			if axis in data:
				value = data[axis]
				if not isinstance(value, (int, long, float)):
					return make_response("Not a number for axis %s: %r" % (axis, value), 400)
				validated_values[axis] = value

		# execute the jog commands
		for axis, value in validated_values.iteritems():
			# TODO make this a generic method call (printer.jog(axis, value)) to get rid of gcode here
			printer.commands(["G91", "G1 %s%.4f F%d" % (axis.upper(), value, movementSpeed[axis]), "G90"])

	##~~ home command
	elif command == "home":
		validated_values = []
		axes = data["axes"]
		for axis in axes:
			if not axis in valid_axes:
				return make_response("Invalid axis: %s" % axis, 400)
			validated_values.append(axis)

		# execute the home command
		# TODO make this a generic method call (printer.home(axis, ...)) to get rid of gcode here
		printer.commands(["G91", "G28 %s" % " ".join(map(lambda x: "%s0" % x.upper(), validated_values)), "G90"])

	return jsonify(SUCCESS)
Пример #17
0
def printerPrintheadCommand(request=None):
    if not printer.isOperational() or printer.isPrinting():
        # do not jog when a print job is running or we don't have a connection
        return make_response(
            "Printer is not operational or currently printing", 409)

    valid_commands = {"jog": [], "home": ["axes"]}
    command, data, response = util.getJsonCommandFromRequest(
        request, valid_commands)
    print "command:", command, "data:", data, "response:", response
    if response is not None:
        return response

    valid_axes = ["x", "y", "z"]
    ##~~ jog command
    if command == "jog":
        # validate all jog instructions, make sure that the values are numbers
        validated_values = {}
        for axis in valid_axes:
            if axis in data:
                value = data[axis]
                if not isinstance(value, (int, long, float)):
                    return make_response(
                        "Not a number for axis %s: %r" % (axis, value), 400)
                validated_values[axis] = value

        # execute the jog commands
        for axis, value in validated_values.iteritems():
            printer.jog(axis, value)

    ##~~ home command
    elif command == "home":
        validated_values = []
        axes = data["axes"]
        for axis in axes:
            if not axis in valid_axes:
                return make_response("Invalid axis: %s" % axis, 400)
            validated_values.append(axis)

        # execute the home command
        printer.home(validated_values)

    return NO_CONTENT
Пример #18
0
def printerPrintheadCommand():
	if not printer.isOperational() or printer.isPrinting():
		# do not jog when a print job is running or we don't have a connection
		return make_response("Printer is not operational or currently printing", 409)

	valid_commands = {
		"jog": [],
		"home": ["axes"]
	}
	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	valid_axes = ["x", "y", "z"]
	##~~ jog command
	if command == "jog":
		# validate all jog instructions, make sure that the values are numbers
		validated_values = {}
		for axis in valid_axes:
			if axis in data:
				value = data[axis]
				if not isinstance(value, (int, long, float)):
					return make_response("Not a number for axis %s: %r" % (axis, value), 400)
				validated_values[axis] = value

		# execute the jog commands
		for axis, value in validated_values.iteritems():
			printer.jog(axis, value)

	##~~ home command
	elif command == "home":
		validated_values = []
		axes = data["axes"]
		for axis in axes:
			if not axis in valid_axes:
				return make_response("Invalid axis: %s" % axis, 400)
			validated_values.append(axis)

		# execute the home command
		printer.home(validated_values)

	return NO_CONTENT
Пример #19
0
def printerSdCommand():
    if not settings().getBoolean(["feature", "sdSupport"]):
        return make_response("SD support is disabled", 404)

    if not printer.isOperational() or printer.isPrinting() or printer.isPaused():
        return make_response("Printer is not operational or currently busy", 409)

    valid_commands = {"init": [], "refresh": [], "release": []}
    command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
    if response is not None:
        return response

    if command == "init":
        printer.initSdCard()
    elif command == "refresh":
        printer.refreshSdFiles()
    elif command == "release":
        printer.releaseSdCard()

    return NO_CONTENT
Пример #20
0
def controlPrinterFeeder():
	if not printer.isOperational() or printer.isPrinting():
		# do not jog when a print job is running or we don't have a connection
		return make_response("Printer is not operational or currently printing", 403)

	valid_commands = {
		"extrude": ["amount"]
	}
	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	extrusionSpeed = settings().get(["printerParameters", "movementSpeed", "e"])

	if command == "extrude":
		amount = data["amount"]
		if not isinstance(amount, (int, long, float)):
			return make_response("Not a number for extrusion amount: %r" % amount, 400)

		# TODO make this a generic method call (printer.extruder([hotend,] amount)) to get rid of gcode here
		printer.commands(["G91", "G1 E%s F%d" % (data["amount"], extrusionSpeed), "G90"])

	return jsonify(SUCCESS)
Пример #21
0
def printerSdCommand():
    if not settings().getBoolean(["feature", "sdSupport"]):
        return make_response("SD support is disabled", 404)

    if not printer.isOperational() or printer.isPrinting() or printer.isPaused(
    ):
        return make_response("Printer is not operational or currently busy",
                             409)

    valid_commands = {"init": [], "refresh": [], "release": []}
    command, data, response = util.getJsonCommandFromRequest(
        request, valid_commands)
    if response is not None:
        return response

    if command == "init":
        printer.initSdCard()
    elif command == "refresh":
        printer.refreshSdFiles()
    elif command == "release":
        printer.releaseSdCard()

    return NO_CONTENT
Пример #22
0
def uploadGcodeFile(target):
    if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
        return make_response("Invalid target: %s" % target, 400)

    if "gcode_file" in request.files.keys():
        file = request.files["gcode_file"]
        sd = target == FileDestinations.SDCARD
        selectAfterUpload = "select" in request.values.keys(
        ) and request.values["select"] in valid_boolean_trues
        printAfterSelect = "print" in request.values.keys(
        ) and request.values["print"] in valid_boolean_trues

        # determine current job
        currentFilename = None
        currentSd = None
        currentJob = printer.getCurrentJob()
        if currentJob is not None and "filename" in currentJob.keys() and "sd" in currentJob.keys():
            currentFilename = currentJob["filename"]
            currentSd = currentJob["sd"]

        # determine future filename of file to be uploaded, abort if it can't
        # be uploaded
        futureFilename = gcodeManager.getFutureFilename(file)
        if futureFilename is None or (not settings.get("cura", "enabled") and not gcodefiles.isGcodeFileName(futureFilename)):
            return make_response("Can not upload file %s, wrong format?" % file.filename, 400)

        # prohibit overwriting currently selected file while it's being printed
        if futureFilename == currentFilename and sd == currentSd and printer.isPrinting() or printer.isPaused():
            return make_response("Trying to overwrite file that is currently being printed: %s" % currentFilename, 403)

        filename = None

        def fileProcessingFinished(filename, absFilename, destination):
            """
            Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
            finished.

            Depending on the file's destination triggers either streaming to SD card or directly calls selectOrPrint.
            """
            sd = destination == FileDestinations.SDCARD
            if sd:
                printer.addSdFile(filename, absFilename, selectAndOrPrint)
            else:
                selectAndOrPrint(absFilename, destination)

        def selectAndOrPrint(nameToSelect, destination):
            """
            Callback for when the file is ready to be selected and optionally printed. For SD file uploads this only
            the case after they have finished streaming to the printer, which is why this callback is also used
            for the corresponding call to addSdFile.

            Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
            exact file is already selected, such reloading it.
            """
            sd = destination == FileDestinations.SDCARD
            if selectAfterUpload or printAfterSelect or (currentFilename == filename and currentSd == sd):
                printer.selectFile(nameToSelect, sd, printAfterSelect)

        destination = FileDestinations.SDCARD if sd else FileDestinations.LOCAL
        filename, done = gcodeManager.addFile(
            file, destination, fileProcessingFinished)
        if filename is None:
            return make_response("Could not upload the file %s" % file.filename, 500)

        eventManager.fire("Upload", filename)
        return jsonify(files=gcodeManager.getAllFileData(), filename=filename, done=done)
    else:
        return make_response("No gcode_file included", 400)
Пример #23
0
def jog():
	if not printer.isOperational() or printer.isPrinting():
		# do not jog when a print job is running or we don't have a connection
		return jsonify(SUCCESS)

	(movementSpeedX, movementSpeedY, movementSpeedZ, movementSpeedE) = settings().get(["printerParameters", "movementSpeed", ["x", "y", "z", "e"]])
	if "x" in request.values.keys():
		# jog x
		x = request.values["x"]
		printer.commands(["G91", "G1 X%s F%d" % (x, movementSpeedX), "G90"])
	if "y" in request.values.keys():
		# jog y
		y = request.values["y"]
		printer.commands(["G91", "G1 Y%s F%d" % (y, movementSpeedY), "G90"])
	if "z" in request.values.keys():
		# jog z
		z = request.values["z"]
		printer.commands(["G91", "G1 Z%s F%d" % (z, movementSpeedZ), "G90"])
	if "homeXY" in request.values.keys():
		# home x/y
		printer.command("G28 X0 Y0")
	if "homeZ" in request.values.keys():
		# home z
		printer.command("G28 Z0")
	if "extrude" in request.values.keys():
		# extrude/retract
		length = request.values["extrude"]
		printer.commands(["G91", "G1 E%s F%d" % (length, movementSpeedE), "G90"])

	movementSpeed = settings().get(["printerParameters", "movementSpeed", ["x", "y", "z"]], asdict=True)

	valid_axes = ["x", "y", "z"]
	##~~ jog command
	if command == "jog":
		# validate all jog instructions, make sure that the values are numbers
		validated_values = {}
		for axis in valid_axes:
			if axis in data:
				value = data[axis]
				if not isinstance(value, (int, long, float)):
					return make_response("Not a number for axis %s: %r" % (axis, value), 400)
				validated_values[axis] = value

		# execute the jog commands
		for axis, value in validated_values.iteritems():
			# TODO make this a generic method call (printer.jog(axis, value)) to get rid of gcode here
			printer.commands(["G91", "G1 %s%.4f F%d" % (axis.upper(), value, movementSpeed[axis]), "G90"])

	##~~ home command
	elif command == "home":
		validated_values = []
		axes = data["axes"]
		for axis in axes:
			if not axis in valid_axes:
				return make_response("Invalid axis: %s" % axis, 400)
			validated_values.append(axis)

		# execute the home command
		# TODO make this a generic method call (printer.home(axis, ...)) to get rid of gcode here
		printer.commands(["G91", "G28 %s" % " ".join(map(lambda x: "%s0" % x.upper(), validated_values)), "G90"])

	return jsonify(SUCCESS)
Пример #24
0
def uploadGcodeFile(target):
    print("lkj uploadGcodeFile target:%s" % str(target))
    if target in ["extruder1", "extruder2", "bed"]:
        return upload_temp_curve_firmware(target)

    if target == "firmware":
        return uploadFirmwareFile(target)

    if target == FileDestinations.FastbotSDCARD:
        return uploadFastBotSDCARD(target)

    if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
        return make_response("Unknown target: %s" % target, 404)

    input_name = "file"
    input_upload_name = input_name + "." + settings().get(
        ["server", "uploads", "nameSuffix"])
    input_upload_path = input_name + "." + settings().get(
        ["server", "uploads", "pathSuffix"])
    if input_upload_name in request.values and input_upload_path in request.values:
        import shutil
        upload = util.Object()
        upload.filename = request.values[input_upload_name]
        upload.save = lambda new_path: shutil.move(
            request.values[input_upload_path], new_path)
    elif input_name in request.files:
        upload = request.files[input_name]
    else:
        return make_response("No file included", 400)

    if target == FileDestinations.SDCARD and not settings().getBoolean(
        ["feature", "sdSupport"]):
        return make_response("SD card support is disabled", 404)

    sd = target == FileDestinations.SDCARD
    selectAfterUpload = "select" in request.values.keys(
    ) and request.values["select"] in valid_boolean_trues
    printAfterSelect = "print" in request.values.keys(
    ) and request.values["print"] in valid_boolean_trues

    if sd:
        # validate that all preconditions for SD upload are met before attempting it
        if not (printer.isOperational()
                and not (printer.isPrinting() or printer.isPaused())):
            return make_response(
                "Can not upload to SD card, printer is either not operational or already busy",
                409)
        if not printer.isSdReady():
            return make_response(
                "Can not upload to SD card, not yet initialized", 409)

    # determine current job
    currentFilename = None
    currentOrigin = None
    currentJob = printer.getCurrentJob()
    if currentJob is not None and "file" in currentJob.keys():
        currentJobFile = currentJob["file"]
        if "name" in currentJobFile.keys() and "origin" in currentJobFile.keys(
        ):
            currentFilename = currentJobFile["name"]
            currentOrigin = currentJobFile["origin"]

    # determine future filename of file to be uploaded, abort if it can't be uploaded
    try:
        futureFilename = fileManager.sanitize_name(FileDestinations.LOCAL,
                                                   upload.filename)
    except:
        futureFilename = None
    if futureFilename is None or not (slicingManager.slicing_enabled
                                      or octoprint.filemanager.valid_file_type(
                                          futureFilename, type="gcode")):
        return make_response(
            "Can not upload file %s, wrong format?" % upload.filename, 415)

    # prohibit overwriting currently selected file while it's being printed
    if futureFilename == currentFilename and target == currentOrigin and printer.isPrinting(
    ) or printer.isPaused():
        return make_response(
            "Trying to overwrite file that is currently being printed: %s" %
            currentFilename, 409)

    def fileProcessingFinished(filename, absFilename, destination):
        """
		Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
		finished.

		Depending on the file's destination triggers either streaming to SD card or directly calls selectAndOrPrint.
		"""

        if destination == FileDestinations.SDCARD and octoprint.filemanager.valid_file_type(
                filename, "gcode"):
            return filename, printer.addSdFile(filename, absFilename,
                                               selectAndOrPrint)
        else:
            selectAndOrPrint(filename, absFilename, destination)
            return filename

    def selectAndOrPrint(filename, absFilename, destination):
        """
		Callback for when the file is ready to be selected and optionally printed. For SD file uploads this is only
		the case after they have finished streaming to the printer, which is why this callback is also used
		for the corresponding call to addSdFile.

		Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
		exact file is already selected, such reloading it.
		"""
        if octoprint.filemanager.valid_file_type(added_file, "gcode") and (
                selectAfterUpload or printAfterSelect or
            (currentFilename == filename and currentOrigin == destination)):
            printer.selectFile(absFilename,
                               destination == FileDestinations.SDCARD,
                               printAfterSelect)

    added_file = fileManager.add_file(FileDestinations.LOCAL,
                                      upload.filename,
                                      upload,
                                      allow_overwrite=True)
    if added_file is None:
        return make_response("Could not upload the file %s" % upload.filename,
                             500)
    if octoprint.filemanager.valid_file_type(added_file, "stl"):
        filename = added_file
        done = True
    else:
        filename = fileProcessingFinished(
            added_file,
            fileManager.get_absolute_path(FileDestinations.LOCAL, added_file),
            target)
        done = True

    sdFilename = None
    if isinstance(filename, tuple):
        filename, sdFilename = filename

    eventManager.fire(Events.UPLOAD, {"file": filename, "target": target})

    files = {}
    location = url_for(".readGcodeFile",
                       target=FileDestinations.LOCAL,
                       filename=filename,
                       _external=True)
    files.update({
        FileDestinations.LOCAL: {
            "name": filename,
            "origin": FileDestinations.LOCAL,
            "refs": {
                "resource":
                location,
                "download":
                url_for("index", _external=True) + "downloads/files/" +
                FileDestinations.LOCAL + "/" + filename
            }
        }
    })

    if sd and sdFilename:
        location = url_for(".readGcodeFile",
                           target=FileDestinations.SDCARD,
                           filename=sdFilename,
                           _external=True)
        files.update({
            FileDestinations.SDCARD: {
                "name": sdFilename,
                "origin": FileDestinations.SDCARD,
                "refs": {
                    "resource": location
                }
            }
        })

    r = make_response(jsonify(files=files, done=done), 201)
    r.headers["Location"] = location
    return r
Пример #25
0
def printerToolCommand():
	if not printer.isOperational():
		return make_response("Printer is not operational", 409)

	valid_commands = {
		"select": ["tool"],
		"target": ["targets"],
		"offset": ["offsets"],
		"extrude": ["amount"]
	}
	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	validation_regex = re.compile("tool\d+")

	##~~ tool selection
	if command == "select":
		tool = data["tool"]
		if re.match(validation_regex, tool) is None:
			return make_response("Invalid tool: %s" % tool, 400)
		if not tool.startswith("tool"):
			return make_response("Invalid tool for selection: %s" % tool, 400)

		printer.changeTool(tool)

	##~~ temperature
	elif command == "target":
		targets = data["targets"]

		# make sure the targets are valid and the values are numbers
		validated_values = {}
		for tool, value in targets.iteritems():
			if re.match(validation_regex, tool) is None:
				return make_response("Invalid target for setting temperature: %s" % tool, 400)
			if not isinstance(value, (int, long, float)):
				return make_response("Not a number for %s: %r" % (tool, value), 400)
			validated_values[tool] = value

		# perform the actual temperature commands
		for tool in validated_values.keys():
			printer.setTemperature(tool, validated_values[tool])

	##~~ temperature offset
	elif command == "offset":
		offsets = data["offsets"]

		# make sure the targets are valid, the values are numbers and in the range [-50, 50]
		validated_values = {}
		for tool, value in offsets.iteritems():
			if re.match(validation_regex, tool) is None:
				return make_response("Invalid target for setting temperature: %s" % tool, 400)
			if not isinstance(value, (int, long, float)):
				return make_response("Not a number for %s: %r" % (tool, value), 400)
			if not -50 <= value <= 50:
				return make_response("Offset %s not in range [-50, 50]: %f" % (tool, value), 400)
			validated_values[tool] = value

		# set the offsets
		printer.setTemperatureOffset(validated_values)

	##~~ extrusion
	elif command == "extrude":
		if printer.isPrinting():
			# do not extrude when a print job is running
			return make_response("Printer is currently printing", 409)

		amount = data["amount"]
		speedTarget = data["speed"]
		if not isinstance(amount, (int, long, float)):
			return make_response("Not a number for extrusion amount: %r" % amount, 400)
		#printer.extrude(amount)
		print("speed=%s" % str(speedTarget))		
		printer.extrudeSpeed(amount, speedTarget)

	return NO_CONTENT
Пример #26
0
def uploadGcodeFile(target):
    if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
        return make_response("Invalid target: %s" % target, 400)

    if "gcode_file" in request.files.keys():
        file = request.files["gcode_file"]
        sd = target == FileDestinations.SDCARD
        selectAfterUpload = "select" in request.values.keys(
        ) and request.values["select"] in valid_boolean_trues
        printAfterSelect = "print" in request.values.keys(
        ) and request.values["print"] in valid_boolean_trues

        # determine current job
        currentFilename = None
        currentSd = None
        currentJob = printer.getCurrentJob()
        if currentJob is not None and "filename" in currentJob.keys(
        ) and "sd" in currentJob.keys():
            currentFilename = currentJob["filename"]
            currentSd = currentJob["sd"]

        # determine future filename of file to be uploaded, abort if it can't be uploaded
        futureFilename = gcodeManager.getFutureFilename(file)
        if futureFilename is None or (
                not settings().getBoolean(["cura", "enabled"])
                and not gcodefiles.isGcodeFileName(futureFilename)):
            return make_response(
                "Can not upload file %s, wrong format?" % file.filename, 400)

        # prohibit overwriting currently selected file while it's being printed
        if futureFilename == currentFilename and sd == currentSd and printer.isPrinting(
        ) or printer.isPaused():
            return make_response(
                "Trying to overwrite file that is currently being printed: %s"
                % currentFilename, 403)

        filename = None

        def fileProcessingFinished(filename, absFilename, destination):
            """
			Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
			finished.

			Depending on the file's destination triggers either streaming to SD card or directly calls selectOrPrint.
			"""
            sd = destination == FileDestinations.SDCARD
            if sd:
                printer.addSdFile(filename, absFilename, selectAndOrPrint)
            else:
                selectAndOrPrint(absFilename, destination)

        def selectAndOrPrint(nameToSelect, destination):
            """
			Callback for when the file is ready to be selected and optionally printed. For SD file uploads this only
			the case after they have finished streaming to the printer, which is why this callback is also used
			for the corresponding call to addSdFile.

			Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
			exact file is already selected, such reloading it.
			"""
            sd = destination == FileDestinations.SDCARD
            if selectAfterUpload or printAfterSelect or (
                    currentFilename == filename and currentSd == sd):
                printer.selectFile(nameToSelect, sd, printAfterSelect)

        destination = FileDestinations.SDCARD if sd else FileDestinations.LOCAL
        filename, done = gcodeManager.addFile(file, destination,
                                              fileProcessingFinished)
        if filename is None:
            return make_response(
                "Could not upload the file %s" % file.filename, 500)

        eventManager.fire("Upload", filename)
        return jsonify(files=gcodeManager.getAllFileData(),
                       filename=filename,
                       done=done)
    else:
        return make_response("No gcode_file included", 400)
Пример #27
0
def sdCommand():
	if not settings().getBoolean(["feature", "sdSupport"]) or not printer.isOperational() or printer.isPrinting():
		return make_response("SD support is disabled", 403)

	valid_commands = {
		"init": [],
		"refresh": [],
		"release": []
	}
	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	if command == "init":
		printer.initSdCard()
	elif command == "refresh":
		printer.refreshSdFiles()
	elif command == "release":
		printer.releaseSdCard()

	return jsonify(SUCCESS)
Пример #28
0
def gcodeFileCommand(filename, target):
	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
		return make_response("Unknown target: %s" % target, 404)

	if not _verifyFileExists(target, filename):
		return make_response("File not found on '%s': %s" % (target, filename), 404)

	# valid file commands, dict mapping command name to mandatory parameters
	valid_commands = {
		"select": [],
		"slice": []
	}

	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	if command == "select":
		# selects/loads a file
		printAfterLoading = False
		if "print" in data.keys() and data["print"] in valid_boolean_trues:
			if not printer.isOperational():
				return make_response("Printer is not operational, cannot directly start printing", 409)
			printAfterLoading = True

		sd = False
		if target == FileDestinations.SDCARD:
			filenameToSelect = filename
			sd = True
		else:
			filenameToSelect = fileManager.get_absolute_path(target, filename)
		printer.selectFile(filenameToSelect, sd, printAfterLoading)

	elif command == "slice":
		if "slicer" in data.keys():
			slicer = data["slicer"]
			del data["slicer"]
			if not slicer in slicingManager.registered_slicers:
				return make_response("Slicer {slicer} is not available".format(**locals()), 400)
			slicer_instance = slicingManager.get_slicer(slicer)
		elif "cura" in slicingManager.registered_slicers:
			slicer = "cura"
			slicer_instance = slicingManager.get_slicer("cura")
		else:
			return make_response("Cannot slice {filename}, no slicer available".format(**locals()), 415)

		if not octoprint.filemanager.valid_file_type(filename, type="stl"):
			return make_response("Cannot slice {filename}, not an STL file".format(**locals()), 415)

		if slicer_instance.get_slicer_properties()["same_device"] and (printer.isPrinting() or printer.isPaused()):
			# slicer runs on same device as OctoPrint, slicing while printing is hence disabled
			return make_response("Cannot slice on {slicer} while printing due to performance reasons".format(**locals()), 409)

		if "gcode" in data.keys() and data["gcode"]:
			gcode_name = data["gcode"]
			del data["gcode"]
		else:
			import os
			name, _ = os.path.splitext(filename)
			gcode_name = name + ".gco"

		# prohibit overwriting the file that is currently being printed
		currentOrigin, currentFilename = _getCurrentFile()
		if currentFilename == gcode_name and currentOrigin == target and (printer.isPrinting() or printer.isPaused()):
			make_response("Trying to slice into file that is currently being printed: %s" % gcode_name, 409)

		if "profile" in data.keys() and data["profile"]:
			profile = data["profile"]
			del data["profile"]
		else:
			profile = None

		if "printerProfile" in data.keys() and data["printerProfile"]:
			printerProfile = data["printerProfile"]
			del data["printerProfile"]
		else:
			printerProfile = None

		if "position" in data.keys() and data["position"] and isinstance(data["position"], dict) and "x" in data["position"] and "y" in data["position"]:
			position = data["position"]
			del data["position"]
		else:
			position = None

		select_after_slicing = False
		if "select" in data.keys() and data["select"] in valid_boolean_trues:
			if not printer.isOperational():
				return make_response("Printer is not operational, cannot directly select for printing", 409)
			select_after_slicing = True

		print_after_slicing = False
		if "print" in data.keys() and data["print"] in valid_boolean_trues:
			if not printer.isOperational():
				return make_response("Printer is not operational, cannot directly start printing", 409)
			select_after_slicing = print_after_slicing = True

		override_keys = [k for k in data if k.startswith("profile.") and data[k] is not None]
		overrides = dict()
		for key in override_keys:
			overrides[key[len("profile."):]] = data[key]

		def slicing_done(target, gcode_name, select_after_slicing, print_after_slicing):
			if select_after_slicing or print_after_slicing:
				sd = False
				if target == FileDestinations.SDCARD:
					filenameToSelect = gcode_name
					sd = True
				else:
					filenameToSelect = fileManager.get_absolute_path(target, gcode_name)
				printer.selectFile(filenameToSelect, sd, print_after_slicing)

		ok, result = fileManager.slice(slicer, target, filename, target, gcode_name,
		                               profile=profile,
		                               printer_profile_id=printerProfile,
		                               position=position,
		                               overrides=overrides,
		                               callback=slicing_done,
		                               callback_args=(target, gcode_name, select_after_slicing, print_after_slicing))

		if ok:
			files = {}
			location = url_for(".readGcodeFile", target=target, filename=gcode_name, _external=True)
			result = {
				"name": gcode_name,
				"origin": FileDestinations.LOCAL,
				"refs": {
					"resource": location,
					"download": url_for("index", _external=True) + "downloads/files/" + target + "/" + gcode_name
				}
			}

			r = make_response(jsonify(result), 202)
			r.headers["Location"] = location
			return r
		else:
			return make_response("Could not slice: {result}".format(result=result), 500)

	return NO_CONTENT
Пример #29
0
def printerToolCommand():
	if not printer.isOperational():
		return make_response("Printer is not operational", 409)

	valid_commands = {
		"select": ["tool"],
		"target": ["targets"],
		"offset": ["offsets"],
		"extrude": ["amount"]
	}
	command, data, response = util.getJsonCommandFromRequest(request, valid_commands)
	if response is not None:
		return response

	validation_regex = re.compile("tool\d+")

	##~~ tool selection
	if command == "select":
		tool = data["tool"]
		if re.match(validation_regex, tool) is None:
			return make_response("Invalid tool: %s" % tool, 400)
		if not tool.startswith("tool"):
			return make_response("Invalid tool for selection: %s" % tool, 400)

		printer.changeTool(tool)

	##~~ temperature
	elif command == "target":
		targets = data["targets"]

		# make sure the targets are valid and the values are numbers
		validated_values = {}
		for tool, value in targets.iteritems():
			if re.match(validation_regex, tool) is None:
				return make_response("Invalid target for setting temperature: %s" % tool, 400)
			if not isinstance(value, (int, long, float)):
				return make_response("Not a number for %s: %r" % (tool, value), 400)
			validated_values[tool] = value

		# perform the actual temperature commands
		for tool in validated_values.keys():
			printer.setTemperature(tool, validated_values[tool])

	##~~ temperature offset
	elif command == "offset":
		offsets = data["offsets"]

		# make sure the targets are valid, the values are numbers and in the range [-50, 50]
		validated_values = {}
		for tool, value in offsets.iteritems():
			if re.match(validation_regex, tool) is None:
				return make_response("Invalid target for setting temperature: %s" % tool, 400)
			if not isinstance(value, (int, long, float)):
				return make_response("Not a number for %s: %r" % (tool, value), 400)
			if not -50 <= value <= 50:
				return make_response("Offset %s not in range [-50, 50]: %f" % (tool, value), 400)
			validated_values[tool] = value

		# set the offsets
		printer.setTemperatureOffset(validated_values)

	##~~ extrusion
	elif command == "extrude":
		if printer.isPrinting():
			# do not extrude when a print job is running
			return make_response("Printer is currently printing", 409)

		amount = data["amount"]
		if not isinstance(amount, (int, long, float)):
			return make_response("Not a number for extrusion amount: %r" % amount, 400)
		printer.extrude(amount, 250 if amount > 0 else 400)

	return NO_CONTENT
Пример #30
0
def uploadGcodeFile(target):
    if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
        return make_response("Unknown target: %s" % target, 404)

    if not "file" in request.files.keys():
        return make_response("No file included", 400)

    if target == FileDestinations.SDCARD and not settings().getBoolean(
        ["feature", "sdSupport"]):
        return make_response("SD card support is disabled", 404)

    file = request.files["file"]
    sd = target == FileDestinations.SDCARD
    selectAfterUpload = "select" in request.values.keys(
    ) and request.values["select"] in valid_boolean_trues
    printAfterSelect = "print" in request.values.keys(
    ) and request.values["print"] in valid_boolean_trues

    if sd:
        # validate that all preconditions for SD upload are met before attempting it
        if not (printer.isOperational()
                and not (printer.isPrinting() or printer.isPaused())):
            return make_response(
                "Can not upload to SD card, printer is either not operational or already busy",
                409)
        if not printer.isSdReady():
            return make_response(
                "Can not upload to SD card, not yet initialized", 409)

    # determine current job
    currentFilename = None
    currentSd = None
    currentJob = printer.getCurrentJob()
    if currentJob is not None and "filename" in currentJob.keys(
    ) and "sd" in currentJob.keys():
        currentFilename = currentJob["filename"]
        currentSd = currentJob["sd"]

    # determine future filename of file to be uploaded, abort if it can't be uploaded
    futureFilename = gcodeManager.getFutureFilename(file)
    if futureFilename is None or (
            not settings().getBoolean(["cura", "enabled"])
            and not gcodefiles.isGcodeFileName(futureFilename)):
        return make_response(
            "Can not upload file %s, wrong format?" % file.filename, 415)

    # prohibit overwriting currently selected file while it's being printed
    if futureFilename == currentFilename and sd == currentSd and printer.isPrinting(
    ) or printer.isPaused():
        return make_response(
            "Trying to overwrite file that is currently being printed: %s" %
            currentFilename, 409)

    filename = None

    def fileProcessingFinished(filename, absFilename, destination):
        """
		Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
		finished.

		Depending on the file's destination triggers either streaming to SD card or directly calls selectAndOrPrint.
		"""
        if destination == FileDestinations.SDCARD:
            return filename, printer.addSdFile(filename, absFilename,
                                               selectAndOrPrint)
        else:
            selectAndOrPrint(absFilename, destination)
            return filename

    def selectAndOrPrint(nameToSelect, destination):
        """
		Callback for when the file is ready to be selected and optionally printed. For SD file uploads this is only
		the case after they have finished streaming to the printer, which is why this callback is also used
		for the corresponding call to addSdFile.

		Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
		exact file is already selected, such reloading it.
		"""
        sd = destination == FileDestinations.SDCARD
        if selectAfterUpload or printAfterSelect or (
                currentFilename == filename and currentSd == sd):
            printer.selectFile(nameToSelect, sd, printAfterSelect)

    destination = FileDestinations.SDCARD if sd else FileDestinations.LOCAL
    filename, done = gcodeManager.addFile(file, destination,
                                          fileProcessingFinished)
    if filename is None:
        return make_response("Could not upload the file %s" % file.filename,
                             500)

    sdFilename = None
    if isinstance(filename, tuple):
        filename, sdFilename = filename

    eventManager.fire(Events.UPLOAD, {"file": filename, "target": target})

    files = {}
    if done:
        files.update({
            FileDestinations.LOCAL: {
                "name": filename,
                "origin": FileDestinations.LOCAL,
                "refs": {
                    "resource":
                    url_for(".readGcodeFile",
                            target=FileDestinations.LOCAL,
                            filename=filename,
                            _external=True),
                    "download":
                    url_for("index", _external=True) + "downloads/files/" +
                    FileDestinations.LOCAL + "/" + filename
                }
            }
        })

        if sd and sdFilename:
            files.update({
                FileDestinations.SDCARD: {
                    "name": sdFilename,
                    "origin": FileDestinations.SDCARD,
                    "refs": {
                        "resource":
                        url_for(".readGcodeFile",
                                target=FileDestinations.SDCARD,
                                filename=sdFilename,
                                _external=True)
                    }
                }
            })

    return make_response(jsonify(files=files, done=done), 201)
Пример #31
0
def gcodeFileCommand(filename, target):

    if not target in [
            FileDestinations.LOCAL, FileDestinations.SDCARD,
            FileDestinations.FastbotSDCARD
    ]:
        return make_response("Unknown target: %s" % target, 404)

    if not _verifyFileExists(target, filename):
        return make_response("File not found on '%s': %s" % (target, filename),
                             404)

    # valid file commands, dict mapping command name to mandatory parameters
    valid_commands = {"select": [], "slice": []}

    command, data, response = util.getJsonCommandFromRequest(
        request, valid_commands)
    if response is not None:
        return response

    if command == "select":
        # selects/loads a file
        printAfterLoading = False
        if "print" in data.keys() and data["print"] in valid_boolean_trues:
            if not printer.isOperational():
                return make_response(
                    "Printer is not operational, cannot directly start printing",
                    409)
            printAfterLoading = True

        if target == FileDestinations.SDCARD:
            filenameToSelect = filename
        else:
            filenameToSelect = fileManager.get_absolute_path(target, filename)
        printer.selectFile(filenameToSelect, target, printAfterLoading)

    elif command == "slice":
        if "slicer" in data.keys():
            slicer = data["slicer"]
            del data["slicer"]
            if not slicer in slicingManager.registered_slicers:
                return make_response(
                    "Slicer {slicer} is not available".format(**locals()), 400)
            slicer_instance = slicingManager.get_slicer(slicer)
        elif "cura" in slicingManager.registered_slicers:
            slicer = "cura"
            slicer_instance = slicingManager.get_slicer("cura")
        else:
            return make_response(
                "Cannot slice {filename}, no slicer available".format(
                    **locals()), 415)

        if not octoprint.filemanager.valid_file_type(filename, type="stl"):
            return make_response(
                "Cannot slice {filename}, not an STL file".format(**locals()),
                415)

        if slicer_instance.get_slicer_properties()["same_device"] and (
                printer.isPrinting() or printer.isPaused()):
            # slicer runs on same device as OctoPrint, slicing while printing is hence disabled
            return make_response(
                "Cannot slice on {slicer} while printing due to performance reasons"
                .format(**locals()), 409)

        if "gcode" in data.keys() and data["gcode"]:
            gcode_name = data["gcode"]
            del data["gcode"]
        else:
            import os
            name, _ = os.path.splitext(filename)
            gcode_name = name + ".gco"

        # prohibit overwriting the file that is currently being printed
        currentOrigin, currentFilename = _getCurrentFile()
        if currentFilename == gcode_name and currentOrigin == target and (
                printer.isPrinting() or printer.isPaused()):
            make_response(
                "Trying to slice into file that is currently being printed: %s"
                % gcode_name, 409)

        if "profile" in data.keys() and data["profile"]:
            profile = data["profile"]
            del data["profile"]
        else:
            profile = None

        if "printerProfile" in data.keys() and data["printerProfile"]:
            printerProfile = data["printerProfile"]
            del data["printerProfile"]
        else:
            printerProfile = None

        if "position" in data.keys() and data["position"] and isinstance(
                data["position"],
                dict) and "x" in data["position"] and "y" in data["position"]:
            position = data["position"]
            del data["position"]
        else:
            position = None

        select_after_slicing = False
        if "select" in data.keys() and data["select"] in valid_boolean_trues:
            if not printer.isOperational():
                return make_response(
                    "Printer is not operational, cannot directly select for printing",
                    409)
            select_after_slicing = True

        print_after_slicing = False
        if "print" in data.keys() and data["print"] in valid_boolean_trues:
            if not printer.isOperational():
                return make_response(
                    "Printer is not operational, cannot directly start printing",
                    409)
            select_after_slicing = print_after_slicing = True

        override_keys = [
            k for k in data if k.startswith("profile.") and data[k] is not None
        ]
        overrides = dict()
        for key in override_keys:
            overrides[key[len("profile."):]] = data[key]

        def slicing_done(target, gcode_name, select_after_slicing,
                         print_after_slicing):
            if select_after_slicing or print_after_slicing:
                sd = False
                if target == FileDestinations.SDCARD:
                    filenameToSelect = gcode_name
                    sd = True
                else:
                    filenameToSelect = fileManager.get_absolute_path(
                        target, gcode_name)
                printer.selectFile(filenameToSelect, sd, print_after_slicing)

        ok, result = fileManager.slice(slicer,
                                       target,
                                       filename,
                                       target,
                                       gcode_name,
                                       profile=profile,
                                       printer_profile_id=printerProfile,
                                       position=position,
                                       overrides=overrides,
                                       callback=slicing_done,
                                       callback_args=(target, gcode_name,
                                                      select_after_slicing,
                                                      print_after_slicing))

        if ok:
            files = {}
            location = url_for(".readGcodeFile",
                               target=target,
                               filename=gcode_name,
                               _external=True)
            result = {
                "name": gcode_name,
                "origin": FileDestinations.LOCAL,
                "refs": {
                    "resource":
                    location,
                    "download":
                    url_for("index", _external=True) + "downloads/files/" +
                    target + "/" + gcode_name
                }
            }

            r = make_response(jsonify(result), 202)
            r.headers["Location"] = location
            return r
        else:
            return make_response(
                "Could not slice: {result}".format(result=result), 500)

    return NO_CONTENT
Пример #32
0
def uploadGcodeFile(target):
	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
		return make_response("Unknown target: %s" % target, 404)

	if not "file" in request.files.keys():
		return make_response("No file included", 400)

	if target == FileDestinations.SDCARD and not settings().getBoolean(["feature", "sdSupport"]):
		return make_response("SD card support is disabled", 404)

	file = request.files["file"]
	sd = target == FileDestinations.SDCARD
	selectAfterUpload = "select" in request.values.keys() and request.values["select"] in valid_boolean_trues
	printAfterSelect = "print" in request.values.keys() and request.values["print"] in valid_boolean_trues

	if sd:
		# validate that all preconditions for SD upload are met before attempting it
		if not (printer.isOperational() and not (printer.isPrinting() or printer.isPaused())):
			return make_response("Can not upload to SD card, printer is either not operational or already busy", 409)
		if not printer.isSdReady():
			return make_response("Can not upload to SD card, not yet initialized", 409)

	# determine current job
	currentFilename = None
	currentSd = None
	currentJob = printer.getCurrentJob()
	if currentJob is not None and "filename" in currentJob.keys() and "sd" in currentJob.keys():
		currentFilename = currentJob["filename"]
		currentSd = currentJob["sd"]

	# determine future filename of file to be uploaded, abort if it can't be uploaded
	futureFilename = gcodeManager.getFutureFilename(file)
	if futureFilename is None or (not settings().getBoolean(["cura", "enabled"]) and not gcodefiles.isGcodeFileName(futureFilename)):
		return make_response("Can not upload file %s, wrong format?" % file.filename, 415)

	# prohibit overwriting currently selected file while it's being printed
	if futureFilename == currentFilename and sd == currentSd and printer.isPrinting() or printer.isPaused():
		return make_response("Trying to overwrite file that is currently being printed: %s" % currentFilename, 409)

	filename = None

	def fileProcessingFinished(filename, absFilename, destination):
		"""
		Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
		finished.

		Depending on the file's destination triggers either streaming to SD card or directly calls selectAndOrPrint.
		"""
		if destination == FileDestinations.SDCARD:
			return filename, printer.addSdFile(filename, absFilename, selectAndOrPrint)
		else:
			selectAndOrPrint(absFilename, destination)
			return filename

	def selectAndOrPrint(nameToSelect, destination):
		"""
		Callback for when the file is ready to be selected and optionally printed. For SD file uploads this is only
		the case after they have finished streaming to the printer, which is why this callback is also used
		for the corresponding call to addSdFile.

		Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
		exact file is already selected, such reloading it.
		"""
		sd = destination == FileDestinations.SDCARD
		if selectAfterUpload or printAfterSelect or (currentFilename == filename and currentSd == sd):
			printer.selectFile(nameToSelect, sd, printAfterSelect)

	destination = FileDestinations.SDCARD if sd else FileDestinations.LOCAL
	filename, done = gcodeManager.addFile(file, destination, fileProcessingFinished)
	if filename is None:
		return make_response("Could not upload the file %s" % file.filename, 500)

	sdFilename = None
	if isinstance(filename, tuple):
		filename, sdFilename = filename

	eventManager.fire(Events.UPLOAD, {"file": filename, "target": target})

	files = {}
	if done:
		files.update({
			FileDestinations.LOCAL: {
				"name": filename,
				"origin": FileDestinations.LOCAL,
				"refs": {
					"resource": url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=filename, _external=True),
					"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + filename
				}
			}
		})

		if sd and sdFilename:
			files.update({
				FileDestinations.SDCARD: {
					"name": sdFilename,
					"origin": FileDestinations.SDCARD,
					"refs": {
						"resource": url_for(".readGcodeFile", target=FileDestinations.SDCARD, filename=sdFilename, _external=True)
					}
				}
			})

	return make_response(jsonify(files=files, done=done), 201)
Пример #33
0
def uploadGcodeFile(target):
	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
		return make_response("Unknown target: %s" % target, 404)

	input_name = "file"
	input_upload_name = input_name + "." + settings().get(["server", "uploads", "nameSuffix"])
	input_upload_path = input_name + "." + settings().get(["server", "uploads", "pathSuffix"])
	if input_upload_name in request.values and input_upload_path in request.values:
		import shutil
		upload = util.Object()
		upload.filename = request.values[input_upload_name]
		upload.save = lambda new_path: shutil.move(request.values[input_upload_path], new_path)
	elif input_name in request.files:
		upload = request.files[input_name]
	else:
		return make_response("No file included", 400)

	if target == FileDestinations.SDCARD and not settings().getBoolean(["feature", "sdSupport"]):
		return make_response("SD card support is disabled", 404)

	sd = target == FileDestinations.SDCARD
	selectAfterUpload = "select" in request.values.keys() and request.values["select"] in valid_boolean_trues
	printAfterSelect = "print" in request.values.keys() and request.values["print"] in valid_boolean_trues

	if sd:
		# validate that all preconditions for SD upload are met before attempting it
		if not (printer.isOperational() and not (printer.isPrinting() or printer.isPaused())):
			return make_response("Can not upload to SD card, printer is either not operational or already busy", 409)
		if not printer.isSdReady():
			return make_response("Can not upload to SD card, not yet initialized", 409)

	# determine current job
	currentFilename = None
	currentOrigin = None
	currentJob = printer.getCurrentJob()
	if currentJob is not None and "file" in currentJob.keys():
		currentJobFile = currentJob["file"]
		if "name" in currentJobFile.keys() and "origin" in currentJobFile.keys():
			currentFilename = currentJobFile["name"]
			currentOrigin = currentJobFile["origin"]

	# determine future filename of file to be uploaded, abort if it can't be uploaded
	try:
		futureFilename = fileManager.sanitize_name(FileDestinations.LOCAL, upload.filename)
	except:
		futureFilename = None
	if futureFilename is None or not (slicingManager.slicing_enabled or octoprint.filemanager.valid_file_type(futureFilename, type="gcode")):
		return make_response("Can not upload file %s, wrong format?" % upload.filename, 415)

	# prohibit overwriting currently selected file while it's being printed
	if futureFilename == currentFilename and target == currentOrigin and printer.isPrinting() or printer.isPaused():
		return make_response("Trying to overwrite file that is currently being printed: %s" % currentFilename, 409)

	def fileProcessingFinished(filename, absFilename, destination):
		"""
		Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
		finished.

		Depending on the file's destination triggers either streaming to SD card or directly calls selectAndOrPrint.
		"""

		if destination == FileDestinations.SDCARD and octoprint.filemanager.valid_file_type(filename, "gcode"):
			return filename, printer.addSdFile(filename, absFilename, selectAndOrPrint)
		else:
			selectAndOrPrint(filename, absFilename, destination)
			return filename

	def selectAndOrPrint(filename, absFilename, destination):
		"""
		Callback for when the file is ready to be selected and optionally printed. For SD file uploads this is only
		the case after they have finished streaming to the printer, which is why this callback is also used
		for the corresponding call to addSdFile.

		Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
		exact file is already selected, such reloading it.
		"""
		if octoprint.filemanager.valid_file_type(added_file, "gcode") and (selectAfterUpload or printAfterSelect or (currentFilename == filename and currentOrigin == destination)):
			printer.selectFile(absFilename, destination == FileDestinations.SDCARD, printAfterSelect)

	added_file = fileManager.add_file(FileDestinations.LOCAL, upload.filename, upload, allow_overwrite=True)
	if added_file is None:
		return make_response("Could not upload the file %s" % upload.filename, 500)
	if octoprint.filemanager.valid_file_type(added_file, "stl"):
		filename = added_file
		done = True
	else:
		filename = fileProcessingFinished(added_file, fileManager.get_absolute_path(FileDestinations.LOCAL, added_file), target)
		done = True

	sdFilename = None
	if isinstance(filename, tuple):
		filename, sdFilename = filename

	eventManager.fire(Events.UPLOAD, {"file": filename, "target": target})

	files = {}
	location = url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=filename, _external=True)
	files.update({
		FileDestinations.LOCAL: {
			"name": filename,
			"origin": FileDestinations.LOCAL,
			"refs": {
				"resource": location,
				"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + filename
			}
		}
	})

	if sd and sdFilename:
		location = url_for(".readGcodeFile", target=FileDestinations.SDCARD, filename=sdFilename, _external=True)
		files.update({
			FileDestinations.SDCARD: {
				"name": sdFilename,
				"origin": FileDestinations.SDCARD,
				"refs": {
					"resource": location
				}
			}
		})

	r = make_response(jsonify(files=files, done=done), 201)
	r.headers["Location"] = location
	return r