def cancelPrint(self, disableMotorsAndHeater=True): """ Cancel the current printjob. """ if self.isConnected() and (self.isPrinting() or self.isPaused()): activePrintJob = None cameraManager().stop_timelapse() consumedMaterial = self.getTotalConsumedFilament() timeElapsed = self.getPrintTime() if self._currentPrintJobId: astroprintCloud().print_job(self._currentPrintJobId, status='failed', materialUsed=consumedMaterial) activePrintJob = self._currentPrintJobId self._currentPrintJobId = None self._logger.info( "Print job [%s] CANCELED. Filament used: %f, Time elapsed: %f" % (os.path.split(self._selectedFile['filename'])[1] if self._selectedFile else 'unknown', consumedMaterial, timeElapsed)) self.executeCancelCommands(disableMotorsAndHeater) return {'print_job_id': activePrintJob} else: return { 'error': 'no_print_job', 'message': 'No active print job to cancel' }
def peerSession(self, data, sendResponse): action = data['action'] if data and 'sessionId' in data: sessionId = data['sessionId'] if action == 'init_peer_session': #Initialize the peer session if cameraManager().startLocalVideoSession(sessionId): sendResponse({'success': 'no-error'}) else: sendResponse('error_init_peer_session', True) #elif request.method == 'DELETE': elif action == 'close_peer_session': #Close peer session if cameraManager().closeLocalVideoSession(sessionId): sendResponse({'success': 'no-error'}) else: sendResponse('error_close_peer_session', True) else: sendResponse('error_no_session_id', True)
def closePeerSession(self, sessionId): with self._peerCondition: if len(self._connectedPeers.keys()) > 0: try: peer = self._connectedPeers[sessionId] except KeyError: self._logger.warning('Session [%s] for peer not found' % sessionId) peer = None if peer: peer.streamingPlugin.send_message({ 'request': 'destroy', 'id': sessionId }) peer.close() peer.sendEventToPeer('stopConnection') del self._connectedPeers[sessionId] self._logger.info("There are %d peers left.", len(self._connectedPeers)) if len(self._connectedPeers.keys()) == 0: #last session self.stopJanus() cameraManager().stop_video_stream()
def startVideoStream(self): #Start Video Stream def startDone(success): if not success: self._logger.error('Managing GStreamer error in WebRTC object') self.stopJanus() cameraManager().start_video_stream(startDone)
def photo(self, data, clientId, done): def doneWithPhoto(pic): if pic is not None: done({ 'success': True, 'image_data': base64.b64encode(pic) }) else: done({ 'success': False, 'image_data': '' }) cameraManager().get_pic_async(doneWithPhoto)
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 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 printCapture(self, data, clientId, done): freq = data['freq'] if freq: cm = cameraManager() if cm.timelapseInfo: if not cm.update_timelapse(freq): done({ 'error': True, 'message': 'Error updating the print capture' }) return else: r = cm.start_timelapse(freq) if r != 'success': done({ 'error': True, 'message': 'Error creating the print capture: %s' % r }) return else: done({ 'error': True, 'message': 'Frequency required' }) return done(None)
def isCameraConnected(): cm = cameraManager() return jsonify({ "isCameraConnected": cm.isCameraConnected(), "cameraName": cm.cameraName })
def connected(self, sendResponse): cm = cameraManager() return sendResponse({ "isCameraConnected": cm.isCameraConnected(), "cameraName": cm.cameraName })
def mcPhotoCommand(self): cm = cameraManager() if not cm.is_timelapse_active(): cm.start_timelapse('gcode') cm.addPhotoToActiveTimelapse()
def cameraSettings(): s = settings() cm = cameraManager() if request.method == 'POST': if "application/json" in request.headers["Content-Type"]: data = request.json if "source" in data: s.set(['camera', 'source'], data['source']) if "size" in data: s.set(['camera', 'size'], data['size']) if "encoding" in data: s.set(['camera', 'encoding'], data['encoding']) if "format" in data: s.set(['camera', 'format'], data['format']) if "framerate" in data: s.set(['camera', 'framerate'], data['framerate']) if "video_rotation" in data: s.set(['camera', 'video-rotation'], int(data['video_rotation'])) if "idle_timeout" in data: s.setFloat(['camera', 'inactivitySecs'], data['idle_timeout']) if "time_lapse" in data: s.set(['camera', 'freq'], data['time_lapse']) s.save() cm.settingsChanged({ 'size': s.get(['camera', 'size']), 'encoding': s.get(['camera', 'encoding']), 'framerate': s.get(['camera', 'framerate']), 'source': s.get(['camera', 'source']), 'format': s.get(['camera', 'format']), 'video_rotation': s.get(['camera', 'video-rotation']) }) return jsonify(encoding=s.get(['camera', 'encoding']), size=s.get(['camera', 'size']), framerate=s.get(['camera', 'framerate']), format=s.get(['camera', 'format']), source=s.get(['camera', 'source']), video_rotation=s.getInt(['camera', 'video-rotation']), structure=cm.settingsStructure(), time_lapse=s.get(['camera', 'freq']), idle_timeout=s.get(['camera', 'inactivitySecs']))
def stopStreaming(self, data, sendResponse): if cameraManager().closeLocalVideoSession(sessionId): sendResponse({'success': 'no-error'}) return else: sendResponse({'stop_streaming_error': True})
def closeAllSessions(self, sender=None, message=None): self._logger.info("Closing all streaming sessions") #closing local streaming sessions cameraManager().removeAllLocalPeerReqs() for sessionId in self._connectedPeers.keys(): peer = self._connectedPeers[sessionId] #if peer != 'local': if isinstance(peer, ConnectionPeer): if message: peer.sendEventToPeer("cameraError", message) self.closePeerSession(sessionId) else: self.closeLocalSession(sessionId) return self.stopJanus()
def startPeerSession(self, clientId): with self._peerCondition: if len(self._connectedPeers.keys()) == 0: #first session self.startJanus() peer = ConnectionPeer(clientId, self) sessionId = peer.start() if sessionId: self._connectedPeers[sessionId] = peer return sessionId else: #something went wrong, no session started. Do we still need Janus up? if len(self._connectedPeers.keys()) == 0: self.stopJanus() cameraManager().stop_video_stream() return None
def peer_session(): data = request.json if data and 'sessionId' in data: sessionId = data['sessionId'] if request.method == 'POST': #Initialize the peer session if cameraManager().startLocalVideoSession(sessionId): return jsonify(SUCCESS) abort(500) elif request.method == 'DELETE': #Close peer session if cameraManager().closeLocalVideoSession(sessionId): return jsonify(SUCCESS) else: abort(500) else: abort(400)
def closeLocalSession(self, sessionId): with self._peerCondition: if len(self._connectedPeers.keys()) > 0: try: peer = self._connectedPeers[sessionId] except KeyError: self._logger.warning('Session [%s] for peer not found' % sessionId) peer = None if peer: del self._connectedPeers[sessionId] self._logger.info("There are %d peers left.", len(self._connectedPeers)) if len(self._connectedPeers) == 0: #last session self.stopJanus() cameraManager().stop_video_stream() return True
def cameraSettings(self, sendResponse): s = settings() cm = cameraManager() sendResponse({ 'encoding': s.get(['camera', 'encoding']), 'size': s.get(['camera', 'size']), 'framerate': s.get(['camera', 'framerate']), 'freq': s.get(['camera', 'freq']), 'format': s.get(['camera', 'format']), 'source': s.get(['camera', 'source']), 'video_rotation': s.getInt(['camera', 'video-rotation']), 'structure': cm.settingsStructure() })
def restartServer(self): if platformStr == "linux" or platformStr == "linux2": actions = self._settings.get(["system", "actions"]) for a in actions: if a['action'] == 'reboot': #Call to Popen will start the restart command but return inmediately before it completes threading.Timer(1.0, subprocess.Popen, [a['command'].split(' ')]).start() self._logger.info('Restart command scheduled') from octoprint_WBCustom.astroprint.printer.manager import printerManager from octoprint_WBCustom.astroprint.camera import cameraManager from octoprint_WBCustom.astroprint.network.manager import networkManagerShutdown #let's be nice about shutthing things down printerManager().disconnect() cameraManager().close_camera() networkManagerShutdown() return True return False return True
def mcPrintjobDone(self): #stop timelapse if there was one cameraManager().stop_timelapse( True) #True makes it take one last photo timeElapsed = self.getPrintTime() #Not sure if this is the best way to get the layer count self._setProgressData(1.0, self._selectedFile["filesize"], timeElapsed, 0, self._layerCount) self.refreshStateData() consumedMaterial = self.getTotalConsumedFilament() if self._currentPrintJobId: astroprintCloud().print_job(self._currentPrintJobId, status='success', materialUsed=consumedMaterial) self._currentPrintJobId = None self._logger.info( "Print job [%s] COMPLETED. Filament used: %f, Time elapsed: %f" % (os.path.split(self._selectedFile['filename'])[1] if self._selectedFile else 'unknown', consumedMaterial, timeElapsed))
def startPrint(self, printJobId=None): """ Starts the currently loaded print job. Only starts if the printer is connected and operational, not currently printing and a printjob is loaded """ if not self.isConnected() or not self.isOperational( ) or self.isPrinting(): return False if self._selectedFile is None: return False self._setCurrentZ(None) kwargs = { 'print_file_name': os.path.basename(self._selectedFile['filename']), 'id': printJobId } if self._selectedFile['cloudId']: kwargs['print_file_id'] = self._selectedFile['cloudId'] #tell astroprint that we started a print result = astroprintCloud().print_job(**kwargs) #start time lapse if is set s = settings() c = cameraManager() freq = s.get(['camera', 'freq']) if freq and c.isCameraConnected(): c.start_timelapse(freq) if result and "id" in result: self._currentPrintJobId = result['id'] self._timeStarted = time.time() self._secsPaused = 0 self._pausedSince = None self._currentLayer = 0 self.printedLayersCounter = 0 return True
def setTimelapse(self,data,sendResponse): freq = data['freq'] if freq: cm = cameraManager() if cm.timelapseInfo: if not cm.update_timelapse(freq): sendResponse('error_updating_timelapse',True) return else: r = cm.start_timelapse(freq) if r != 'success': sendResponse('error_starting_timelapse',True) return else: sendResponse('erro_no_frequency',True) return sendResponse({'success': 'no_error'})
def update_timelapse(): freq = request.values.get('freq') if freq: cm = cameraManager() if cm.timelapseInfo: if cm.update_timelapse(freq): return jsonify(SUCCESS) else: timelapse = cm.start_timelapse(freq) if timelapse == 'success': return jsonify(SUCCESS) if timelapse == 'no_storage': return make_response('No Storage', 402) else: abort(500) else: abort(400) abort(500)
def togglePausePrint(self): """ Pause the current printjob. """ if not self.isConnected(): return wasPaused = self.isPaused() if wasPaused: if self._pausedSince is not None: self._secsPaused += (time.time() - self._pausedSince) self._pausedSince = None else: self._pausedSince = time.time() self.setPause(not wasPaused) cm = cameraManager() if cm.is_timed_timelapse_active(): if wasPaused: cm.resume_timelapse() else: cm.pause_timelapse()
def hasCameraProperties(self, sendResponse): cm = cameraManager() return sendResponse({"hasCameraProperties": cm.hasCameraProperties()})
def getTimelapse(self,data,sendResponse): sendResponse(cameraManager().timelapseInfo)
def cameraSettings(self, data, sendMessage): s = settings() cm = cameraManager() if data: if "source" in data: s.set(['camera', 'source'], data['source']) if "size" in data: s.set(['camera', 'size'], data['size']) if "encoding" in data: s.set(['camera', 'encoding'], data['encoding']) if "format" in data: s.set(['camera', 'format'], data['format']) if "framerate" in data: s.set(['camera', 'framerate'], data['framerate']) if "video_rotation" in data: s.set(['camera', 'video-rotation'], int(data['video_rotation'])) if "freq" in data: s.set(['camera', 'freq'], data['freq']) if "idle_timeout" in data: s.setFloat(['camera', 'inactivitySecs'], data['idle_timeout']) s.save() cm.settingsChanged({ 'size': s.get(['camera', 'size']), 'encoding': s.get(['camera', 'encoding']), 'framerate': s.get(['camera', 'framerate']), 'source': s.get(['camera', 'source']), 'format': s.get(['camera', 'format']), 'video_rotation': s.get(['camera', 'video-rotation']) }) sendMessage({ 'encoding': s.get(['camera', 'encoding']), 'size': s.get(['camera', 'size']), 'framerate': s.get(['camera', 'framerate']), 'freq': s.get(['camera', 'freq']), 'idle_timeout': s.get(['camera', 'inactivitySecs']), 'format': s.get(['camera', 'format']), 'source': s.get(['camera', 'source']), 'video_rotation': str(s.getInt(['camera', 'video-rotation'])), 'structure': cm.settingsStructure() })
def isResolutionSupported(self, size, sendMessage): cm = cameraManager() sendMessage({"isResolutionSupported": cm.isResolutionSupported(size)})
def refreshPluggedCamera(self, data, sendMessage): cm = cameraManager() sendMessage({"camera_plugged": cm.reScan()})
def isCameraSupportedByAstrobox(self, sendResponse): cm = cameraManager() return sendResponse( {"isCameraSupported": cm.settingsStructure() is not None})