q3k
/
OctoPrint
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Broken commit... redoing the complete messaging to the frontend, part 1

master
Gina Häußge 2013-01-10 23:40:00 +01:00
parent e51d7dc7a0
commit 4983a00adf
3 changed files with 166 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

273
printer_webui/printer.py
View File

@ -3,9 +3,7 @@ __author__ = "Gina Häußge <osd@foosel.net>"
__license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html' __license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html'
import time import time
from threading import Thread from threading import Thread, Event, Lock
import Queue
import collections
import printer_webui.util.comm as comm import printer_webui.util.comm as comm
from printer_webui.util import gcodeInterpreter from printer_webui.util import gcodeInterpreter
@ -36,12 +34,15 @@ class Printer():
"actualBed": [], "actualBed": [],
"targetBed": [] "targetBed": []
} }
self._tempBacklog = []
self._latestMessage = None self._latestMessage = None
self._messages = [] self._messages = []
self._messageBacklog = []
self._latestLog = None self._latestLog = None
self._log = [] self._log = []
self._logBacklog = []
self._state = None self._state = None
@ -70,18 +71,10 @@ class Printer():
self._callbacks = [] self._callbacks = []
self._lastProgressReport = None self._lastProgressReport = None
self._updateQueue = MessageQueue() self._stateMonitor = StateMonitor(ratelimit=0.5, updateCallback=self._sendCurrentDataCallbacks)
self._updateQueue.registerMessageType("zchange", self._sendZChangeCallbacks, overwrite=True) self._stateMonitor.reset(
self._updateQueue.registerMessageType("state", self._sendStateCallbacks) state={"state": self._state, "stateString": self.getStateString(), "flags": self._getStateFlags()}
self._updateQueue.registerMessageType("temperature", self._sendTemperatureCallbacks, mergeFunction=(lambda x,y: x + y)) )
self._updateQueue.registerMessageType("log", self._sendLogCallbacks, mergeFunction=(lambda x, y: x + y))
self._updateQueue.registerMessageType("message", self._sendMessageCallbacks, mergeFunction=(lambda x, y: x + y))
self._updateQueue.registerMessageType("progress", self._sendProgressCallbacks, overwrite=True)
self._updateQueue.registerMessageType("job", self._sendJobCallbacks, throttling=0.5)
self._updateQueue.registerMessageType("gcode", self._sendGcodeCallbacks, throttling=0.5)
self._updateQueueWorker = Thread(target=self._processQueue)
self._updateQueueWorker.start()
#~~ callback handling #~~ callback handling
@ -93,53 +86,11 @@ class Printer():
if callback in self._callbacks: if callback in self._callbacks:
self._callbacks.remove(callback) self._callbacks.remove(callback)
def _sendZChangeCallbacks(self, data): def _sendCurrentDataCallbacks(self, data):
for callback in self._callbacks: for callback in self._callbacks:
try: callback.zChangeCB(data["currentZ"]) try: callback.sendCurrentData(data)
except: pass except: pass
def _sendStateCallbacks(self, data):
for callback in self._callbacks:
try: callback.stateChangeCB(data["state"], data["stateString"], data["stateFlags"])
except: pass
def _sendTemperatureCallbacks(self, data):
for callback in self._callbacks:
try: callback.temperatureChangeCB(data)
except: pass
def _sendLogCallbacks(self, data):
for callback in self._callbacks:
try: callback.logChangeCB(data)
except: pass
def _sendMessageCallbacks(self, data):
for callback in self._callbacks:
try: callback.messageChangeCB(data)
except: pass
def _sendProgressCallbacks(self, data):
for callback in self._callbacks:
try: callback.progressChangeCB(data["progress"], data["printTime"], data["printTimeLeft"])
except: pass
def _sendJobCallbacks(self, data):
for callback in self._callbacks:
try: callback.jobDataChangeCB(data["filename"], data["lines"], data["estimatedPrintTime"], data["filament"])
except: pass
def _sendGcodeCallbacks(self, data):
for callback in self._callbacks:
try: callback.gcodeChangeCB(data["filename"], data["progress"])
except:
pass
def _processQueue(self):
while True:
(target, data) = self._updateQueue.read()
target(data)
self._updateQueue.task_done()
#~~ printer commands #~~ printer commands
def connect(self, port=None, baudrate=None): def connect(self, port=None, baudrate=None):
@ -241,41 +192,29 @@ class Printer():
def _setCurrentZ(self, currentZ): def _setCurrentZ(self, currentZ):
self._currentZ = currentZ self._currentZ = currentZ
self._updateQueue.message("zchange", {"currentZ": self._currentZ}) self._stateMonitor.setCurrentZ(self._currentZ)
def _setState(self, state): def _setState(self, state):
self._state = state self._state = state
self._updateQueue.message("state", {"state": self._state, "stateString": self.getStateString(), "stateFlags": self._getStateFlags()}) self._stateMonitor.setState({"state": self._state, "stateString": self.getStateString(), "stateFlags": self._getStateFlags()})
def _addLog(self, log): def _addLog(self, log):
"""
Log line is stored in internal buffer, which is truncated to the last 300 lines.
"""
self._latestLog = log
self._log.append(log) self._log.append(log)
self._log = self._log[-300:] self._log = self._log[-300:]
self._updateQueue.message("log", [self._latestLog]) self._stateMonitor.addLog(log)
def _addMessage(self, message): def _addMessage(self, message):
self._latestMessage = message
self._messages.append(message) self._messages.append(message)
self._messages = self._messages[-300:] self._messages = self._messages[-300:]
self._updateQueue.message("message", [self._latestLog]) self._stateMonitor.addMessage(message)
def _setProgressData(self, progress, printTime, printTimeLeft): def _setProgressData(self, progress, printTime, printTimeLeft):
self._progress = progress self._progress = progress
self._printTime = printTime self._printTime = printTime
self._printTimeLeft = printTimeLeft self._printTimeLeft = printTimeLeft
self._stateMonitor.setProgress({"progress": self._progress, "printTime": self._printTime, "printTimeLeft": self._printTimeLeft})
#if not self._lastProgressReport or self._lastProgressReport + 0.5 <= time.time():
self._updateQueue.message("progress", {"progress": self._progress, "printTime": self._printTime, "printTimeLeft": self._printTimeLeft})
# self._lastProgressReport = time.time()
def _addTemperatureData(self, temp, bedTemp, targetTemp, bedTargetTemp): def _addTemperatureData(self, temp, bedTemp, targetTemp, bedTargetTemp):
"""
Temperature information (actual and target) for print head and print bed is stored in corresponding
temperature history (including timestamp), history is truncated to 300 entries.
"""
currentTime = int(time.time() * 1000) currentTime = int(time.time() * 1000)
self._temps["actual"].append((currentTime, temp)) self._temps["actual"].append((currentTime, temp))
@ -295,7 +234,7 @@ class Printer():
self._targetTemp = targetTemp self._targetTemp = targetTemp
self._targetBedTemp = bedTargetTemp self._targetBedTemp = bedTargetTemp
self._updateQueue.message("temperature", [{"currentTime": currentTime, "temp": self._temp, "bedTemp": self._bedTemp, "targetTemp": self._targetTemp, "targetBedTemp": self._targetBedTemp, "history": self._temps}]) self._stateMonitor.addTemperature({"currentTime": currentTime, "temp": self._temp, "bedTemp": self._bedTemp, "targetTemp": self._targetTemp, "targetBedTemp": self._targetBedTemp})
def _setJobData(self, filename, gcode, gcodeList): def _setJobData(self, filename, gcode, gcodeList):
self._filename = filename self._filename = filename
@ -312,7 +251,7 @@ class Printer():
estimatedPrintTime = self._gcode.totalMoveTimeMinute estimatedPrintTime = self._gcode.totalMoveTimeMinute
filament = self._gcode.extrusionAmount filament = self._gcode.extrusionAmount
self._updateQueue.message("job", {"filename": self._filename, "lines": lines, "estimatedPrintTime": estimatedPrintTime, "filament": filament}) self._stateMonitor.setJobData({"filename": self._filename, "lines": lines, "estimatedPrintTime": estimatedPrintTime, "filament": filament})
def _sendInitialStateUpdate(self, callback): def _sendInitialStateUpdate(self, callback):
lines = None lines = None
@ -326,12 +265,13 @@ class Printer():
filament = self._gcode.extrusionAmount filament = self._gcode.extrusionAmount
try: try:
callback.zChangeCB(self._currentZ) data = self._stateMonitor.getCurrentData()
callback.stateChangeCB(self._state, self.getStateString(), self._getStateFlags()) data.update({
callback.progressChangeCB(self._progress, self._printTime, self._printTimeLeft) "temperatureHistory": self._temps,
callback.temperatureChangeCB([{"currentTime": time.time() * 1000, "temp": self._temp, "bedTemp": self._bedTemp, "targetTemp": self._targetTemp, "bedTargetTemp": self._targetBedTemp}]) "logHistory": self._log,
callback.jobDataChangeCB(self._filename, lines, estimatedPrintTime, filament) "messageHistory": self._messages
callback.sendHistoryData(self._temps, self._log, self._messages) })
callback.sendHistoryData(data)
except Exception, err: except Exception, err:
import sys import sys
sys.stderr.write("ERROR: %s\n" % str(err)) sys.stderr.write("ERROR: %s\n" % str(err))
@ -407,7 +347,7 @@ class Printer():
#~~ callbacks triggered by gcodeLoader #~~ callbacks triggered by gcodeLoader
def onGcodeLoadingProgress(self, progress): def onGcodeLoadingProgress(self, progress):
self._updateQueue.message("gcode", {"filename": self._gcodeLoader._filename, "progress": progress}) self._stateMonitor.setGcodeData({"filename": self._gcodeLoader._filename, "progress": progress})
def onGcodeLoaded(self): def onGcodeLoaded(self):
self._setJobData(self._gcodeLoader._filename, self._gcodeLoader._gcode, self._gcodeLoader._gcodeList) self._setJobData(self._gcodeLoader._filename, self._gcodeLoader._gcode, self._gcodeLoader._gcodeList)
@ -415,20 +355,10 @@ class Printer():
self._setProgressData(None, None, None) self._setProgressData(None, None, None)
self._gcodeLoader = None self._gcodeLoader = None
self._updateQueue.message("state", {"state": self._state, "stateString": self.getStateString(), "stateFlags": self._getStateFlags()}) self._stateMonitor.setState({"state": self._state, "stateString": self.getStateString(), "stateFlags": self._getStateFlags()})
#~~ state reports #~~ state reports
def gcodeState(self):
if self.gcodeLoader is not None:
return {
"filename": self.gcodeLoader.filename,
"progress": self.gcodeLoader.progress
}
else:
return None
def feedrateState(self): def feedrateState(self):
if self._comm is not None: if self._comm is not None:
feedrateModifiers = self._comm.getFeedrateModifiers() feedrateModifiers = self._comm.getFeedrateModifiers()
@ -520,86 +450,109 @@ class GcodeLoader(Thread):
self._printerCallback.onGcodeLoadingProgress(progress) self._printerCallback.onGcodeLoadingProgress(progress)
class PrinterCallback(object): class PrinterCallback(object):
def zChangeCB(self, newZ): def sendCurrentData(self, data):
pass pass
def progressChangeCB(self, currentLine, printTime, printTimeLeft): def sendHistoryData(self, data):
pass pass
def temperatureChangeCB(self, currentTime, temp, bedTemp, targetTemp, bedTargetTemp): class StateMonitor(object):
pass def __init__(self, ratelimit, updateCallback):
self._ratelimit = ratelimit
self._updateCallback = updateCallback
def stateChangeCB(self, state, stateString, booleanStates): self._state = None
pass self._jobData = None
self._gcodeData = None
self._currentZ = None
self._progress = None
self._logBacklog = []
self._logHistory = []
self._messageBacklog = []
self._messageHistory = []
self._temperatureBacklog = []
self._temperatureHistory = []
def logChangeCB(self, line): self._temperatureBacklogMutex = Lock()
pass self._logBacklogMutex = Lock()
self._messageBacklogMutex = Lock()
self._changeEvent = Event()
def messageChangeCB(self, line): self._lastUpdate = time.time()
pass self._worker = Thread(target=self._work)
self._worker.start()
def gcodeChangeCB(self, filename, progress): def reset(self, state=None):
pass self.setState(state)
def jobDataChangeCB(self, filename, lines, estimatedPrintTime, filamentLength): def addTemperature(self, temperature):
pass with self._temperatureBacklogMutex:
self._temperatureBacklog.append(temperature)
self._changeEvent.set()
def sendHistoryData(self, tempHistory, logHistory, messageHistory): def addLog(self, log):
pass with self._logBacklogMutex:
self._logBacklog.append(log)
self._changeEvent.set()
def addMessage(self, message):
with self._messageBacklogMutex:
self._messageBacklog.append(message)
self._changeEvent.set()
class MessageQueue(Queue.Queue): def setCurrentZ(self, currentZ):
def __init__(self, maxsize=0): self._currentZ = currentZ
Queue.Queue.__init__(self, maxsize) self._changeEvent.set()
self._messageTypes = dict()
self._lastSends = dict()
def registerMessageType(self, messageType, callback, overwrite=False, throttling=None, mergeFunction=None): def setState(self, state):
self._messageTypes[messageType] = (callback, overwrite, throttling, mergeFunction) self._state = state
if throttling is not None: self._changeEvent.set()
self._lastSends[messageType] = time.time()
def message(self, messageType, data, timestamp=time.time()): def setJobData(self, jobData):
if not self._messageTypes.has_key(messageType): self._jobData = jobData
return self._changeEvent.set()
(callback, overwrite, throttling, merger) = self._messageTypes[messageType] def setGcodeData(self, gcodeData):
updated = False self._gcodeData = gcodeData
try: self._changeEvent.set()
self.mutex.acquire()
if overwrite or throttling is not None or merger is not None:
for item in self.queue:
if item.type == messageType and ((throttling is not None and item.timestamp + throttling < time.time()) or overwrite or merger is not None):
if merger is not None:
item.payload = merger(item.payload, data)
else:
item.payload = data
updated = True
break
finally:
self.mutex.release()
if not updated: def setProgress(self, progress):
item = MessageQueueItem(messageType, timestamp, data) self._progress = progress
self.put(item) self._changeEvent.set()
def read(self): def _work(self):
item = None while True:
while item is None: self._changeEvent.wait()
item = self.get() additionalWaitTime = time.time() + self._ratelimit - self._lastUpdate
if not self._messageTypes.has_key(item.type): if additionalWaitTime > 0:
self.task_done() time.sleep(additionalWaitTime)
item = None
(callback, overwrite, throttling, merger) = self._messageTypes[item.type]
if throttling and self._lastSends[item.type] + throttling > time.time():
self.message(item.type, item.payload, item.timestamp)
item = None
self._lastSends[item.type] = time.time() with self._temperatureBacklogMutex:
return (callback, item.payload) temperatures = self._temperatureBacklog
self._temperatureBacklog = []
class MessageQueueItem(object): with self._logBacklogMutex:
def __init__(self, type, timestamp, payload): logs = self._logBacklog
self.type = type self._logBacklog = []
self.timestamp = timestamp
self.payload = payload with self._messageBacklogMutex:
messages = self._messageBacklog
self._messageBacklog = []
data = self.getCurrentData()
data.update({
"temperatures": temperatures,
"logs": logs,
"messages": messages
})
self._updateCallback(data)
self._lastUpdate = time.time()
self._changeEvent.clear()
def getCurrentData(self):
return {
"state": self._state,
"job": self._jobData,
"gcode": self._gcodeData,
"currentZ": self._currentZ
}

66
printer_webui/server.py
View File

@ -44,69 +44,13 @@ class PrinterStateConnection(tornadio2.SocketConnection, PrinterCallback):
def on_message(self, message): def on_message(self, message):
pass pass
def zChangeCB(self, currentZ): def sendCurrentData(self, data):
formattedCurrentZ = None print("Sending current data...")
if currentZ: self.emit("current", data)
formattedCurrentZ = "%.2f mm" % (currentZ)
print("Sending zChange...") def sendHistoryData(self, data):
self.emit("zChange", {"currentZ": formattedCurrentZ})
def progressChangeCB(self, currentLine, printTimeInSeconds, printTimeLeftInMinutes):
formattedPrintTime = None
if (printTimeInSeconds):
formattedPrintTime = _getFormattedTimeDelta(datetime.timedelta(seconds=printTimeInSeconds))
formattedPrintTimeLeft = None
if (printTimeLeftInMinutes):
formattedPrintTimeLeft = _getFormattedTimeDelta(datetime.timedelta(minutes=printTimeLeftInMinutes))
print("Sending progressChange...")
self.emit("printProgress", {
"currentLine": currentLine,
"printTime": formattedPrintTime,
"printTimeLeft": formattedPrintTimeLeft
})
def temperatureChangeCB(self, temperatures):
print("Sending temperatureChange...")
self.emit("temperatures", temperatures)
def stateChangeCB(self, state, stateString, booleanStates):
print("Sending stateChange...")
self.emit("state", {"currentState": stateString, "flags": booleanStates})
def logChangeCB(self, lines):
print("Sending logChange...")
self.emit("log", {"lines": lines})
def messageChangeCB(self, lines):
print("Sending messageChange...")
self.emit("message", {"lines": lines})
def gcodeChangeCB(self, filename, progress):
print("Sending gcodeChange...")
self.emit("gcode", {"filename": filename, "progress": progress})
def jobDataChangeCB(self, filename, lines, estimatedPrintTimeInMinutes, filamentLengthInMillimeters):
formattedPrintTimeEstimation = None
if estimatedPrintTimeInMinutes:
formattedPrintTimeEstimation = _getFormattedTimeDelta(datetime.timedelta(minutes=estimatedPrintTimeInMinutes))
formattedFilament = None
if filamentLengthInMillimeters:
formattedFilament = "%.2fm" % (filamentLengthInMillimeters / 1000)
formattedFilename = None
if filename:
formattedFilename = filename.replace(UPLOAD_FOLDER + os.sep, "")
print("Sending jobDataChange...")
self.emit("jobData", {"filename": formattedFilename, "lineCount": lines, "estimatedPrintTime": formattedPrintTimeEstimation, "filament": formattedFilament})
def sendHistoryData(self, tempHistory, logHistory, messageHistory):
print("Sending history...") print("Sending history...")
self.emit("history", {"temperature": tempHistory, "log": logHistory, "message": messageHistory}) self.emit("history", data)
#~~ Printer control #~~ Printer control

86
printer_webui/static/js/ui.js
View File

@ -49,7 +49,11 @@ function ConnectionViewModel() {
self.saveSettings(false); self.saveSettings(false);
} }
self.fromStateEvent = function(data) { self.fromCurrentData = function(data) {
self._processStateData(data.state);
}
self._processStateData = function(data) {
self.previousIsOperational = self.isOperational(); self.previousIsOperational = self.isOperational();
self.isErrorOrClosed(data.flags.closedOrError); self.isErrorOrClosed(data.flags.closedOrError);
@ -139,8 +143,20 @@ function PrinterStateViewModel() {
return "Pause"; return "Pause";
}); });
self.fromStateEvent = function(data) { self.fromCurrentData = function(data) {
self.stateString(data.currentState); self._processStateData(data.state);
self._processJobData(data.job);
self._processGcodeData(data.gcode);
self._processProgressData(data.progress);
self._processZData(data.currentZ);
}
self.fromHistoryData = function(data) {
self._processStateData(data.state)
}
self._processStateData = function(data) {
self.stateString(data.stateString);
self.isErrorOrClosed(data.flags.closedOrError); self.isErrorOrClosed(data.flags.closedOrError);
self.isOperational(data.flags.operational); self.isOperational(data.flags.operational);
self.isPaused(data.flags.paused); self.isPaused(data.flags.paused);
@ -150,32 +166,28 @@ function PrinterStateViewModel() {
self.isLoading(data.flags.loading); self.isLoading(data.flags.loading);
} }
self.fromJobEvent = function(data) { self._processJobData = function(data) {
self.filename(data.filename); self.filename(data.filename);
self.totalLines(data.lineCount); self.totalLines(data.lineCount);
self.estimatedPrintTime(data.estimatedPrintTime); self.estimatedPrintTime(data.estimatedPrintTime);
self.filament(data.filament); self.filament(data.filament);
} }
self.fromGcodeEvent = function(data) { self._processGcodeData = function(data) {
if (self.isLoading()) { if (self.isLoading()) {
self.filename("Loading... (" + Math.round(data.progress * 100) + ")"); self.filename("Loading... (" + Math.round(data.progress * 100) + "%)");
} }
} }
self.fromProgressEvent = function(data) { self._processProgressData = function(data) {
self.currentLine(data.currentLine); self.currentLine(data.currentLine);
self.printTime(data.printTime); self.printTime(data.printTime);
self.printTimeLeft(data.printTimeLeft); self.printTimeLeft(data.printTimeLeft);
} }
self.fromZChangeEvent = function(data) { self._processZData = function(data) {
self.currentHeight(data.currentZ); self.currentHeight(data.currentZ);
} }
self.fromGcodeEvent = function(data) {
self.filename("Loading... (" + Math.round(data.progress * 100) + "%)");
}
} }
var printerStateViewModel = new PrinterStateViewModel(); var printerStateViewModel = new PrinterStateViewModel();
@ -241,7 +253,17 @@ function TemperatureViewModel() {
} }
} }
self.fromStateEvent = function(data) { self.fromCurrentData = function(data) {
self._processStateData(data.state);
self._processTemperatureUpdateData(data.temperatures);
}
self.fromHistoryData = function(data) {
self._processStateData(data.state);
self._processTemperatureHistoryData(data.temperatureHistory);
}
self._processStateData = function(data) {
self.isErrorOrClosed(data.flags.closedOrError); self.isErrorOrClosed(data.flags.closedOrError);
self.isOperational(data.flags.operational); self.isOperational(data.flags.operational);
self.isPaused(data.flags.paused); self.isPaused(data.flags.paused);
@ -251,7 +273,7 @@ function TemperatureViewModel() {
self.isLoading(data.flags.loading); self.isLoading(data.flags.loading);
} }
self.fromTemperatureEvent = function(data) { self._processTemperatureUpdateData = function(data) {
if (data.length == 0) if (data.length == 0)
return; return;
@ -282,15 +304,15 @@ function TemperatureViewModel() {
self.temperatures.actualBed = self.temperatures.actualBed.slice(-300); self.temperatures.actualBed = self.temperatures.actualBed.slice(-300);
self.temperatures.targetBed = self.temperatures.targetBed.slice(-300); self.temperatures.targetBed = self.temperatures.targetBed.slice(-300);
self.updatePlot(); self._updatePlot();
} }
self.fromHistoryEvent = function(data) { self._processTemperatureHistoryData = function(data) {
self.temperatures = data; self.temperatures = data;
self.updatePlot(); self._updatePlot();
} }
self.updatePlot = function() { self._updatePlot = function() {
var data = [ var data = [
{label: "Actual", color: "#FF4040", data: self.temperatures.actual}, {label: "Actual", color: "#FF4040", data: self.temperatures.actual},
{label: "Target", color: "#FFA0A0", data: self.temperatures.target}, {label: "Target", color: "#FFA0A0", data: self.temperatures.target},
@ -556,27 +578,15 @@ function DataUpdater(connectionViewModel, printerStateViewModel, temperatureView
self.speedViewModel.fromStateEvent(data); self.speedViewModel.fromStateEvent(data);
self.webcamViewModel.fromStateEvent(data); self.webcamViewModel.fromStateEvent(data);
}) })
self.socket.on("temperatures", function(data) {
self.temperatureViewModel.fromTemperatureEvent(data);
})
self.socket.on("jobData", function(data) {
self.printerStateViewModel.fromJobEvent(data);
})
self.socket.on("gcode", function(data) {
self.printerStateViewModel.fromGcodeEvent(data);
})
self.socket.on("logs", function(data) {
self.terminalViewModel.fromLogEvent(data);
})
self.socket.on("printProgress", function(data) {
self.printerStateViewModel.fromProgressEvent(data);
})
self.socket.on("zChange", function(data) {
self.printerStateViewModel.fromZChangeEvent(data);
})
self.socket.on("history", function(data) { self.socket.on("history", function(data) {
self.temperatureViewModel.fromHistoryEvent(data.temperature) self.printerStateViewModel.fromHistoryData(data);
self.terminalViewModel.fromHistoryEvent(data.log) self.temperatureViewModel.fromHistoryData(data);
//self.terminalViewModel.fromHistoryData(data);
})
self.socket.on("current", function(data) {
self.connectionViewModel.fromCurrentData(data);
self.printerStateViewModel.fromCurrentData(data);
self.temperatureViewModel.fromCurrentData(data);
}) })
} }
var dataUpdater = new DataUpdater(connectionViewModel, printerStateViewModel, temperatureViewModel, speedViewModel, terminalViewModel, webcamViewModel); var dataUpdater = new DataUpdater(connectionViewModel, printerStateViewModel, temperatureViewModel, speedViewModel, terminalViewModel, webcamViewModel);