OctoPrint Plugin 만들기 #11 (시리얼 통신시 별도 쓰레드를 만들어 데이터 전송)

OctoPrint Plugin 만들기 #11 (시리얼 통신시 별도 쓰레드를 만들어 데이터 전송)

옥토 프린트 플러그인 만들기 (챔버 매니저)

□ 필요 함수

 - queue.get() : 할일 꺼내기

 - queue.put() : 할일 추가

 - queue.task_done() : 할일 완료 처리

 - thread.start() : 쓰레드 시작

 - _plugin_manager.send_plugin_message : Octoprint Back-End에서 Front-End로 데이터 전송

 - onDataUpdaterPluginMessage : Octoprint Back-End에서 Front-End로 데이터 전송시 이벤트 발생

 

[ __init__.py ]

# coding=utf-8
from __future__ import absolute_import
 
from decimal import *
from struct import *
from octoprint.events import eventManager, Events
from octoprint.util import RepeatedTimer
from serial import SerialException
from collections import namedtuple
 
import octoprint.plugin
import flask
import serial
import json
import datetime
import base64
from threading import Lock
 
from threading import Thread
from queue import Queue
 
import traceback
import sys
 
 
class ChamberManagerPlugin(octoprint.plugin.StartupPlugin,
                      octoprint.plugin.TemplatePlugin,
                      octoprint.plugin.SettingsPlugin,
                      octoprint.plugin.BlueprintPlugin,
                      octoprint.plugin.AssetPlugin):
 
    def __init__(self) :
        self.lock = Lock()
    
    # Add thread support
    task_queue = Queue()
    task_thread = None
 
    tempAmbient = []
    tempTarget = []
    tempLabel = []
    tempCurrent = None
 
    device = serial.Serial()
    
    serialParams = {
        'port' : None,
        'baudrate' : None,
        'timeout' : None,
        'autoconnect' : False
    }
 
    deviceParams = {
        'tempControlMode' : None,
        'tempControlTarget' : None,
        'doorVentilMaxPos' : None,
        'doorVentilMinPos' : None,
        'doorFilterMaxPos' : None,
        'doorFilterMinPos' : None,
        'doorControlVentilAngle' : None,
        'doorControlFilterAngle' : None,
        'fanControlVentilSpeed' : None,
        'fanControlFilterSpeed' : None,
        'lightControlMode' : None,
        'lightControlSensitive' : None,
        'lightControlInitailStatus' : None
    }
 
 
    TempControlModeOptionsStringToCode = {
        'Manual': '0',
        'ON/OFF': '1',
        'PID': '2'
    }
 
    TempControlModeOptionsCodeToString = {
        '0': 'Manual',
        '1': 'ON/OFF',
        '2': 'PID'
    }
 
    LightControlModeOptionsStringToCode = {
        'Off': '0',
        'On': '1',
        'Auto': '2'
    }
    
    LightControlModeOptionsCodeToString = {
        '0': 'Off',
        '1': 'On',
        '2': 'Auto'
    }    
        
    ControlObjectToID = {
        'writeEEPROM'                : '10',
        'deviceParams'                : '20',
        'doorVentilMaxPos'            : '111',
        'doorVentilMinPos'            : '112',
        'doorFilterMaxPos'            : '113',
        'doorFilterMinPos'            : '114',
        'tempControlMode'            : '200',
        'tempControlTarget'            : '201',
        'tempControlCurrent'        : '202',
        'fanEnable'                    : '300',
        'doorControlAngle'            : '311',
        'doorFanSpeed'                : '312',
        'ventilServoAngle'            : '321',
        'ventilFanSpeed'            : '322',
        'filterServoAngle'            : '331',
        'filterFanSpeed'            : '332',
        'lightControlMode'            : '400',
        'lightOnOff'                : '401',
        'lightControlSensitivity'    : '411',
        'lightControlSensCurrent'    : '421'
    }
 
 
    def task_serial(self):
        while True:
            try:
                obj, mode, value = self.task_queue.get()
                id = self.ControlObjectToID[obj]
                if self.device.is_open == True:
                    if mode == 'READ' :
                        if obj == 'deviceParams':
                            self.getDeviceParams(obj, value)
                        elif obj == 'tempControlCurrent':
                            self.getTemperature(obj, value)
                        else:
                            self.getDeviceValue(obj, value)
                    elif mode == 'WRITE' :
                        if obj == 'deviceParams':
                            self.setDeviceParams(obj, value)
                        else:
                            self.setDeviceValue(obj, value)
                self.task_queue.task_done()
            except SerialException as e:
                self._logger.error(e)
            except Exception as e:
                self._logger.error(e)
                exc_info = sys.exc_info()
                self._logger.error(exc_info)
                traceback.print_exception(*exc_info)
 
 
    def on_after_startup(self):
        try:
            self.serialParams['port'] = self._settings.get(['serial','port'])
            self.serialParams['baudrate'] = self._settings.get(['serial','baudrate'])
            self.serialParams['timeout'] = self._settings.get(['serial','timeout'])
            self.serialParams['autoconnect'] = self._settings.get(['serial','autoconnect'])
 
            if self.serialParams['autoconnect'] == True :
                port = self.serialParams['port']
                baudrate = self.serialParams['baudrate']
                timeout = self.serialParams['timeout']
                if self.connectToDevice(port, baudrate, timeout) == True :
                    if self.getDeviceParams('deviceParams', '0') == True :
                        self.saveParamsToSettings()
                    else :
                        self.saveSettingsToParams()
 
            # Add thread support
            self.task_thread = Thread(target=self.task_serial)
            self.task_thread.daemon = True
            self.task_thread.start()
            self.start_Timer()
            
        except Exception as e:
            self._logger.error(e)
        except SerialException as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
    
 
    def get_settings_defaults(self):
        return dict(
            serial = dict(
                port = '/dev/ttyS0',
                baudrate = 115200,
                timeout = 0.3,
                autoconnect = True,
            ),
            device = dict(
                tempControlMode = 'MANUAL',
                tempControlTarget = 26,
                
                doorVentilMaxPos = 2250,
                doorVentilMinPos = 750,
                doorFilterMaxPos = 2250,
                doorFilterMinPos = 750,
 
                doorControlPosValue = 'OPEN',
                doorControlAngle = 90,
 
                fanControlVentilSpeed = 100,
                fanControlFilterSpeed = 100,
 
                lightControlMode = 'Auto',
                lightControlSensitive = 255,
                lightControlInitailStatus = 1
            )
        )
 
 
    def get_template_configs(self):
        return [
            dict(type='navbar', custom_bindings=False),
            dict(type='tab', custom_bindings=False),
            dict(type='settings', custom_bindings=True)
        ]
 
    def get_assets(self):
        return dict(
            js=['js/chambermanager.js', 'js/Chart.js', 'js/Chart.min.js'],
            css=['css/chambermanager.css'],
            less=['less/chambermanager.less']
        )
 
    def saveSettingsToParams(self):
        try :
            self.deviceParams['tempControlMode'] = int(self.TempControlModeOptionsStringToCode[self._settings.get(['device','tempControlMode'])])
            self.deviceParams['tempControlTarget'] = self._settings.get(['device','tempControlTarget'])
            self.deviceParams['doorVentilMaxPos'] = self._settings.get(['device','doorVentilMaxPos'])
            self.deviceParams['doorVentilMinPos'] = self._settings.get(['device','doorVentilMinPos'])
            self.deviceParams['doorFilterMaxPos'] = self._settings.get(['device','doorFilterMaxPos'])
            self.deviceParams['doorFilterMinPos'] = self._settings.get(['device','doorFilterMinPos'])
            self.deviceParams['doorControlVentilAngle'] = self._settings.get(['device','doorControlAngle'])
            self.deviceParams['doorControlFilterAngle'] = self._settings.get(['device','doorControlAngle'])
            self.deviceParams['fanControlVentilSpeed'] = self._settings.get(['device','fanControlVentilSpeed'])
            self.deviceParams['fanControlFilterSpeed'] = self._settings.get(['device','fanControlFilterSpeed'])
            self.deviceParams['lightControlMode'] = int(self.TempControlModeOptionsStringToCode[self._settings.get(['device','lightControlMode'])])
            self.deviceParams['lightControlSensitive'] = self._settings.get(['device','lightControlSensitive'])
            self.deviceParams['lightControlInitailStatus'] = self._settings.get(['device','lightControlInitailStatus'])
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
 
 
    def saveParamsToSettings(self):
        try :
            self._settings.set(['device','tempControlMode'], self.TempControlModeOptionsCodeToString[str(self.deviceParams['tempControlMode'])])
            self._settings.set(['device','tempControlTarget'], self.deviceParams['tempControlTarget'])
            self._settings.set(['device','doorVentilMaxPos'], self.deviceParams['doorVentilMaxPos'])
            self._settings.set(['device','doorVentilMinPos'], self.deviceParams['doorVentilMinPos'])
            self._settings.set(['device','doorFilterMaxPos'], self.deviceParams['doorFilterMaxPos'])
            self._settings.set(['device','doorFilterMinPos'], self.deviceParams['doorFilterMinPos'])
            self._settings.set(['device','doorControlAngle'], self.deviceParams['doorControlVentilAngle'])
            if self.deviceParams['doorControlVentilAngle'] == 0 :
                self._settings.set(['device','doorControlPosValue'], 'CLOSE')
            elif self.deviceParams['doorControlVentilAngle'] == 90 :
                self._settings.set(['device','doorControlPosValue'], 'OPEN')
            else :
                self._settings.set(['device','doorControlPosValue'], 'UNKNOWN')
            self._settings.set(['device','fanControlVentilSpeed'], self.deviceParams['fanControlVentilSpeed'])
            self._settings.set(['device','fanControlFilterSpeed'], self.deviceParams['fanControlFilterSpeed'])
            self._settings.set(['device','lightControlMode'], self.LightControlModeOptionsCodeToString[str(self.deviceParams['lightControlMode'])])
            self._settings.set(['device','lightControlSensitive'], self.deviceParams['lightControlSensitive'])
            self._settings.set(['device','lightControlInitailStatus'], self.deviceParams['lightControlInitailStatus'])
 
            for key, value in self.deviceParams.items():
                self._logger.debug('{} : {}'.format(key, value))
 
            self._plugin_manager.send_plugin_message(self._identifier, dict(deviceParams=self.deviceParams))
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
 
 
    def connectToDevice(self, port, baudrate, timeout) :
        ret = False
        try:
            self.device.port = port
            self.device.baudrate = baudrate
            self.device.timeout = timeout
            if self.device.is_open == True :
                self.device.close()
            self.device.open()
            self.device.flush()
            msg = 'CMD O0 R0\r'
            with self.lock:
                self.device.write(msg.encode('ascii','ignore'))
                ret = self.device.read_until('\r')
            if ret.startswith('OK')==True :
                tok = ret.split(' ')
                if tok[1]=='O0' :
                    self._logger.info('Connected to device. [port='+port+' baudrate='+str(baudrate)+']')
                    ret = True
                else :
                    self.device.close()
                    self._logger.info('Connection error')
        except SerialException as e:
            self._logger.error(e)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
        return ret
 
 
    def updateControlValues(self, obj, data):
        try:
            if obj == 'tempControlMode':
                self._settings.set(['device',obj], self.TempControlModeOptionsCodeToString[data])
                self.deviceParams[obj] = int(data)
            elif obj == 'lightControlMode':
                self._settings.set(['device',obj], self.LightControlModeOptionsCodeToString[data])
                self.deviceParams[obj] = int(data)
            elif obj == 'doorControlAngle':
                angle = int(data)
                self._settings.set(['device',obj], angle)
                self.deviceParams['doorControlVentilAngle'] = angle
                self.deviceParams['doorControlFilterAngle'] = angle
                if angle == 0 :
                    self._settings.set(['device','doorControlPosValue'], 'CLOSE')
                elif angle == 90 :
                    self._settings.set(['device','doorControlPosValue'], 'OPEN')
                else :
                    self._settings.set(['device','doorControlPosValue'], 'UNKNOWN')
            else :
                self._settings.set([obj], int(float(data)))
                self.deviceParams[obj] = int(float(data))
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
 
 
    def setDeviceParams(self, obj, data):
        ret = False
        try:
            p = pack('<bhhhhhhhhhhhhh',
                    1,
                    self.deviceParams['tempControlMode'],
                    self.deviceParams['tempControlTarget'],
                    self.deviceParams['doorVentilMaxPos'],
                    self.deviceParams['doorVentilMinPos'],
                    self.deviceParams['doorFilterMaxPos'],
                    self.deviceParams['doorFilterMinPos'],
                    self.deviceParams['doorControlVentilAngle'],
                    self.deviceParams['doorControlFilterAngle'],
                    self.deviceParams['fanControlVentilSpeed'],
                    self.deviceParams['fanControlFilterSpeed'],
                    self.deviceParams['lightControlMode'],
                    self.deviceParams['lightControlSensitive'],
                    self.deviceParams['lightControlInitailStatus'])
            params = base64.b64encode(p)
            msg = 'CMD O{} R{} {}\r'.format((obj, len(params), params))
            self.device.write(msg.encode('ascii','ignore'))
            r = self.device.read_until('\r')
            if r.startswith('OK')==True :
                self._logger.info('Device parameter setting ok!')
            else :
                self._logger.info('Device parameter setting error!')
        except SerialException as e:
            self._logger.error(e)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
 
        return ret        
 
 
    def getDeviceParams(self, obj, data):
        ret = False
        try:
            msg = 'CMD O{} R{}\r'.format(self.ControlObjectToID[obj], data)
            with self.lock:
                self.device.write(msg.encode('ascii','ignore'))
                r = self.device.read_until('\r')
            if r.startswith('OK')==True:
                tok = r.split(' ')
                decoded = base64.b64decode(tok[2])
                deviceParams = namedtuple('params', 'firstRun tempControlMode tempControlTarget doorVentilMaxPos doorVentilMinPos doorFilterMaxPos doorFilterMinPos doorControlVentilAngle doorControlFilterAngle fanControlVentilSpeed fanControlFilterSpeed lightControlMode lightControlSensitive lightControlInitailStatus')
                params = deviceParams._make(unpack('<bhhhhhhhhhhhhh', decoded))
 
                self.deviceParams['tempControlMode'] = params.tempControlMode
                self.deviceParams['tempControlTarget'] = params.tempControlTarget
                self.deviceParams['doorVentilMaxPos'] = params.doorVentilMaxPos
                self.deviceParams['doorVentilMinPos'] = params.doorVentilMinPos
                self.deviceParams['doorFilterMaxPos'] = params.doorFilterMaxPos
                self.deviceParams['doorFilterMinPos'] = params.doorFilterMinPos
                self.deviceParams['doorControlVentilAngle'] = params.doorControlVentilAngle
                self.deviceParams['doorControlFilterAngle'] = params.doorControlFilterAngle
                self.deviceParams['fanControlVentilSpeed'] = params.fanControlVentilSpeed
                self.deviceParams['fanControlFilterSpeed'] = params.fanControlFilterSpeed
                self.deviceParams['lightControlMode'] = params.lightControlMode
                self.deviceParams['lightControlSensitive'] = params.lightControlSensitive
                self.deviceParams['lightControlInitailStatus'] = params.lightControlInitailStatus
 
                self._logger.info('Successfully received parameters from device.')
                ret = True
            else :
                self._logger.info('Error during receiving parameters from device')
 
        except SerialException as e:
            self._logger.error(e)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
        
        return ret
 
 
    def getTemperature(self, obj, data):
        ret = False
        try:
            msg = 'CMD O{} R{}\r'.format(self.ControlObjectToID[obj], data)
            self.device.write(msg.encode('ascii','ignore'))
            r = self.device.read_until('\r')
            if r.startswith('OK')==True :
                tok = r.split(' ')
                self.tempCurrent = float(tok[2])
                if len(self.tempAmbient) < 900 :
                    self.tempAmbient.append(self.tempCurrent)
                    self.tempTarget.append(self.deviceParams['tempControlTarget'])
                    self.tempLabel.append(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
                else :
                    for i in range(0, 899) :
                        self.tempAmbient[i] = self.tempAmbient[i+1]
                        self.tempTarget[i] = self.tempTarget[i+1]
                        self.tempLabel[i] = self.tempLabel[i+1]
                    self.tempAmbient[899] = self.tempCurrent
                    self.tempTarget[899] = self.deviceParams['tempControlTarget']
                    self.tempLabel[899] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                TempData = {
                    'Actual'   : self.tempCurrent,
                    'Target'    : self.deviceParams['tempControlTarget'],
                    'TimeStamp' : datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                }
                ret = True
                self._plugin_manager.send_plugin_message(self._identifier, dict(current_temp=TempData))
        except SerialException as e:
            self._logger.error(e)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
        return ret
 
 
    def getDeviceValue(self, obj, data):
        ret = False
        try:
            msg = 'CMD O{} R{}\r'.format(self.ControlObjectToID[obj], data)
            self.device.write(msg.encode('ascii','ignore'))
            r = self.device.read_until('\r')
            if r.startswith('OK') == True:
                tok = r.split(' ')
                self.updateControlValues(obj, tok[2])
                value = {
                    'object'   : obj,
                    'value'        : tok[2]
                }
                ret = True
                self._logger.debug('getDeviceValue : {} {}'.format(obj, tok[2]))
                self._plugin_manager.send_plugin_message(self._identifier, dict(device_value=value))
        except SerialException as e:
            self._logger.error(e)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
        return ret
 
 
    def setDeviceValue(self, obj, data):
        ret = False
        try:
            if obj == 'tempControlMode':
                data = self.TempControlModeOptionsStringToCode[data]
            elif obj == 'lightControlMode':
                data = self.LightControlModeOptionsStringToCode[data]
            msg = 'CMD O{} W{}\r'.format(self.ControlObjectToID[obj], data)
            self.device.write(msg.encode('ascii','ignore'))
            r = self.device.read_until('\r')
            if r.startswith('OK') == True:
                tok = r.split(' ')
                self.updateControlValues(obj, tok[2])
                cv = {
                    'Control'   : obj,
                    'Value'        : tok[2]
                }
                ret = True
                self._plugin_manager.send_plugin_message(self._identifier, dict(control_value=cv))
        except SerialException as e:
            self._logger.error(e)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
        return ret
 
    
    def start_Timer(self):
        self._timer = RepeatedTimer(2.0, self.checkTimer, run_first=True)
        self._timer.start()
    
    def checkTimer(self):
        if self.device.is_open == True :
            self.task_queue.put(('tempControlCurrent', 'READ', '0'))
 
 
    # ~~ Blueprintplugin mixin
    @octoprint.plugin.BlueprintPlugin.route('/getConnectionStatus', methods=['GET'])
    def blueprintPluginGetConnectionStatus(self):
        return flask.Response(json.dumps(self.device.is_open), mimetype='application/json')
 
    @octoprint.plugin.BlueprintPlugin.route('/setConnectionStatus', methods=['GET'])
    def blueprintPluginSetConnectionStatus(self):
        try:
            serial_cmd = flask.request.values['cmd']
            serial_port = None
            serial_baudrate = None
            serial_timeout = None
            
            if serial_cmd.upper()=='CONNECTED':
                serial_port = flask.request.values['port']
                serial_baudrate = flask.request.values['baudrate']
                serial_timeout = flask.request.values['timeout']
                
                self._logger.debug('Try connect to device')
 
                if self.device.is_open == True :
                    self.device.close()
                self.connectToDevice(serial_port, Decimal(serial_baudrate), float(serial_timeout))
            elif serial_cmd.upper()=='DISCONNECTED':
                self._logger.debug('Try disconnect from device')
                if self.device.is_open == True :
                    self.device.close()
        except SerialException as e:
            self._logger.error(e)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
            
        return flask.Response(json.dumps(self.device.is_open), mimetype='application/json')                    
 
 
    @octoprint.plugin.BlueprintPlugin.route('/setControlValues', methods=['GET'])
    def blueprintPluginSetControlValues(self):
        try:
            set_object = flask.request.values['object']
            set_value = flask.request.values['value']
            
            self._logger.debug('Object: '+set_object+' Value: '+set_value)
            
            if self.device.is_open == True :
                self.task_queue.put((set_object, 'WRITE', set_value))
                return flask.jsonify(success=True)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
            
        return flask.jsonify(success=False)
 
 
    @octoprint.plugin.BlueprintPlugin.route('/getControlValues', methods=['GET'])
    def blueprintPluginGetControlValues(self):
        try:
            get_object = flask.request.values['object']
            
            self._logger.debug('Object: '+get_object)
 
            if self.device.is_open == True:
                self.task_queue.put((get_object, 'READ', '0'))
                return flask.jsonify(success=True)
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)
    
        return flask.jsonify(success=False)        
 
 
    @octoprint.plugin.BlueprintPlugin.route('/getTemperature', methods=['GET'])
    def blueprintPluginGetTemperature(self):
        get_cmd = flask.request.values['cmd']
 
        res = None
 
        try:
            if get_cmd.upper() == 'CURRENT' :
                res = [get_cmd, self.tempCurrent, self.tempControlTarget, datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')]
                self._logger.debug('Get current temp')
            elif get_cmd.upper() == 'HISTORY' :
                res = [get_cmd, self.tempAmbient, self.tempTarget, self.tempLabel]
                self._logger.debug('Get temp history')
        except Exception as e:
            self._logger.error(e)
            exc_info = sys.exc_info()
            self._logger.error(exc_info)
            traceback.print_exception(*exc_info)            
 
        return flask.Response(json.dumps(res), mimetype='application/json')
 
 
 
__plugin_name__ = 'Chamber Manager'
__plugin_implementation__ = ChamberManagerPlugin()

[ chambermanager.js ]

$(function() {
    function ChamberManagerViewModel(parameters) {
        var self = this;
 
        self.settings = parameters[0];
        self.connections = parameters[1];
 
        self.pluginName = "chambermanager";
 
        self.disableControl = ko.observable(false);
 
        self.serialParams = {
            serial_port : ko.observable('/dev/ttyS0'),
            serial_baudrate : ko.observable(115200),
            serial_timeout : ko.observable(0.5),
            serial_timeout_ms : ko.observable(500),
            serial_connectionStatus : ko.observable(false),
            serial_autoconnect : ko.observable(false),
            serial_portOptions : ko.observableArray(['/dev/ttyS0', '/dev/ttyS1']),
            serial_baudrateOptions : ko.observableArray([115200]),
            serial_connectionOptions : ko.observableArray(['Connected', 'Disconnected'])
        };
 
        self.deviceParams = {
            tempControlOptions : ko.observableArray(['Manual', 'ON/OFF', 'PID']),
            tempControlMode : ko.observable('ON/OFF'),
            tempControlTarget : ko.observable(26),
            tempControlActual : ko.observable(25.5),
 
            doorVentilMaxPos : ko.observable(2250),
            doorVentilMinPos : ko.observable(750),
            doorFilterMaxPos : ko.observable(2250),
            doorFilterMinPos : ko.observable(750),
 
            doorControlAngle : ko.observable(90),
            doorControlVentilAngle : ko.observable(90),
            doorControlFilterAngle : ko.observable(90),
            doorControlPosOptions : ko.observableArray(['CLOSE', 'UNKNOWN', 'OPEN']),
            doorControlPosValue : ko.observable('OPEN'),
 
            fanControlVentilSpeed : ko.observable(100),
            fanControlFilterSpeed : ko.observable(100),
 
            lightControlOptions : ko.observableArray(['Off', 'On', 'Auto']),
            lightControlMode : ko.observable('Auto'),
            lightControlSensitive : ko.observable(255),
            lightControlSensCurrent : ko.observable(255)
        };
 
 
        self.changeConnectionStatus = function(mode) {
            if(self.serialParams['serial_connectionStatus'] != mode) {
                self.setSerialConnection(mode);
            }
        }
 
        self.setDoorVentilMaxPos = function() {
            self.settings.saveData();
 
            self.setControlValue('doorVentilMaxPos', self.deviceParams.doorVentilMaxPos());
        }
 
        self.setDoorVentilMinPos = function() {
            self.setControlValue('doorVentilMinPos', self.deviceParams.doorVentilMinPos());
        }
 
        self.setDoorFilterMaxPos = function() {
            self.setControlValue('doorFilterMaxPos', self.deviceParams.doorFilterMaxPos());
        }
 
        self.setDoorFilterMinPos = function() {
            self.setControlValue('doorFilterMinPos', self.deviceParams.doorFilterMinPos());
        }
 
        self.setLightControlSensitive = function() {
            self.setControlValue('lightControlSensitive', self.deviceParams.lightControlSensitive());
        }
 
        self.getLightControlSensCurrent = function() {
            self.getControlValue('lightControlSensCurrent');
        }
 
 
        self.changeControlMode = function(mode) {
            try {
                self.deviceParams.tempControlMode(mode);
                self.settings.settings.plugins.chambermanager.device.tempControlMode(mode);
 
                if (mode === 'Manual') {
                    self.disableControl(false);
                } else {
                    self.disableControl(true);
                }
                self.settings.saveData();
                self.setControlValue('tempControlMode', mode);
            } catch (ex) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
        self.tempControlDecrementTarget = function() {
            var value = self.deviceParams.tempControlTarget();
 
            try {
                value = parseInt(value);
                if (value <= 0) return;
                self.deviceParams.tempControlTarget(value - 1);
            } catch (ex) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
        self.tempControlIncrementTarget = function() {
            var value = self.deviceParams.tempControlTarget();
 
            try {
                value = parseInt(value);
                if (value >= 999) return;
                self.deviceParams.tempControlTarget(value + 1);
            } catch (ex) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
        self.setTempControlTarget = function() {
            self.setControlValue('tempControlTarget', self.deviceParams.tempControlTarget());
        }
 
        self.setDoorControlAngle = function() {
            switch (self.deviceParams.doorControlAngle()) {
                case 0:
                    self.deviceParams.doorControlPosValue('CLOSE');
                    break;
                case 90:
                    self.deviceParams.doorControlPosValue('OPEN');
                    break;
                default:
                    self.deviceParams.doorControlPosValue('UNKNOWN');
                    break;
            }
 
            self.settings.settings.plugins.chambermanager.device.doorControlPosValue(self.deviceParams.doorControlPosValue());
            self.settings.settings.plugins.chambermanager.device.doorControlAngle(self.deviceParams.doorControlAngle());
            self.settings.saveData();
 
            self.setControlValue('doorControlAngle', self.deviceParams.doorControlAngle());
        }
 
        self.setDoorControlPosition = function(mode) {
            try {
                if (mode === 'OPEN') {
                    self.deviceParams.doorControlAngle(90);
                }
                if (mode === 'UNKNOWN') {
                    self.deviceParams.doorControlAngle(45);
                }
                if (mode === 'CLOSE') {
                    self.deviceParams.doorControlAngle(0);
                }
 
                self.deviceParams.doorControlPosValue(mode);
                self.settings.settings.plugins.chambermanager.device.doorControlPosValue(mode);
                self.settings.settings.plugins.chambermanager.device.doorControlAngle(self.deviceParams.doorControlAngle());
                self.settings.saveData();
 
                self.setControlValue('doorControlAngle', self.deviceParams.doorControlAngle());
            } catch (ex) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
        self.setVentilFanSpeed = function() {
            self.settings.settings.plugins.chambermanager.device.fanControlVentilSpeed(self.deviceParams.fanControlVentilSpeed());
            self.settings.saveData();
 
            self.setControlValue('ventilFanSpeed', self.deviceParams.fanControlVentilSpeed());
        }
 
        self.setFilterFanSpeed = function() {
            self.settings.settings.plugins.chambermanager.device.fanControlFilterSpeed(self.deviceParams.fanControlFilterSpeed());
            self.settings.saveData();
 
            self.setControlValue('filterFanSpeed', self.deviceParams.fanControlFilterSpeed());
        }
 
        self.setLightControlMode = function(mode) {
            self.deviceParams.lightControlMode(mode);
            self.settings.settings.plugins.chambermanager.device.lightControlMode(mode);
 
            self.setControlValue('lightControlMode', mode);
 
            self.settings.saveData();
        }
 
 
        self.bindFromSettings = function() {
 
            try {
                self.serialParams['serial_port'] = self.settings.settings.plugins.chambermanager.serial.port();
                self.serialParams['serial_baudrate'] = self.settings.settings.plugins.chambermanager.serial.baudrate();
                self.serialParams['serial_timeout'] = self.settings.settings.plugins.chambermanager.serial.timeout();
                self.serialParams['serial_timeout_ms'] = self.serialParams['serial_timeout']*1000;
                self.serialParams['serial_autoconnect'] = self.settings.settings.plugins.chambermanager.serial.autoconnect();
 
                self.serialParams['serial_portOptions'] = self.connections.portOptions();
                var idx = self.serialParams['serial_portOptions'].indexOf(self.connections.selectedPort());
                self.serialParams['serial_portOptions'].splice(idx, 1);
                // self.serialParams['serial_baudrateOptions'] = self.connections.baudrateOptions();
 
                self.deviceParams.tempControlMode(self.settings.settings.plugins.chambermanager.device.tempControlMode());
                self.deviceParams.tempControlTarget(self.settings.settings.plugins.chambermanager.device.tempControlTarget());
 
                self.deviceParams.doorVentilMaxPos(self.settings.settings.plugins.chambermanager.device.doorVentilMaxPos());
                self.deviceParams.doorVentilMinPos(self.settings.settings.plugins.chambermanager.device.doorVentilMinPos());
                self.deviceParams.doorFilterMaxPos(self.settings.settings.plugins.chambermanager.device.doorFilterMaxPos());
                self.deviceParams.doorFilterMinPos(self.settings.settings.plugins.chambermanager.device.doorFilterMinPos());
 
                self.deviceParams.doorControlAngle(self.settings.settings.plugins.chambermanager.device.doorControlAngle());
                self.deviceParams.doorControlPosValue(self.settings.settings.plugins.chambermanager.device.doorControlPosValue());
 
                self.deviceParams.fanControlVentilSpeed(self.settings.settings.plugins.chambermanager.device.fanControlVentilSpeed());
                self.deviceParams.fanControlFilterSpeed(self.settings.settings.plugins.chambermanager.device.fanControlFilterSpeed());
 
                self.deviceParams.lightControlMode(self.settings.settings.plugins.chambermanager.device.lightControlMode());
                self.deviceParams.lightControlSensitive(self.settings.settings.plugins.chambermanager.device.lightControlSensitive());
 
                if (self.deviceParams.tempControlMode() != 'Manual') {
                    self.disableControl(true);
                } else {
                    self.disableControl(false);
                }
 
            } catch (ex) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
 
        }
 
        self.bindToSettings = function() {
 
            try {
                self.settings.settings.plugins.chambermanager.serial.port(self.serialParams['serial_port']);
                self.settings.settings.plugins.chambermanager.serial.baudrate(self.serialParams['serial_baudrate']);
                self.serialParams['serial_timeout'] = self.serialParams['serial_timeout_ms'] / 1000;
                self.settings.settings.plugins.chambermanager.serial.timeout(self.serialParams['serial_timeout']);
                self.settings.settings.plugins.chambermanager.serial.autoconnect(self.serialParams['serial_autoconnect']);
 
                self.settings.settings.plugins.chambermanager.device.tempControlMode(self.deviceParams.tempControlMode());
                self.settings.settings.plugins.chambermanager.device.tempControlTarget(self.deviceParams.tempControlTarget());
 
                self.settings.settings.plugins.chambermanager.device.doorVentilMaxPos(self.deviceParams.doorVentilMaxPos());
                self.settings.settings.plugins.chambermanager.device.doorVentilMinPos(self.deviceParams.doorVentilMinPos());
                self.settings.settings.plugins.chambermanager.device.doorFilterMaxPos(self.deviceParams.doorFilterMaxPos());
                self.settings.settings.plugins.chambermanager.device.doorFilterMinPos(self.deviceParams.doorFilterMinPos());
 
                self.settings.settings.plugins.chambermanager.device.doorControlAngle(self.deviceParams.doorControlAngle());
                self.settings.settings.plugins.chambermanager.device.doorControlPosValue(self.deviceParams.doorControlPosValue());
 
                self.settings.settings.plugins.chambermanager.device.fanControlVentilSpeed(self.deviceParams.fanControlVentilSpeed());
                self.settings.settings.plugins.chambermanager.device.fanControlFilterSpeed(self.deviceParams.fanControlFilterSpeed());
 
                self.settings.settings.plugins.chambermanager.device.lightControlMode(self.deviceParams.lightControlMode());
                self.settings.settings.plugins.chambermanager.device.lightControlSensitive(self.deviceParams.lightControlSensitive());
 
            } catch (ex) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
 
        }
 
        self.getSerialConnectionStatus = function(value) {
            var request = { value };
 
            $.ajax({
                url: self.buildPluginUrl("/getConnectionStatus"),
                type: "GET",
                dataType: "json",
                data: request,
                success: function(data) {
                    if (data == true) {
                        self.serialParams['serial_connectionStatus'] = 'Connected';
                    } else {
                        self.serialParams['serial_connectionStatus'] = 'Disconnected';
                    }
                },
                error: function(textStatus, errorThrown) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: textStatus,
                        type: "error"
                    });
                }
            });
        }
 
        self.setSerialConnection = function(cmd) {
            var port = self.serialParams['serial_port'];
            var baudrate = self.serialParams['serial_baudrate'];
            var timeout = self.serialParams['serial_timeout'];
            var request = { cmd, port, baudrate, timeout };
 
            $.ajax({
                url: self.buildPluginUrl("/setConnectionStatus"),
                type: "GET",
                dataType: "json",
                data: request,
                success: function(data) {
                    if (data == true) {
                        self.serialParams['serial_connectionStatus'] = 'Connected';
                    } else {
                        self.serialParams['serial_connectionStatus'] = 'Disconnected';
                    }
                },
                error: function(textStatus, errorThrown) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: textStatus,
                        type: "error"
                    });
                }
            });
        }
 
        self.setControlValue = function(object, value) {
            var request = { object, value };
 
            $.ajax({
                url: self.buildPluginUrl("/setControlValues"),
                type: "GET",
                dataType: "json",
                data: request,
                success: function(data) {
                },
                error: function(textStatus, errorThrown) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: textStatus,
                        type: "error"
                    });
                }
            });
        }
 
        self.getControlValue = function(object) {
            var request = { object };
 
            $.ajax({
                url: self.buildPluginUrl("/getControlValues"),
                type: "GET",
                dataType: "json",
                data: request,
                success: function(data) {
                },
                error: function(textStatus, errorThrown) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: textStatus,
                        type: "error"
                    });
                }
            });
        }
 
        self.buildPluginUrl = function(path) {
            return window.PLUGIN_BASEURL + self.pluginName + path;
        };
 
        //
        // For Temperature
        // 
 
        self.Chart = undefined;
        self.ChartConfig = undefined;
        self.ChartUpdateTimer = undefined;
        self.historyTempChecked = false;
        self.historyTemp = {
            actuals: [],
            targets: [],
            labels: [],
            countMax: 900
        };
        self.historyTempLogScale = {
            actuals: new Array(200),
            targets: new Array(200),
            labels: new Array(200),
            countMax: 900
        };
 
 
        self.initializeChart = function() {
            try {
 
                self.ChartConfig = {
                    type: 'line',
                    data: {
                        labels: [],
                        datasets: [{
                            label: 'Target',
                            backgroundColor: 'rgba(255,0,0,0.4)',
                            borderColor: 'rgba(255,0,0,0.4)',
                            data: [],
                            fill: false,
                            pointRadius: 0,
                            pointHoverRadius: 0,
                        }, {
                            label: 'Actual',
                            fill: false,
                            backgroundColor: 'rgba(255,0,0,0.8)',
                            borderColor: 'rgba(255,0,0,0.8)',
                            data: [],
                            fill: false,
                            pointRadius: 0,
                            pointHoverRadius: 0,                            
                        }]
                    },
                    options: {
                        animation: {
                            duration: 0, // general animation time
                        },
                        hover: {
                            animationDuration: 0, // duration of animations when hovering an item
                            enabled: false,
                        },
                        responsiveAnimationDuration: 0, // animation duration after a resize
                        elements: {
                            line: {
                                tension: 0, // disables bezier curves
                            }
                        },
                        title: {
                            display: true,
                            text: 'Ambient Temperature'
                        },
                        legend: {
                            display: false,
                        },
                        tooltips: {
                            enabled: false,
                        },
                        scales: {
                            xAxes: [{
                                display: true,
                                scaleLabel: {
                                    display: false,
                                    labelString: 'Time',
                                }
                            }],
                            yAxes: [{
                                display: true,
                                scaleLabel: {
                                    display: false,
                                    labelString: 'Temperature'
                                },
                                ticks: {
                                    suggestedMin: 10,
                                    suggestedMax: 50
                                }
        
                            }]
                        }
                    }
                };
 
                self.Chart = new Chart($("#AmbientTempChart"), self.ChartConfig );
            }
            catch (e) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
        
        self.updateTemperature = function() {
            var ret = undefined;
 
            try {
                if(self.historyTemp.labels.length==0) {
                    self.getCurrentTemp('HISTORY');
                } else {
                    self.getCurrentTemp('CURRENT');
                }
            }
            catch (e) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
 
        }
 
        self.getCurrentTemp = function(cmd) {
            var request = { cmd };
            var ret = undefined;
 
            try {
                $.ajax({
                    url: self.buildPluginUrl("/getTemperature"),
                    type: "GET",
                    dataType: "json",
                    data: request,
                    success: function(data) {
                        ret = data;
                        if(ret[0].toUpperCase() == 'HISTORY') {
                            if(ret[3].length>self.historyTemp.countMax) {
                                var pos = ret[3].length - self.historyTemp.countMax;
 
                                self.historyTemp.actuals = ret[1].slice(pos);
                                self.historyTemp.targets = ret[2].slice(pos);
                                self.historyTemp.labels = ret[3].slice(pos);
                            } else {
                                self.historyTemp.actuals = ret[1];
                                self.historyTemp.targets = ret[2];
                                self.historyTemp.labels = ret[3];
                            }
                        } else if(ret[0].toUpperCase() == 'CURRENT') {
                            self.historyTemp.actuals.push(ret[1]);
                            self.historyTemp.targets.push(ret[2]);
                            self.historyTemp.labels.push(ret[3]);
 
                            self.deviceParams.tempControlActual(ret[1]);
                            self.deviceParams.tempControlTarget(ret[2]);
 
                            if(self.historyTemp.labels.length>self.historyTemp.countMax) {
                                self.historyTemp.actuals.shift();
                                self.historyTemp.targets.shift();
                                self.historyTemp.labels.shift();
                            }
                        }
 
                        self.processTemperature();
                    },
                    error: function(textStatus, errorThrown) {
                        new PNotify({
                            title: "Chamber Manager",
                            text: textStatus,
                            type: "error"
                        });
                    }
                });
            }
            catch (e) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
        self.processCurrentTemp = function(current, target, timestamp) {
            try {
                self.historyTemp.actuals.push(current);
                self.historyTemp.targets.push(target);
                self.historyTemp.labels.push(timestamp);
    
                self.deviceParams.tempControlActual(current);
    
                if(self.historyTemp.labels.length>self.historyTemp.countMax) {
                    self.historyTemp.actuals.shift();
                    self.historyTemp.targets.shift();
                    self.historyTemp.labels.shift();
                }
                self.processTemperature();
            }
            catch (e) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
 
        self.processTemperature = function() {
 
            if(self.historyTemp.labels.length<200) {
                try {
                    var labels =  self.historyTemp.labels.slice();
 
                    self.ChartConfig.data.labels = labels;
                    self.ChartConfig.data.datasets[0].data = self.historyTemp.actuals;
                    self.ChartConfig.data.datasets[1].data = self.historyTemp.targets;
    
                    var last = self.ChartConfig.data.labels.length - 1;
                    var dtNow = Date.parse(self.ChartConfig.data.labels[last]);
                    for(var i in self.ChartConfig.data.labels) {
                        var diffMin = (dtNow - Date.parse(self.ChartConfig.data.labels[i]))/(1000*60);
                        self.ChartConfig.data.labels[i] = String(-1*parseInt(diffMin*100)/100);
                    }
                }
                catch (e) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: ex.message,
                        type: "error"
                    });
                }
            } else {
                try {
                    for(var i=0; i<200; i++) {
                        //          LastArrayIndex                    -ROUNDUP  (LastArrayIndex                    /9*(   POWER(10,(199-Index)/200)-1),0)
                        var index = (self.historyTemp.labels.length-1)-Math.ceil((self.historyTemp.labels.length-1)/9*(Math.pow(10,(199-i)/200)-1),0);
    
                        self.historyTempLogScale.actuals[i] = self.historyTemp.actuals[index];
                        self.historyTempLogScale.targets[i] = self.historyTemp.targets[index];
                        self.historyTempLogScale.labels[i] = self.historyTemp.labels[index];
                    }
                    self.ChartConfig.data.labels = self.historyTempLogScale.labels;
                    self.ChartConfig.data.datasets[0].data = self.historyTempLogScale.actuals;
                    self.ChartConfig.data.datasets[1].data = self.historyTempLogScale.targets;
 
                    var last = self.ChartConfig.data.labels.length - 1;
                    var dtNow = Date.parse(self.ChartConfig.data.labels[last]);
                    var ticks = 0;
                    for(var i in self.ChartConfig.data.labels) {
                        var diffMin = (dtNow - Date.parse(self.ChartConfig.data.labels[i]))/(1000*60);
 
                        if((ticks++%10)==0) {
                            self.ChartConfig.data.labels[i] = String(-1*parseInt(diffMin*10)/10);
                        } else {
                            self.ChartConfig.data.labels[i] = String(-1*parseInt(diffMin*10)/10);
                        }
 
                        
                    }
                }
                catch (e) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: ex.message,
                        type: "error"
                    });
                }
            }
 
            self.Chart.update();
        }
 
 
        self.onStartup = function() {
            self.initializeChart();
        }
 
 
        self.onStartupComplete = function() {
            self.historyTempChecked = true;            
            self.getCurrentTemp('HISTORY');
        };
 
        self.onDataUpdaterPluginMessage = function (plugin, data) {
            if (typeof plugin == 'undefined'){
                return;
            }
            if (plugin != "chambermanager") {
               return;
            }
 
            if (data.hasOwnProperty("current_temp")) {
                self.processCurrentTemp(data.current_temp.Actual, data.current_temp.Target, data.current_temp.TimeStamp);
            }
            else if (data.hasOwnProperty("device_value")) {
                try{
                    self.deviceParams[data.device_value.object] = data.device_value.value;
                }
                catch (e) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: ex.message,
                        type: "error"
                    });
                }
            }
            else if (data.hasOwnProperty("deviceParams")) {
                for(var key in data) {
                    var value = data[key];
 
                    if(key == 'tempControlMode') {
                        switch(value) {
                            case 1:
                                value = 'Manual';
                                break;
                            case 2:
                                value = 'PID';
                                break;
                            default:
                                value = 'Manual';
                                break;
                        }
                        self.deviceParams.tempControlMode(value);
                    }
                    if(key == 'doorControlPosValue') {
                        switch(value) {
                            case 0:
                                value = 'CLOSE';
                                break;
                            case 90:
                                value = 'OPEN';
                                break;
                            default:
                                value = 'UNKNOWN';
                        }
                        self.deviceParams.doorControlPosValue(value);
                    }
                    if(key == 'lightControlMode') {
                        switch(value) {
                            case 1:
                                value = 'On';
                                break;
                            case 2:
                                value = 'Auto';
                                break;
                            default:
                                value = 'Off';
                                break;
                        }
                        self.deviceParams.lightControlMode(value);
                    }
                    else {
                        self.deviceParams[key] = value;
                    }
                }
            }
 
        };
 
 
        // This will get called before the ChamberManagerViewModel gets bound to the DOM, but after its
        // dependencies have already been initialized. It is especially guaranteed that this method
        // gets called _after_ the settings have been retrieved from the OctoPrint backend and thus
        // the SettingsViewModel been properly populated.
        self.onBeforeBinding = function() {
            self.bindFromSettings();
            self.getSerialConnectionStatus();
        }
 
        self.onSettingsBeforeSave = function() {
            self.bindToSettings();
        }
 
        self.onSettingsShown = function() {
            self.serialParams['serial_port'] = self.settings.settings.plugins.chambermanager.serial.port();
            self.serialParams['serial_baudrate'] = self.settings.settings.plugins.chambermanager.serial.baudrate();
            self.serialParams['serial_timeout'] = self.settings.settings.plugins.chambermanager.serial.timeout();
            self.serialParams['serial_timeout_ms'] = self.serialParams['serial_timeout']*1000;
            self.serialParams['serial_autoconnect'] = self.settings.settings.plugins.chambermanager.serial.autoconnect();
            self.serialParams['serial_connectionStatus'] = 'Connected';
 
 
            self.serialParams['serial_portOptions'] = self.connections.portOptions();
            var idx = self.serialParams['serial_portOptions'].indexOf(self.connections.selectedPort());
            self.serialParams['serial_portOptions'].splice(idx, 1);
            // self.serialParams['serial_baudrateOptions'] = self.connections.baudrateOptions();
 
            self.deviceParams.doorVentilMaxPos(self.settings.settings.plugins.chambermanager.device.doorVentilMaxPos());
            self.deviceParams.doorVentilMinPos(self.settings.settings.plugins.chambermanager.device.doorVentilMinPos());
            self.deviceParams.doorFilterMaxPos(self.settings.settings.plugins.chambermanager.device.doorFilterMaxPos());
            self.deviceParams.doorFilterMinPos(self.settings.settings.plugins.chambermanager.device.doorFilterMinPos());
 
            self.deviceParams.lightControlSensitive(self.settings.settings.plugins.chambermanager.device.lightControlSensitive());
        }
 
    }
 
    // This is how our plugin registers itself with the application, by adding some configuration
    // information to the global variable OCTOPRINT_VIEWMODELS
    OCTOPRINT_VIEWMODELS.push({
        construct: ChamberManagerViewModel,
        dependencies: ["settingsViewModel", "connectionViewModel"],
        elements: ["#settings_plugin_chambermanager", "#tab_plugin_chambermanager"]
    });
});