def initial_state(self, data, clientId, done):
printer = printerManager()
cm = cameraManager()
softwareManager = swManager()
state = {
'printing': printer.isPrinting() or printer.isPaused(),
'heatingUp': printer.isHeatingUp(),
'operational': printer.isOperational(),
'paused': printer.isPaused(),
'camera': printer.isCameraConnected(),
'filament' : printerProfileManager().data['filament'],
'printCapture': cm.timelapseInfo,
'profile': printerProfileManager().data,
'remotePrint': True,
'capabilities': softwareManager.capabilities() + cm.capabilities,
'tool': printer.getSelectedTool() if printer.isOperational() else None,
'printSpeed': printer.getPrintingSpeed(),
'printFlow': printer.getPrintingFlow()
}
if state['printing'] or state['paused']:
#Let's add info about the ongoing print job
state['job'] = printer._stateMonitor._jobData
state['progress'] = printer._stateMonitor._progress
done(state)
def handlePrinterSettings():
s = settings()
pm = printerManager()
ppm = printerProfileManager()
connectionOptions = pm.getConnectionOptions()
if request.method == "POST":
if "application/json" in request.headers["Content-Type"]:
data = request.json
if "serial" in data.keys():
if "port" in data["serial"].keys():
s.set(["serial", "port"], data["serial"]["port"])
if "baudrate" in data["serial"].keys():
s.setInt(["serial", "baudrate"],
data["serial"]["baudrate"])
s.save()
driverName = ppm.data['driver']
driverInfo = ppm.driverChoices().get(driverName)
if driverInfo:
driverName = driverInfo['name']
return jsonify({
"driver": ppm.data['driver'],
"driverName": driverName,
"serial": {
"port": connectionOptions["portPreference"],
"baudrate": connectionOptions["baudratePreference"],
"portOptions": connectionOptions["ports"].items(),
"baudrateOptions": connectionOptions["baudrates"]
}
})
def saveTempPreset(self, data, sendMessage):
ppm = printerProfileManager()
if data:
id = ppm.createTempPreset(data['name'], data['nozzle_temp'],
data['bed_temp'])
sendMessage(id)
def connection_settings():
connectionOptions = printerManager().getConnectionOptions()
if connectionOptions:
plugins = pluginManager().getPluginsByProvider('printerComms')
driverChoices = {("plugin:%s" % k): plugins[k].definition['name']
for k in plugins}
driverChoices.update({
'marlin': 'GCODE - Marlin / Repetier Firmware',
's3g': 'X3G - Sailfish / Makerbot Firmware'
})
response = {
"driver": printerProfileManager().data['driver'],
"driverChoices": driverChoices,
"port": connectionOptions["portPreference"],
"baudrate": connectionOptions["baudratePreference"],
"portOptions": connectionOptions["ports"].items(),
"baudrateOptions": connectionOptions["baudrates"]
}
return jsonify(response)
return make_response("Connection options not available", 400)
def processAuthenticate(self, data):
if data:
self._silentReconnect = False
if 'error' in data:
self._logger.warn(data['message'] if 'message' in data else 'Unkonwn authentication error')
self.status = self.STATUS_ERROR
self._eventManager.fire(Events.ASTROPRINT_STATUS, self.status)
self.close()
if data.get('should_retry'):
self._doRetry()
elif data.get('type') == 'unable_to_authenticate':
self._logger.info("Unuable to authenticate user in fleet box. Logout")
astroprintCloud().remove_logged_user()
elif 'success' in data:
self._logger.info("Connected to astroprint service")
self.authenticated = True
if 'groupId' in data:
astroprintCloud().updateFleetInfo(data['orgId'], data['groupId'])
self._eventManager.fire(Events.FLEET_STATUS, data)
self._retries = 0
self._retryTimer = None
self.status = self.STATUS_CONNECTED
self._eventManager.fire(Events.ASTROPRINT_STATUS, self.status)
return None
else:
from octoprint.server import VERSION
from octoprint_WBCustom.astroprint.printerprofile import printerProfileManager
nm = networkManager()
sm = softwareManager()
ppm = printerProfileManager()
authData = {
'silentReconnect': self._silentReconnect,
'boxId': self.boxId,
'variantId': sm.variant['id'],
'boxName': nm.getHostname(),
'swVersion': VERSION,
'platform': sm.platform,
'localIpAddress': nm.activeIpAddress,
'publicKey': self._publicKey,
'privateKey': self._privateKey,
'printerModel': ppm.data['printer_model'] if ppm.data['printer_model']['id'] else None
}
pkgId = sm.mfPackageId
if pkgId:
authData['mfPackageId'] = pkgId
return {
'type': 'auth',
'data': authData
}
def printerConnectionDriver(self, data, sendMessage):
s = settings()
pm = printerManager()
ppm = printerProfileManager()
connectionOptions = pm.getConnectionOptions()
if data and data['settings']:
if "serial" in data.keys():
if "port" in data["serial"].keys():
s.set(["serial", "port"], data["serial"]["port"])
if "baudrate" in data["serial"].keys():
s.setInt(["serial", "baudrate"],
data["serial"]["baudrate"])
s.save()
driverName = ppm.data['driver']
driverInfo = ppm.driverChoices().get(driverName)
if driverInfo:
driverName = driverInfo['name']
sendMessage({
"driver": ppm.data['driver'],
"driverName": driverName,
"fileFormat": pm.fileManager.fileFormat,
"serial": {
"port": connectionOptions["portPreference"],
"baudrate": connectionOptions["baudratePreference"],
"portOptions": connectionOptions["ports"],
"baudrateOptions": connectionOptions["baudrates"]
}
})
def saveConnectionSettings(self, data, sendResponse):
port = data['port']
baudrate = data['baudrate']
driver = data['driver']
if port:
s = settings()
s.set(["serial", "port"], port)
if baudrate:
s.setInt(["serial", "baudrate"], baudrate)
s.save()
pp = printerProfileManager()
pp.set({'driver': driver})
pp.save()
printerManager().connect(port, baudrate)
sendResponse({'success': 'no_error'})
return
sendResponse('invalid_printer_connection_settings', True)
def getStatus(self):
printer = printerManager()
cm = cameraManager()
ppm = printerProfileManager()
cloudInstance = astroprintCloud()
fileName = None
if printer.isPrinting():
currentJob = printer.getCurrentJob()
fileName = currentJob["file"]["name"]
return {
'id': boxrouterManager().boxId,
'name': networkManager().getHostname(),
'orgId' : cloudInstance.orgId,
'groupId' : cloudInstance.groupId,
'printing': printer.isPrinting(),
'fileName': fileName,
'printerModel': ppm.data['printer_model'] if ppm.data['printer_model']['id'] else None,
'filament' : ppm.data['filament'],
'material': None,
'operational': printer.isOperational(),
'paused': printer.isPaused(),
'camera': cm.isCameraConnected(),
#'printCapture': cm.timelapseInfo,
'remotePrint': True,
'capabilities': ['remotePrint'] + cm.capabilities
}
def temp_preset_create():
ppm = printerProfileManager()
name = request.values.get('name', None)
nozzle_temp = request.values.get('nozzle_temp', None)
bed_temp = request.values.get('bed_temp', None)
return jsonify({'id': ppm.createTempPreset(name, nozzle_temp, bed_temp)})
def getNumberOfExtruders(self,data,sendResponse=None):
ppm = printerProfileManager()
extruderCount = ppm.data.get('extruder_count')
if sendResponse:
sendResponse(extruderCount)
return extruderCount
def save_printer_profile_settings():
driver = request.values.get('driver', None)
if driver:
pp = printerProfileManager()
pp.set({'driver': driver})
pp.save()
return make_response("OK", 200)
return make_response('Invalid Connection Settings', 400)
def set_filament(self, data, clientId, done):
filament = {}
filament['filament'] = {}
if data['filament'] and data['filament']['name'] and data['filament']['color']:
filament['filament']['name'] = data['filament']['name']
#Better to make sure that are getting right color codes
if re.search(r'^#(?:[0-9a-fA-F]{3}){1,2}$', data['filament']['color']):
filament['filament']['color'] = data['filament']['color']
else:
done({
'error': True,
'message': 'Invalid color code'
})
else:
filament['filament']['name'] = None
filament['filament']['color'] = None
printerProfileManager().set(filament)
printerProfileManager().save()
done(None)
def printer_profile_patch():
ppm = printerProfileManager()
if request.method == "PATCH":
changes = request.json
ppm.set(changes)
ppm.save()
return jsonify()
else:
result = ppm.data.copy()
result.update({"driverChoices": ppm.driverChoices()})
return jsonify(result)
def printerManager(driver=None):
global _instance
if driver is not None and _instance is not None and _instance.driverName != driver:
_instance.rampdown()
_instance = None
if _instance is None and driver:
if driver.startswith('plugin:'):
from octoprint_WBCustom.astroprint.printer.plugin import PrinterWithPlugin, NoPluginException
try:
_instance = PrinterWithPlugin(driver[7:])
except NoPluginException:
#The plugin is gone. Pick the default
from octoprint_WBCustom.astroprint.printerprofile import printerProfileManager
ppm = printerProfileManager()
ppm.set({'driver': DEFAULT_MANAGER})
ppm.save()
else:
import importlib
try:
# driver name to class map. format is (module, classname)
classInfo = {
'marlin': ('.marlin', 'PrinterMarlin'),
's3g': ('.s3g', 'PrinterS3g')
}[driver]
except KeyError:
classInfo = ('.marlin', 'PrinterMarlin')
module = importlib.import_module(classInfo[0],
'astroprint.printer')
_instance = getattr(module, classInfo[1])()
return _instance
def __init__(self):
self.systemPlugin = False
self._logger = logging.getLogger('Plugin::%s' %
self.__class__.__name__)
self._definition = None
self._settings = settings()
self._pluginEventListeners = {}
self._profileManager = printerProfileManager()
#Read it's definition file - plugin.yaml -
pluginPath = os.path.dirname(sys.modules[self.__module__].__file__)
definitionFile = os.path.join(pluginPath, 'plugin.yaml')
if os.path.exists(definitionFile):
try:
with open(definitionFile, "r") as f:
self._definition = yaml.safe_load(f)
except Exception as e:
raise e #Raise parse exception here
if all(key in self._definition for key in REQUIRED_PLUGIN_KEYS):
min_api_version = int(self._definition['min_api_version'])
if PLUGIN_API_VERSION >= min_api_version:
self.initialize()
else:
raise Exception(
"AstroBox API version [%d] is lower than minimum required by %s [%d]"
% (PLUGIN_API_VERSION, self._definition['id'],
min_api_version))
else:
raise Exception("Invalid plugin definition found in %s" %
definitionFile)
else:
raise Exception("No plugin definition file exists in %s" %
pluginPath)
def printerProfile(self, data, sendMessage):
ppm = printerProfileManager()
pm = printerManager()
if data:
if 'driverChoices' in data:
del data['driverChoices']
if 'allowTerminal' in data:
del data['allowTerminal']
ppm.set(data)
ppm.save()
sendMessage({'success': 'no_error'})
else:
result = ppm.data.copy()
result.update({"allowTerminal": pm.allowTerminal})
result.update({"driverChoices": ppm.driverChoices()})
sendMessage(result)
def save_connection_settings():
port = request.values.get('port', None)
baudrate = request.values.get('baudrate', None)
driver = request.values.get('driver', None)
if port:
s = settings()
s.set(["serial", "port"], port)
if baudrate:
s.setInt(["serial", "baudrate"], baudrate)
s.save()
pp = printerProfileManager()
pp.set({'driver': driver})
pp.save()
printerManager().connect(port, baudrate)
return make_response("OK", 200)
return make_response('Invalid Connection Settings', 400)
def __init__(self):
self.broadcastTraffic = 0 #Number of clients that wish to receive serial link traffic
self.doIdleTempReports = True #Let's the client know if periodic temperature reports should be queries to the printer
self._comm = None
self._currentFile = None
self._selectedFile = None
self._currentZ = None # This should probably be deprecated
self._progress = None
self._printTime = None
self._printTimeLeft = None
self._currentLayer = None
self._currentPrintJobId = None
self._timeStarted = 0
self._secsPaused = 0
self._pausedSince = None
self._profileManager = printerProfileManager()
self._fileManager = printFileManagerMap[self._fileManagerClass.name]()
self._fileManager.registerCallback(self)
self._state = self.STATE_NONE
self._logger = logging.getLogger(__name__)
self._temp = {}
self._bedTemp = None
self._temps = deque([], 300)
self._shutdown = False
self._messages = deque([], 300)
self.printedLayersCounter = 0
# callbacks
self._callbacks = []
#self._lastProgressReport = None
self._stateMonitor = StateMonitor(
ratelimit=1.0,
updateCallback=self._sendCurrentDataCallbacks,
addTemperatureCallback=self._sendAddTemperatureCallbacks,
addLogCallback=self._sendAddLogCallbacks,
addMessageCallback=self._sendAddMessageCallbacks)
self._stateMonitor.reset(state={
"text": self.getStateString(),
"flags": self._getStateFlags()
},
jobData={
"file": {
"name": None,
"size": None,
"origin": None,
"date": None
},
"estimatedPrintTime": None,
"filament": {
"length": None,
"volume": None
}
},
progress={
"completion": None,
"filepos": None,
"printTime": None,
"printTimeLeft": None
},
currentZ=None)
eventManager().subscribe(Events.METADATA_ANALYSIS_FINISHED,
self.onMetadataAnalysisFinished)