mirror of
https://github.com/Ultimaker/Cura.git
synced 2026-02-10 10:49:27 -07:00
Merge branch 'master' of github.com:ultimaker/Cura into per_object_settings
* 'master' of github.com:ultimaker/Cura: (98 commits) 15.10 Restyling of the message stack Fixed machine head polygons Removed unused settings from fdmprinter Added action for togling fullscreen Fixed usage of wrong checkbox in viewpage Added preference to disable automatic push free Added preference to disable auto center when selecting object Cleanup 15.10 Restyling toolbar, viewmode button Update README.md Update README.md Added rudementary 3 point bed leveling 15.10 New font for Cura 15.10 Changes the styling for the open file button 15.10 Changes the label names for the different action buttons Fixed typo Endstop now stops listening upon destruction 15.10 Re-alignment of the messagestack Cleaned up code a bit Added heated bed check ...
This commit is contained in:
Arjen Hiemstra
commit
f099c30dfd
66 changed files with 2608 additions and 1842 deletions
124
plugins/3MFReader/ThreeMFReader.py
Normal file
124
plugins/3MFReader/ThreeMFReader.py
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
# Copyright (c) 2015 Ultimaker B.V.
|
||||
# Cura is released under the terms of the AGPLv3 or higher.
|
||||
|
||||
from UM.Mesh.MeshReader import MeshReader
|
||||
from UM.Mesh.MeshData import MeshData
|
||||
from UM.Logger import Logger
|
||||
from UM.Math.Matrix import Matrix
|
||||
from UM.Math.Vector import Vector
|
||||
from UM.Scene.SceneNode import SceneNode
|
||||
from UM.Scene.GroupDecorator import GroupDecorator
|
||||
from UM.Math.Quaternion import Quaternion
|
||||
|
||||
|
||||
import os
|
||||
import struct
|
||||
import math
|
||||
from os import listdir
|
||||
import zipfile
|
||||
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
## Base implementation for reading 3MF files. Has no support for textures. Only loads meshes!
|
||||
class ThreeMFReader(MeshReader):
|
||||
def __init__(self):
|
||||
super(ThreeMFReader, self).__init__()
|
||||
self._supported_extension = ".3mf"
|
||||
|
||||
self._namespaces = {
|
||||
"3mf": "http://schemas.microsoft.com/3dmanufacturing/core/2015/02",
|
||||
"cura": "http://software.ultimaker.com/xml/cura/3mf/2015/10"
|
||||
}
|
||||
|
||||
def read(self, file_name):
|
||||
result = None
|
||||
extension = os.path.splitext(file_name)[1]
|
||||
if extension.lower() == self._supported_extension:
|
||||
result = SceneNode()
|
||||
# The base object of 3mf is a zipped archive.
|
||||
archive = zipfile.ZipFile(file_name, 'r')
|
||||
try:
|
||||
root = ET.parse(archive.open("3D/3dmodel.model"))
|
||||
|
||||
# There can be multiple objects, try to load all of them.
|
||||
objects = root.findall("./3mf:resources/3mf:object", self._namespaces)
|
||||
for object in objects:
|
||||
mesh = MeshData()
|
||||
node = SceneNode()
|
||||
vertex_list = []
|
||||
#for vertex in object.mesh.vertices.vertex:
|
||||
for vertex in object.findall(".//3mf:vertex", self._namespaces):
|
||||
vertex_list.append([vertex.get("x"), vertex.get("y"), vertex.get("z")])
|
||||
|
||||
triangles = object.findall(".//3mf:triangle", self._namespaces)
|
||||
|
||||
mesh.reserveFaceCount(len(triangles))
|
||||
|
||||
#for triangle in object.mesh.triangles.triangle:
|
||||
for triangle in triangles:
|
||||
v1 = int(triangle.get("v1"))
|
||||
v2 = int(triangle.get("v2"))
|
||||
v3 = int(triangle.get("v3"))
|
||||
mesh.addFace(vertex_list[v1][0],vertex_list[v1][1],vertex_list[v1][2],vertex_list[v2][0],vertex_list[v2][1],vertex_list[v2][2],vertex_list[v3][0],vertex_list[v3][1],vertex_list[v3][2])
|
||||
#TODO: We currently do not check for normals and simply recalculate them.
|
||||
mesh.calculateNormals()
|
||||
node.setMeshData(mesh)
|
||||
node.setSelectable(True)
|
||||
|
||||
transformation = root.findall("./3mf:build/3mf:item[@objectid='{0}']".format(object.get("id")), self._namespaces)
|
||||
if transformation:
|
||||
transformation = transformation[0]
|
||||
|
||||
if transformation.get("transform"):
|
||||
splitted_transformation = transformation.get("transform").split()
|
||||
## Transformation is saved as:
|
||||
## M00 M01 M02 0.0
|
||||
## M10 M11 M12 0.0
|
||||
## M20 M21 M22 0.0
|
||||
## M30 M31 M32 1.0
|
||||
## We switch the row & cols as that is how everyone else uses matrices!
|
||||
temp_mat = Matrix()
|
||||
# Rotation & Scale
|
||||
temp_mat._data[0,0] = splitted_transformation[0]
|
||||
temp_mat._data[1,0] = splitted_transformation[1]
|
||||
temp_mat._data[2,0] = splitted_transformation[2]
|
||||
temp_mat._data[0,1] = splitted_transformation[3]
|
||||
temp_mat._data[1,1] = splitted_transformation[4]
|
||||
temp_mat._data[2,1] = splitted_transformation[5]
|
||||
temp_mat._data[0,2] = splitted_transformation[6]
|
||||
temp_mat._data[1,2] = splitted_transformation[7]
|
||||
temp_mat._data[2,2] = splitted_transformation[8]
|
||||
|
||||
# Translation
|
||||
temp_mat._data[0,3] = splitted_transformation[9]
|
||||
temp_mat._data[1,3] = splitted_transformation[10]
|
||||
temp_mat._data[2,3] = splitted_transformation[11]
|
||||
|
||||
node.setPosition(Vector(temp_mat.at(0,3), temp_mat.at(1,3), temp_mat.at(2,3)))
|
||||
|
||||
temp_quaternion = Quaternion()
|
||||
temp_quaternion.setByMatrix(temp_mat)
|
||||
node.setOrientation(temp_quaternion)
|
||||
|
||||
# Magical scale extraction
|
||||
S2 = temp_mat.getTransposed().multiply(temp_mat)
|
||||
scale_x = math.sqrt(S2.at(0,0))
|
||||
scale_y = math.sqrt(S2.at(1,1))
|
||||
scale_z = math.sqrt(S2.at(2,2))
|
||||
node.setScale(Vector(scale_x,scale_y,scale_z))
|
||||
|
||||
# We use a different coordinate frame, so rotate.
|
||||
rotation = Quaternion.fromAngleAxis(-0.5 * math.pi, Vector(1,0,0))
|
||||
node.rotate(rotation)
|
||||
result.addChild(node)
|
||||
|
||||
#If there is more then one object, group them.
|
||||
try:
|
||||
if len(objects) > 1:
|
||||
group_decorator = GroupDecorator()
|
||||
result.addDecorator(group_decorator)
|
||||
except:
|
||||
pass
|
||||
except Exception as e:
|
||||
Logger.log("e" ,"exception occured in 3mf reader: %s" , e)
|
||||
return result
|
||||
25
plugins/3MFReader/__init__.py
Normal file
25
plugins/3MFReader/__init__.py
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
# Copyright (c) 2015 Ultimaker B.V.
|
||||
# Cura is released under the terms of the AGPLv3 or higher.
|
||||
|
||||
from UM.i18n import i18nCatalog
|
||||
catalog = i18nCatalog("cura")
|
||||
|
||||
from . import ThreeMFReader
|
||||
|
||||
def getMetaData():
|
||||
return {
|
||||
"plugin": {
|
||||
"name": "3MF Reader",
|
||||
"author": "Ultimaker",
|
||||
"version": "1.0",
|
||||
"description": catalog.i18nc("3MF Reader plugin description", "Provides support for reading 3MF files."),
|
||||
"api": 2
|
||||
},
|
||||
"mesh_reader": {
|
||||
"extension": "3mf",
|
||||
"description": catalog.i18nc("3MF Reader plugin file type", "3MF File")
|
||||
}
|
||||
}
|
||||
|
||||
def register(app):
|
||||
return { "mesh_reader": ThreeMFReader.ThreeMFReader() }
|
||||
|
|
@ -17,8 +17,8 @@ class RemovableDriveOutputDevice(OutputDevice):
|
|||
super().__init__(device_id)
|
||||
|
||||
self.setName(device_name)
|
||||
self.setShortDescription(catalog.i18nc("", "Save to Removable Drive"))
|
||||
self.setDescription(catalog.i18nc("", "Save to Removable Drive {0}").format(device_name))
|
||||
self.setShortDescription(catalog.i18nc("@action:button", "Save to Removable Drive"))
|
||||
self.setDescription(catalog.i18nc("@info:tooltip", "Save to Removable Drive {0}").format(device_name))
|
||||
self.setIconName("save_sd")
|
||||
self.setPriority(1)
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ class RemovableDriveOutputDevice(OutputDevice):
|
|||
job.progress.connect(self._onProgress)
|
||||
job.finished.connect(self._onFinished)
|
||||
|
||||
message = Message(catalog.i18nc("", "Saving to Removable Drive {0}").format(self.getName()), 0, False, -1)
|
||||
message = Message(catalog.i18nc("@info:status", "Saving to Removable Drive <filename>{0}</filename>").format(self.getName()), 0, False, -1)
|
||||
message.show()
|
||||
|
||||
job._message = message
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ UM.Dialog
|
|||
Column
|
||||
{
|
||||
anchors.fill: parent;
|
||||
|
||||
|
||||
Text
|
||||
{
|
||||
anchors {
|
||||
|
|
|
|||
|
|
@ -8,96 +8,156 @@ import time
|
|||
import queue
|
||||
import re
|
||||
import functools
|
||||
import os
|
||||
import os.path
|
||||
|
||||
from UM.Application import Application
|
||||
from UM.Signal import Signal, SignalEmitter
|
||||
from UM.Resources import Resources
|
||||
from UM.Logger import Logger
|
||||
from UM.OutputDevice.OutputDevice import OutputDevice
|
||||
from UM.OutputDevice import OutputDeviceError
|
||||
from UM.PluginRegistry import PluginRegistry
|
||||
|
||||
from PyQt5.QtQuick import QQuickView
|
||||
from PyQt5.QtQml import QQmlComponent, QQmlContext
|
||||
from PyQt5.QtCore import QUrl, QObject, pyqtSlot, pyqtProperty, pyqtSignal, Qt
|
||||
|
||||
from UM.i18n import i18nCatalog
|
||||
catalog = i18nCatalog("cura")
|
||||
|
||||
class PrinterConnection(OutputDevice, QObject, SignalEmitter):
|
||||
def __init__(self, serial_port, parent = None):
|
||||
QObject.__init__(self, parent)
|
||||
OutputDevice.__init__(self, serial_port)
|
||||
SignalEmitter.__init__(self)
|
||||
#super().__init__(serial_port)
|
||||
self.setName(catalog.i18nc("@item:inmenu", "USB printing"))
|
||||
self.setShortDescription(catalog.i18nc("@action:button", "Print with USB"))
|
||||
self.setDescription(catalog.i18nc("@info:tooltip", "Print with USB"))
|
||||
self.setIconName("print")
|
||||
|
||||
class PrinterConnection(SignalEmitter):
|
||||
def __init__(self, serial_port):
|
||||
super().__init__()
|
||||
|
||||
self._serial = None
|
||||
self._serial_port = serial_port
|
||||
self._error_state = None
|
||||
|
||||
|
||||
self._connect_thread = threading.Thread(target = self._connect)
|
||||
self._connect_thread.daemon = True
|
||||
|
||||
|
||||
self._end_stop_thread = threading.Thread(target = self._pollEndStop)
|
||||
self._end_stop_thread.deamon = True
|
||||
|
||||
# Printer is connected
|
||||
self._is_connected = False
|
||||
|
||||
|
||||
# Printer is in the process of connecting
|
||||
self._is_connecting = False
|
||||
|
||||
|
||||
# The baud checking is done by sending a number of m105 commands to the printer and waiting for a readable
|
||||
# response. If the baudrate is correct, this should make sense, else we get giberish.
|
||||
self._required_responses_auto_baud = 10
|
||||
|
||||
self._required_responses_auto_baud = 3
|
||||
|
||||
self._progress = 0
|
||||
|
||||
|
||||
self._listen_thread = threading.Thread(target=self._listen)
|
||||
self._listen_thread.daemon = True
|
||||
|
||||
|
||||
self._update_firmware_thread = threading.Thread(target= self._updateFirmware)
|
||||
self._update_firmware_thread.demon = True
|
||||
self._update_firmware_thread.deamon = True
|
||||
|
||||
self._heatup_wait_start_time = time.time()
|
||||
|
||||
|
||||
## Queue for commands that need to be send. Used when command is sent when a print is active.
|
||||
self._command_queue = queue.Queue()
|
||||
|
||||
|
||||
self._is_printing = False
|
||||
|
||||
|
||||
## Set when print is started in order to check running time.
|
||||
self._print_start_time = None
|
||||
self._print_start_time_100 = None
|
||||
|
||||
|
||||
## Keep track where in the provided g-code the print is
|
||||
self._gcode_position = 0
|
||||
|
||||
|
||||
# List of gcode lines to be printed
|
||||
self._gcode = []
|
||||
|
||||
|
||||
# Number of extruders
|
||||
self._extruder_count = 1
|
||||
|
||||
|
||||
# Temperatures of all extruders
|
||||
self._extruder_temperatures = [0] * self._extruder_count
|
||||
|
||||
|
||||
# Target temperatures of all extruders
|
||||
self._target_extruder_temperatures = [0] * self._extruder_count
|
||||
|
||||
|
||||
#Target temperature of the bed
|
||||
self._target_bed_temperature = 0
|
||||
|
||||
|
||||
# Temperature of the bed
|
||||
self._bed_temperature = 0
|
||||
|
||||
|
||||
# Current Z stage location
|
||||
self._current_z = 0
|
||||
|
||||
|
||||
self._x_min_endstop_pressed = False
|
||||
self._y_min_endstop_pressed = False
|
||||
self._z_min_endstop_pressed = False
|
||||
|
||||
self._x_max_endstop_pressed = False
|
||||
self._y_max_endstop_pressed = False
|
||||
self._z_max_endstop_pressed = False
|
||||
|
||||
# In order to keep the connection alive we request the temperature every so often from a different extruder.
|
||||
# This index is the extruder we requested data from the last time.
|
||||
self._temperature_requested_extruder_index = 0
|
||||
|
||||
|
||||
self._updating_firmware = False
|
||||
|
||||
|
||||
self._firmware_file_name = None
|
||||
|
||||
|
||||
self._control_view = None
|
||||
|
||||
onError = pyqtSignal()
|
||||
progressChanged = pyqtSignal()
|
||||
extruderTemperatureChanged = pyqtSignal()
|
||||
bedTemperatureChanged = pyqtSignal()
|
||||
|
||||
endstopStateChanged = pyqtSignal(str ,bool, arguments = ["key","state"])
|
||||
|
||||
@pyqtProperty(float, notify = progressChanged)
|
||||
def progress(self):
|
||||
return self._progress
|
||||
|
||||
@pyqtProperty(float, notify = extruderTemperatureChanged)
|
||||
def extruderTemperature(self):
|
||||
return self._extruder_temperatures[0]
|
||||
|
||||
@pyqtProperty(float, notify = bedTemperatureChanged)
|
||||
def bedTemperature(self):
|
||||
return self._bed_temperature
|
||||
|
||||
@pyqtProperty(str, notify = onError)
|
||||
def error(self):
|
||||
return self._error_state
|
||||
|
||||
# TODO: Might need to add check that extruders can not be changed when it started printing or loading these settings from settings object
|
||||
def setNumExtuders(self, num):
|
||||
self._extruder_count = num
|
||||
self._extruder_temperatures = [0] * self._extruder_count
|
||||
self._target_extruder_temperatures = [0] * self._extruder_count
|
||||
|
||||
|
||||
## Is the printer actively printing
|
||||
def isPrinting(self):
|
||||
if not self._is_connected or self._serial is None:
|
||||
return False
|
||||
return self._is_printing
|
||||
|
||||
@pyqtSlot()
|
||||
def startPrint(self):
|
||||
gcode_list = getattr( Application.getInstance().getController().getScene(), "gcode_list")
|
||||
self.printGCode(gcode_list)
|
||||
|
||||
## Start a print based on a g-code.
|
||||
# \param gcode_list List with gcode (strings).
|
||||
def printGCode(self, gcode_list):
|
||||
|
|
@ -115,20 +175,20 @@ class PrinterConnection(SignalEmitter):
|
|||
self._print_start_time_100 = None
|
||||
self._is_printing = True
|
||||
self._print_start_time = time.time()
|
||||
|
||||
|
||||
for i in range(0, 4): #Push first 4 entries before accepting other inputs
|
||||
self._sendNextGcodeLine()
|
||||
|
||||
|
||||
## Get the serial port string of this connection.
|
||||
# \return serial port
|
||||
def getSerialPort(self):
|
||||
return self._serial_port
|
||||
|
||||
|
||||
## Try to connect the serial. This simply starts the thread, which runs _connect.
|
||||
def connect(self):
|
||||
if not self._updating_firmware and not self._connect_thread.isAlive():
|
||||
self._connect_thread.start()
|
||||
|
||||
|
||||
## Private fuction (threaded) that actually uploads the firmware.
|
||||
def _updateFirmware(self):
|
||||
if self._is_connecting or self._is_connected:
|
||||
|
|
@ -162,6 +222,8 @@ class PrinterConnection(SignalEmitter):
|
|||
|
||||
self.setProgress(100, 100)
|
||||
|
||||
self.firmwareUpdateComplete.emit()
|
||||
|
||||
## Upload new firmware to machine
|
||||
# \param filename full path of firmware file to be uploaded
|
||||
def updateFirmware(self, file_name):
|
||||
|
|
@ -169,14 +231,28 @@ class PrinterConnection(SignalEmitter):
|
|||
self._firmware_file_name = file_name
|
||||
self._update_firmware_thread.start()
|
||||
|
||||
@pyqtSlot()
|
||||
def startPollEndstop(self):
|
||||
self._poll_endstop = True
|
||||
self._end_stop_thread.start()
|
||||
|
||||
@pyqtSlot()
|
||||
def stopPollEndstop(self):
|
||||
self._poll_endstop = False
|
||||
|
||||
def _pollEndStop(self):
|
||||
while self._is_connected and self._poll_endstop:
|
||||
self.sendCommand("M119")
|
||||
time.sleep(0.5)
|
||||
|
||||
## Private connect function run by thread. Can be started by calling connect.
|
||||
def _connect(self):
|
||||
Logger.log("d", "Attempting to connect to %s", self._serial_port)
|
||||
self._is_connecting = True
|
||||
programmer = stk500v2.Stk500v2()
|
||||
programmer = stk500v2.Stk500v2()
|
||||
try:
|
||||
programmer.connect(self._serial_port) # Connect with the serial, if this succeeds, it"s an arduino based usb device.
|
||||
self._serial = programmer.leaveISP()
|
||||
self._serial = programmer.leaveISP()
|
||||
except ispBase.IspError as e:
|
||||
Logger.log("i", "Could not establish connection on %s: %s. Device is not arduino based." %(self._serial_port,str(e)))
|
||||
except Exception as e:
|
||||
|
|
@ -186,25 +262,23 @@ class PrinterConnection(SignalEmitter):
|
|||
self._is_connecting = False
|
||||
Logger.log("i", "Could not establish connection on %s, unknown reasons.", self._serial_port)
|
||||
return
|
||||
|
||||
|
||||
# If the programmer connected, we know its an atmega based version. Not all that usefull, but it does give some debugging information.
|
||||
for baud_rate in self._getBaudrateList(): # Cycle all baud rates (auto detect)
|
||||
|
||||
if self._serial is None:
|
||||
try:
|
||||
self._serial = serial.Serial(str(self._serial_port), baud_rate, timeout=3, writeTimeout=10000)
|
||||
self._serial = serial.Serial(str(self._serial_port), baud_rate, timeout = 3, writeTimeout = 10000)
|
||||
except serial.SerialException:
|
||||
Logger.log("i", "Could not open port %s" % self._serial_port)
|
||||
return
|
||||
else:
|
||||
else:
|
||||
if not self.setBaudRate(baud_rate):
|
||||
continue # Could not set the baud rate, go to the next
|
||||
time.sleep(1.5) # Ensure that we are not talking to the bootloader. 1.5 sec seems to be the magic number
|
||||
sucesfull_responses = 0
|
||||
timeout_time = time.time() + 15
|
||||
timeout_time = time.time() + 5
|
||||
self._serial.write(b"\n")
|
||||
self._sendCommand("M105") # Request temperature, as this should (if baudrate is correct) result in a command with "T:" in it
|
||||
|
||||
while timeout_time > time.time():
|
||||
line = self._readline()
|
||||
if line is None:
|
||||
|
|
@ -213,7 +287,6 @@ class PrinterConnection(SignalEmitter):
|
|||
|
||||
if b"T:" in line:
|
||||
self._serial.timeout = 0.5
|
||||
self._sendCommand("M105")
|
||||
sucesfull_responses += 1
|
||||
if sucesfull_responses >= self._required_responses_auto_baud:
|
||||
self._serial.timeout = 2 #Reset serial timeout
|
||||
|
|
@ -221,6 +294,8 @@ class PrinterConnection(SignalEmitter):
|
|||
Logger.log("i", "Established printer connection on port %s" % self._serial_port)
|
||||
return
|
||||
|
||||
self._sendCommand("M105") # Send M105 as long as we are listening, otherwise we end up in an undefined state
|
||||
|
||||
Logger.log("e", "Baud rate detection for %s failed", self._serial_port)
|
||||
self.close() # Unable to connect, wrap up.
|
||||
self.setIsConnected(False)
|
||||
|
|
@ -240,21 +315,12 @@ class PrinterConnection(SignalEmitter):
|
|||
self.connectionStateChanged.emit(self._serial_port)
|
||||
if self._is_connected:
|
||||
self._listen_thread.start() #Start listening
|
||||
#Application.getInstance().addOutputDevice(self._serial_port, {
|
||||
#"id": self._serial_port,
|
||||
#"function": self.printGCode,
|
||||
#"shortDescription": "Print with USB",
|
||||
#"description": "Print with USB {0}".format(self._serial_port),
|
||||
#"icon": "save",
|
||||
#"priority": 1
|
||||
#})
|
||||
|
||||
else:
|
||||
Logger.log("w", "Printer connection state was not changed")
|
||||
|
||||
connectionStateChanged = Signal()
|
||||
|
||||
## Close the printer connection
|
||||
|
||||
connectionStateChanged = Signal()
|
||||
|
||||
## Close the printer connection
|
||||
def close(self):
|
||||
if self._connect_thread.isAlive():
|
||||
try:
|
||||
|
|
@ -262,6 +328,9 @@ class PrinterConnection(SignalEmitter):
|
|||
except Exception as e:
|
||||
pass # This should work, but it does fail sometimes for some reason
|
||||
|
||||
self._connect_thread = threading.Thread(target=self._connect)
|
||||
self._connect_thread.daemon = True
|
||||
|
||||
if self._serial is not None:
|
||||
self.setIsConnected(False)
|
||||
try:
|
||||
|
|
@ -269,12 +338,31 @@ class PrinterConnection(SignalEmitter):
|
|||
except:
|
||||
pass
|
||||
self._serial.close()
|
||||
|
||||
|
||||
self._listen_thread = threading.Thread(target=self._listen)
|
||||
self._listen_thread.daemon = True
|
||||
self._serial = None
|
||||
|
||||
|
||||
def isConnected(self):
|
||||
return self._is_connected
|
||||
|
||||
|
||||
@pyqtSlot(int)
|
||||
def heatupNozzle(self, temperature):
|
||||
self._sendCommand("M104 S%s" % temperature)
|
||||
|
||||
@pyqtSlot(int)
|
||||
def heatupBed(self, temperature):
|
||||
self._sendCommand("M140 S%s" % temperature)
|
||||
|
||||
@pyqtSlot("long", "long","long")
|
||||
def moveHead(self, x, y, z):
|
||||
print("Moving head" , x , " ", y , " " , z)
|
||||
self._sendCommand("G0 X%s Y%s Z%s"%(x,y,z))
|
||||
|
||||
@pyqtSlot()
|
||||
def homeHead(self):
|
||||
self._sendCommand("G28")
|
||||
|
||||
## Directly send the command, withouth checking connection state (eg; printing).
|
||||
# \param cmd string with g-code
|
||||
def _sendCommand(self, cmd):
|
||||
|
|
@ -296,10 +384,9 @@ class PrinterConnection(SignalEmitter):
|
|||
self._target_bed_temperature = float(re.search("S([0-9]+)", cmd).group(1))
|
||||
except:
|
||||
pass
|
||||
#Logger.log("i","Sending: %s" % (cmd))
|
||||
try:
|
||||
command = (cmd + "\n").encode()
|
||||
#self._serial.write(b"\n")
|
||||
self._serial.write(b"\n")
|
||||
self._serial.write(command)
|
||||
except serial.SerialTimeoutException:
|
||||
Logger.log("w","Serial timeout while writing to serial port, trying again.")
|
||||
|
|
@ -314,11 +401,26 @@ class PrinterConnection(SignalEmitter):
|
|||
Logger.log("e","Unexpected error while writing serial port %s" % e)
|
||||
self._setErrorState("Unexpected error while writing serial port %s " % e)
|
||||
self.close()
|
||||
|
||||
|
||||
## Ensure that close gets called when object is destroyed
|
||||
def __del__(self):
|
||||
self.close()
|
||||
|
||||
|
||||
def createControlInterface(self):
|
||||
if self._control_view is None:
|
||||
path = QUrl.fromLocalFile(os.path.join(PluginRegistry.getInstance().getPluginPath("USBPrinting"), "ControlWindow.qml"))
|
||||
component = QQmlComponent(Application.getInstance()._engine, path)
|
||||
self._control_context = QQmlContext(Application.getInstance()._engine.rootContext())
|
||||
self._control_context.setContextProperty("manager", self)
|
||||
self._control_view = component.create(self._control_context)
|
||||
|
||||
## Show control interface.
|
||||
# This will create the view if its not already created.
|
||||
def showControlInterface(self):
|
||||
if self._control_view is None:
|
||||
self.createControlInterface()
|
||||
self._control_view.show()
|
||||
|
||||
## Send a command to printer.
|
||||
# \param cmd string with g-code
|
||||
def sendCommand(self, cmd):
|
||||
|
|
@ -326,37 +428,47 @@ class PrinterConnection(SignalEmitter):
|
|||
self._command_queue.put(cmd)
|
||||
elif self.isConnected():
|
||||
self._sendCommand(cmd)
|
||||
|
||||
|
||||
## Set the error state with a message.
|
||||
# \param error String with the error message.
|
||||
def _setErrorState(self, error):
|
||||
self._error_state = error
|
||||
self.onError.emit(error)
|
||||
|
||||
onError = Signal()
|
||||
|
||||
self.onError.emit()
|
||||
|
||||
## Private function to set the temperature of an extruder
|
||||
# \param index index of the extruder
|
||||
# \param temperature recieved temperature
|
||||
def _setExtruderTemperature(self, index, temperature):
|
||||
try:
|
||||
self._extruder_temperatures[index] = temperature
|
||||
self.onExtruderTemperatureChange.emit(self._serial_port, index, temperature)
|
||||
self.extruderTemperatureChanged.emit()
|
||||
except Exception as e:
|
||||
pass
|
||||
|
||||
onExtruderTemperatureChange = Signal()
|
||||
|
||||
|
||||
## Private function to set the temperature of the bed.
|
||||
# As all printers (as of time of writing) only support a single heated bed,
|
||||
# these are not indexed as with extruders.
|
||||
def _setBedTemperature(self, temperature):
|
||||
self._bed_temperature = temperature
|
||||
self.onBedTemperatureChange.emit(self._serial_port,temperature)
|
||||
|
||||
onBedTemperatureChange = Signal()
|
||||
|
||||
|
||||
self.bedTemperatureChanged.emit()
|
||||
|
||||
def requestWrite(self, node):
|
||||
self.showControlInterface()
|
||||
|
||||
def _setEndstopState(self, endstop_key, value):
|
||||
if endstop_key == b'x_min':
|
||||
if self._x_min_endstop_pressed != value:
|
||||
self.endstopStateChanged.emit('x_min', value)
|
||||
self._x_min_endstop_pressed = value
|
||||
elif endstop_key == b'y_min':
|
||||
if self._y_min_endstop_pressed != value:
|
||||
self.endstopStateChanged.emit('y_min', value)
|
||||
self._y_min_endstop_pressed = value
|
||||
elif endstop_key == b'z_min':
|
||||
if self._z_min_endstop_pressed != value:
|
||||
self.endstopStateChanged.emit('z_min', value)
|
||||
self._z_min_endstop_pressed = value
|
||||
|
||||
## Listen thread function.
|
||||
def _listen(self):
|
||||
Logger.log("i", "Printer connection listen thread started for %s" % self._serial_port)
|
||||
|
|
@ -364,10 +476,18 @@ class PrinterConnection(SignalEmitter):
|
|||
ok_timeout = time.time()
|
||||
while self._is_connected:
|
||||
line = self._readline()
|
||||
|
||||
|
||||
if line is None:
|
||||
break # None is only returned when something went wrong. Stop listening
|
||||
|
||||
|
||||
if time.time() > temperature_request_timeout:
|
||||
if self._extruder_count > 0:
|
||||
self._temperature_requested_extruder_index = (self._temperature_requested_extruder_index + 1) % self._extruder_count
|
||||
self.sendCommand("M105 T%d" % (self._temperature_requested_extruder_index))
|
||||
else:
|
||||
self.sendCommand("M105")
|
||||
temperature_request_timeout = time.time() + 5
|
||||
|
||||
if line.startswith(b"Error:"):
|
||||
# Oh YEAH, consistency.
|
||||
# Marlin reports an MIN/MAX temp error as "Error:x\n: Extruder switched off. MAXTEMP triggered !\n"
|
||||
|
|
@ -392,19 +512,14 @@ class PrinterConnection(SignalEmitter):
|
|||
except Exception as e:
|
||||
pass
|
||||
#TODO: temperature changed callback
|
||||
elif b"_min" in line or b"_max" in line:
|
||||
tag, value = line.split(b':', 1)
|
||||
self._setEndstopState(tag,(b'H' in value or b'TRIGGERED' in value))
|
||||
|
||||
if self._is_printing:
|
||||
if time.time() > temperature_request_timeout: # When printing, request temperature every 5 seconds.
|
||||
if self._extruder_count > 0:
|
||||
self._temperature_requested_extruder_index = (self._temperature_requested_extruder_index + 1) % self._extruder_count
|
||||
self.sendCommand("M105 T%d" % (self._temperature_requested_extruder_index))
|
||||
else:
|
||||
self.sendCommand("M105")
|
||||
temperature_request_timeout = time.time() + 5
|
||||
|
||||
if line == b"" and time.time() > ok_timeout:
|
||||
line = b"ok" # Force a timeout (basicly, send next command)
|
||||
|
||||
|
||||
if b"ok" in line:
|
||||
ok_timeout = time.time() + 5
|
||||
if not self._command_queue.empty():
|
||||
|
|
@ -449,26 +564,25 @@ class PrinterConnection(SignalEmitter):
|
|||
Logger.log("e", "Unexpected error with printer connection: %s" % e)
|
||||
self._setErrorState("Unexpected error: %s" %e)
|
||||
checksum = functools.reduce(lambda x,y: x^y, map(ord, "N%d%s" % (self._gcode_position, line)))
|
||||
|
||||
|
||||
self._sendCommand("N%d%s*%d" % (self._gcode_position, line, checksum))
|
||||
self._gcode_position += 1
|
||||
self.setProgress(( self._gcode_position / len(self._gcode)) * 100)
|
||||
self.progressChanged.emit(self._progress, self._serial_port)
|
||||
|
||||
progressChanged = Signal()
|
||||
|
||||
self.progressChanged.emit()
|
||||
|
||||
## Set the progress of the print.
|
||||
# It will be normalized (based on max_progress) to range 0 - 100
|
||||
def setProgress(self, progress, max_progress = 100):
|
||||
self._progress = (progress / max_progress) * 100 #Convert to scale of 0-100
|
||||
self.progressChanged.emit(self._progress, self._serial_port)
|
||||
|
||||
self.progressChanged.emit()
|
||||
|
||||
## Cancel the current print. Printer connection wil continue to listen.
|
||||
@pyqtSlot()
|
||||
def cancelPrint(self):
|
||||
self._gcode_position = 0
|
||||
self.setProgress(0)
|
||||
self._gcode = []
|
||||
|
||||
|
||||
# Turn of temperatures
|
||||
self._sendCommand("M140 S0")
|
||||
self._sendCommand("M104 S0")
|
||||
|
|
@ -477,7 +591,7 @@ class PrinterConnection(SignalEmitter):
|
|||
## Check if the process did not encounter an error yet.
|
||||
def hasError(self):
|
||||
return self._error_state != None
|
||||
|
||||
|
||||
## private read line used by printer connection to listen for data on serial port.
|
||||
def _readline(self):
|
||||
if self._serial is None:
|
||||
|
|
@ -490,9 +604,16 @@ class PrinterConnection(SignalEmitter):
|
|||
self.close()
|
||||
return None
|
||||
return ret
|
||||
|
||||
|
||||
## Create a list of baud rates at which we can communicate.
|
||||
# \return list of int
|
||||
def _getBaudrateList(self):
|
||||
ret = [250000, 230400, 115200, 57600, 38400, 19200, 9600]
|
||||
return ret
|
||||
|
||||
def _onFirmwareUpdateComplete(self):
|
||||
self._update_firmware_thread.join()
|
||||
self._update_firmware_thread = threading.Thread(target= self._updateFirmware)
|
||||
self._update_firmware_thread.deamon = True
|
||||
|
||||
self.connect()
|
||||
|
|
|
|||
|
|
@ -9,6 +9,8 @@ from UM.Scene.SceneNode import SceneNode
|
|||
from UM.Resources import Resources
|
||||
from UM.Logger import Logger
|
||||
from UM.PluginRegistry import PluginRegistry
|
||||
from UM.OutputDevice.OutputDevicePlugin import OutputDevicePlugin
|
||||
from UM.Qt.ListModel import ListModel
|
||||
|
||||
import threading
|
||||
import platform
|
||||
|
|
@ -26,34 +28,48 @@ from PyQt5.QtCore import QUrl, QObject, pyqtSlot, pyqtProperty, pyqtSignal, Qt
|
|||
from UM.i18n import i18nCatalog
|
||||
i18n_catalog = i18nCatalog("cura")
|
||||
|
||||
class USBPrinterManager(QObject, SignalEmitter, Extension):
|
||||
class USBPrinterManager(QObject, SignalEmitter, OutputDevicePlugin, Extension):
|
||||
def __init__(self, parent = None):
|
||||
super().__init__(parent)
|
||||
QObject.__init__(self, parent)
|
||||
SignalEmitter.__init__(self)
|
||||
OutputDevicePlugin.__init__(self)
|
||||
Extension.__init__(self)
|
||||
self._serial_port_list = []
|
||||
self._printer_connections = []
|
||||
self._check_ports_thread = threading.Thread(target = self._updateConnectionList)
|
||||
self._check_ports_thread.daemon = True
|
||||
self._check_ports_thread.start()
|
||||
|
||||
self._progress = 0
|
||||
self._printer_connections = {}
|
||||
self._printer_connections_model = None
|
||||
self._update_thread = threading.Thread(target = self._updateThread)
|
||||
self._update_thread.setDaemon(True)
|
||||
|
||||
self._control_view = None
|
||||
self._check_updates = True
|
||||
self._firmware_view = None
|
||||
self._extruder_temp = 0
|
||||
self._bed_temp = 0
|
||||
self._error_message = ""
|
||||
|
||||
|
||||
## Add menu item to top menu of the application.
|
||||
self.setMenuName("Firmware")
|
||||
self.addMenuItem(i18n_catalog.i18n("Update Firmware"), self.updateAllFirmware)
|
||||
|
||||
Application.getInstance().applicationShuttingDown.connect(self._onApplicationShuttingDown)
|
||||
|
||||
pyqtError = pyqtSignal(str, arguments = ["error"])
|
||||
processingProgress = pyqtSignal(float, arguments = ["amount"])
|
||||
pyqtExtruderTemperature = pyqtSignal(float, arguments = ["amount"])
|
||||
pyqtBedTemperature = pyqtSignal(float, arguments = ["amount"])
|
||||
|
||||
Application.getInstance().applicationShuttingDown.connect(self.stop)
|
||||
self.addConnectionSignal.connect(self.addConnection) #Because the model needs to be created in the same thread as the QMLEngine, we use a signal.
|
||||
|
||||
addConnectionSignal = Signal()
|
||||
printerConnectionStateChanged = pyqtSignal()
|
||||
|
||||
def start(self):
|
||||
self._check_updates = True
|
||||
self._update_thread.start()
|
||||
|
||||
def stop(self):
|
||||
self._check_updates = False
|
||||
try:
|
||||
self._update_thread.join()
|
||||
except RuntimeError:
|
||||
pass
|
||||
|
||||
def _updateThread(self):
|
||||
while self._check_updates:
|
||||
result = self.getSerialPortList(only_list_usb = True)
|
||||
self._addRemovePorts(result)
|
||||
time.sleep(5)
|
||||
|
||||
## Show firmware interface.
|
||||
# This will create the view if its not already created.
|
||||
def spawnFirmwareInterface(self, serial_port):
|
||||
|
|
@ -66,79 +82,37 @@ class USBPrinterManager(QObject, SignalEmitter, Extension):
|
|||
self._firmware_view = component.create(self._firmware_context)
|
||||
|
||||
self._firmware_view.show()
|
||||
|
||||
## Show control interface.
|
||||
# This will create the view if its not already created.
|
||||
def spawnControlInterface(self,serial_port):
|
||||
if self._control_view is None:
|
||||
path = QUrl.fromLocalFile(os.path.join(PluginRegistry.getInstance().getPluginPath("USBPrinting"), "ControlWindow.qml"))
|
||||
|
||||
component = QQmlComponent(Application.getInstance()._engine, path)
|
||||
self._control_context = QQmlContext(Application.getInstance()._engine.rootContext())
|
||||
self._control_context.setContextProperty("manager", self)
|
||||
|
||||
self._control_view = component.create(self._control_context)
|
||||
|
||||
self._control_view.show()
|
||||
|
||||
@pyqtProperty(float,notify = processingProgress)
|
||||
def progress(self):
|
||||
return self._progress
|
||||
|
||||
@pyqtProperty(float,notify = pyqtExtruderTemperature)
|
||||
def extruderTemperature(self):
|
||||
return self._extruder_temp
|
||||
|
||||
@pyqtProperty(float,notify = pyqtBedTemperature)
|
||||
def bedTemperature(self):
|
||||
return self._bed_temp
|
||||
|
||||
@pyqtProperty(str,notify = pyqtError)
|
||||
def error(self):
|
||||
return self._error_message
|
||||
|
||||
## Check all serial ports and create a PrinterConnection object for them.
|
||||
# Note that this does not validate if the serial ports are actually usable!
|
||||
# This (the validation) is only done when the connect function is called.
|
||||
def _updateConnectionList(self):
|
||||
while True:
|
||||
temp_serial_port_list = self.getSerialPortList(only_list_usb = True)
|
||||
if temp_serial_port_list != self._serial_port_list: # Something changed about the list since we last changed something.
|
||||
disconnected_ports = [port for port in self._serial_port_list if port not in temp_serial_port_list ]
|
||||
self._serial_port_list = temp_serial_port_list
|
||||
for serial_port in self._serial_port_list:
|
||||
if self.getConnectionByPort(serial_port) is None: # If it doesn't already exist, add it
|
||||
if not os.path.islink(serial_port): # Only add the connection if it's a non symbolic link
|
||||
connection = PrinterConnection.PrinterConnection(serial_port)
|
||||
connection.connect()
|
||||
connection.connectionStateChanged.connect(self.serialConectionStateCallback)
|
||||
connection.progressChanged.connect(self.onProgress)
|
||||
connection.onExtruderTemperatureChange.connect(self.onExtruderTemperature)
|
||||
connection.onBedTemperatureChange.connect(self.onBedTemperature)
|
||||
connection.onError.connect(self.onError)
|
||||
self._printer_connections.append(connection)
|
||||
|
||||
for serial_port in disconnected_ports: # Close connections and remove them from list.
|
||||
connection = self.getConnectionByPort(serial_port)
|
||||
if connection != None:
|
||||
self._printer_connections.remove(connection)
|
||||
connection.close()
|
||||
time.sleep(5) # Throttle, as we don"t need this information to be updated every single second.
|
||||
|
||||
def updateAllFirmware(self):
|
||||
self.spawnFirmwareInterface("")
|
||||
for printer_connection in self._printer_connections:
|
||||
try:
|
||||
printer_connection.updateFirmware(Resources.getPath(Resources.FirmwareLocation, self._getDefaultFirmwareName()))
|
||||
self._printer_connections[printer_connection].updateFirmware(Resources.getPath(Resources.FirmwareLocation, self._getDefaultFirmwareName()))
|
||||
except FileNotFoundError:
|
||||
continue
|
||||
|
||||
|
||||
@pyqtSlot(str, result = bool)
|
||||
def updateFirmwareBySerial(self, serial_port):
|
||||
printer_connection = self.getConnectionByPort(serial_port)
|
||||
if printer_connection is not None:
|
||||
self.spawnFirmwareInterface(printer_connection.getSerialPort())
|
||||
printer_connection.updateFirmware(Resources.getPath(Resources.FirmwareLocation, self._getDefaultFirmwareName()))
|
||||
|
||||
if serial_port in self._printer_connections:
|
||||
self.spawnFirmwareInterface(self._printer_connections[serial_port].getSerialPort())
|
||||
try:
|
||||
self._printer_connections[serial_port].updateFirmware(Resources.getPath(Resources.FirmwareLocation, self._getDefaultFirmwareName()))
|
||||
except FileNotFoundError:
|
||||
self._firmware_view.close()
|
||||
Logger.log("e", "Could not find firmware required for this machine")
|
||||
return False
|
||||
return True
|
||||
return False
|
||||
|
||||
## Return the singleton instance of the USBPrinterManager
|
||||
@classmethod
|
||||
def getInstance(cls, engine = None, script_engine = None):
|
||||
# Note: Explicit use of class name to prevent issues with inheritance.
|
||||
if USBPrinterManager._instance is None:
|
||||
USBPrinterManager._instance = cls()
|
||||
|
||||
return USBPrinterManager._instance
|
||||
|
||||
def _getDefaultFirmwareName(self):
|
||||
machine_type = Application.getInstance().getActiveMachine().getTypeID()
|
||||
firmware_name = ""
|
||||
|
|
@ -160,120 +134,46 @@ class USBPrinterManager(QObject, SignalEmitter, Extension):
|
|||
return "MarlinUltimaker2.hex"
|
||||
|
||||
##TODO: Add check for multiple extruders
|
||||
|
||||
|
||||
if firmware_name != "":
|
||||
firmware_name += ".hex"
|
||||
return firmware_name
|
||||
|
||||
## Callback for extruder temperature change
|
||||
def onExtruderTemperature(self, serial_port, index, temperature):
|
||||
self._extruder_temp = temperature
|
||||
self.pyqtExtruderTemperature.emit(temperature)
|
||||
|
||||
## Callback for bed temperature change
|
||||
def onBedTemperature(self, serial_port,temperature):
|
||||
self._bed_temp = temperature
|
||||
self.pyqtBedTemperature.emit(temperature)
|
||||
|
||||
## Callback for error
|
||||
def onError(self, error):
|
||||
self._error_message = error if type(error) is str else error.decode("utf-8")
|
||||
self.pyqtError.emit(self._error_message)
|
||||
|
||||
## Callback for progress change
|
||||
def onProgress(self, progress, serial_port):
|
||||
self._progress = progress
|
||||
self.processingProgress.emit(progress)
|
||||
def _addRemovePorts(self, serial_ports):
|
||||
# First, find and add all new or changed keys
|
||||
for serial_port in list(serial_ports):
|
||||
if serial_port not in self._serial_port_list:
|
||||
self.addConnectionSignal.emit(serial_port) #Hack to ensure its created in main thread
|
||||
continue
|
||||
self._serial_port_list = list(serial_ports)
|
||||
|
||||
## Attempt to connect with all possible connections.
|
||||
def connectAllConnections(self):
|
||||
## Because the model needs to be created in the same thread as the QMLEngine, we use a signal.
|
||||
def addConnection(self, serial_port):
|
||||
connection = PrinterConnection.PrinterConnection(serial_port)
|
||||
connection.connect()
|
||||
connection.connectionStateChanged.connect(self._onPrinterConnectionStateChanged)
|
||||
self._printer_connections[serial_port] = connection
|
||||
|
||||
def _onPrinterConnectionStateChanged(self, serial_port):
|
||||
if self._printer_connections[serial_port].isConnected():
|
||||
self.getOutputDeviceManager().addOutputDevice(self._printer_connections[serial_port])
|
||||
else:
|
||||
self.getOutputDeviceManager().removeOutputDevice(serial_port)
|
||||
self.printerConnectionStateChanged.emit()
|
||||
|
||||
@pyqtProperty(QObject , notify = printerConnectionStateChanged)
|
||||
def connectedPrinterList(self):
|
||||
self._printer_connections_model = ListModel()
|
||||
self._printer_connections_model.addRoleName(Qt.UserRole + 1,"name")
|
||||
self._printer_connections_model.addRoleName(Qt.UserRole + 2, "printer")
|
||||
for connection in self._printer_connections:
|
||||
connection.connect()
|
||||
|
||||
## Send gcode to printer and start printing
|
||||
def sendGCodeByPort(self, serial_port, gcode_list):
|
||||
printer_connection = self.getConnectionByPort(serial_port)
|
||||
if printer_connection is not None:
|
||||
printer_connection.printGCode(gcode_list)
|
||||
return True
|
||||
return False
|
||||
|
||||
@pyqtSlot()
|
||||
def cancelPrint(self):
|
||||
for printer_connection in self.getActiveConnections():
|
||||
printer_connection.cancelPrint()
|
||||
|
||||
## Send gcode to all active printers.
|
||||
# \return True if there was at least one active connection.
|
||||
def sendGCodeToAllActive(self, gcode_list):
|
||||
for printer_connection in self.getActiveConnections():
|
||||
printer_connection.printGCode(gcode_list)
|
||||
if len(self.getActiveConnections()):
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
## Send a command to a printer indentified by port
|
||||
# \param serial port String indentifieing the port
|
||||
# \param command String with the g-code command to send.
|
||||
# \return True if connection was found, false otherwise
|
||||
def sendCommandByPort(self, serial_port, command):
|
||||
printer_connection = self.getConnectionByPort(serial_port)
|
||||
if printer_connection is not None:
|
||||
printer_connection.sendCommand(command)
|
||||
return True
|
||||
return False
|
||||
|
||||
## Send a command to all active (eg; connected) printers
|
||||
# \param command String with the g-code command to send.
|
||||
# \return True if at least one connection was found, false otherwise
|
||||
def sendCommandToAllActive(self, command):
|
||||
for printer_connection in self.getActiveConnections():
|
||||
printer_connection.sendCommand(command)
|
||||
if len(self.getActiveConnections()):
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
## Callback if the connection state of a connection is changed.
|
||||
# This adds or removes the connection as a possible output device.
|
||||
def serialConectionStateCallback(self, serial_port):
|
||||
connection = self.getConnectionByPort(serial_port)
|
||||
if connection.isConnected():
|
||||
Application.getInstance().addOutputDevice(serial_port, {
|
||||
"id": serial_port,
|
||||
"function": self.spawnControlInterface,
|
||||
"description": "Print with USB {0}".format(serial_port),
|
||||
"shortDescription": "Print with USB",
|
||||
"icon": "save",
|
||||
"priority": 1
|
||||
})
|
||||
else:
|
||||
Application.getInstance().removeOutputDevice(serial_port)
|
||||
|
||||
@pyqtSlot()
|
||||
def startPrint(self):
|
||||
gcode_list = getattr(Application.getInstance().getController().getScene(), "gcode_list", None)
|
||||
if gcode_list:
|
||||
final_list = []
|
||||
for gcode in gcode_list:
|
||||
final_list += gcode.split("\n")
|
||||
self.sendGCodeToAllActive(gcode_list)
|
||||
|
||||
## Get a list of printer connection objects that are connected.
|
||||
def getActiveConnections(self):
|
||||
return [connection for connection in self._printer_connections if connection.isConnected()]
|
||||
|
||||
## Get a printer connection object by serial port
|
||||
def getConnectionByPort(self, serial_port):
|
||||
for printer_connection in self._printer_connections:
|
||||
if serial_port == printer_connection.getSerialPort():
|
||||
return printer_connection
|
||||
return None
|
||||
if self._printer_connections[connection].isConnected():
|
||||
self._printer_connections_model.appendItem({"name":connection, "printer": self._printer_connections[connection]})
|
||||
return self._printer_connections_model
|
||||
|
||||
## Create a list of serial ports on the system.
|
||||
# \param only_list_usb If true, only usb ports are listed
|
||||
def getSerialPortList(self,only_list_usb=False):
|
||||
def getSerialPortList(self, only_list_usb = False):
|
||||
base_list = []
|
||||
if platform.system() == "Windows":
|
||||
import winreg
|
||||
|
|
@ -293,8 +193,6 @@ class USBPrinterManager(QObject, SignalEmitter, Extension):
|
|||
base_list = filter(lambda s: "Bluetooth" not in s, base_list) # Filter because mac sometimes puts them in the list
|
||||
else:
|
||||
base_list = base_list + glob.glob("/dev/ttyUSB*") + glob.glob("/dev/ttyACM*") + glob.glob("/dev/cu.*") + glob.glob("/dev/tty.usb*") + glob.glob("/dev/rfcomm*") + glob.glob("/dev/serial/by-id/*")
|
||||
return base_list
|
||||
return list(base_list)
|
||||
|
||||
def _onApplicationShuttingDown(self):
|
||||
for connection in self._printer_connections:
|
||||
connection.close()
|
||||
_instance = None
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
# Cura is released under the terms of the AGPLv3 or higher.
|
||||
|
||||
from . import USBPrinterManager
|
||||
|
||||
from PyQt5.QtQml import qmlRegisterType, qmlRegisterSingletonType
|
||||
from UM.i18n import i18nCatalog
|
||||
i18n_catalog = i18nCatalog("cura")
|
||||
|
||||
|
|
@ -13,9 +13,11 @@ def getMetaData():
|
|||
"name": "USB printing",
|
||||
"author": "Ultimaker",
|
||||
"version": "1.0",
|
||||
"api": 2,
|
||||
"description": i18n_catalog.i18nc("USB Printing plugin description","Accepts G-Code and sends them to a printer. Plugin can also update firmware")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
def register(app):
|
||||
return {"extension":USBPrinterManager.USBPrinterManager()}
|
||||
qmlRegisterSingletonType(USBPrinterManager.USBPrinterManager, "UM", 1, 0, "USBPrinterManager", USBPrinterManager.USBPrinterManager.getInstance)
|
||||
return {"extension":USBPrinterManager.USBPrinterManager.getInstance(),"output_device": USBPrinterManager.USBPrinterManager.getInstance() }
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue