OctoPrint Plugin 만들기 #12 (설치하기)

OctoPrint Plugin 만들기 #12 (설치하기)

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

□ 동작 화면

□ 설치 방법

1. 개발 소스가 있는 폴더를  zip 파일로 압축한다.

2. 압축 완료

3. Octoprint의 설정 메뉴에서 Plugin Manager로 들어간다.

4. ... from an uploaded archive의 Browse 버튼을 클릭

5. 방금 전 압축한 파일을 선택한다.

6. Install Button을 클릭한다.

7. 설치 진행 중...

8. 완료되면 Restart Now 버튼을 클릭!

9. 설치가 완료된 모습

□ Source Code

[ __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 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):
 
    # Add thread support
    task_queue = Queue()
    task_send = None
    task_recv = None
 
    tempAmbient = []
    tempTarget = []
    tempLabel = []
    # tempCurrent = None
 
    sensorStatus = {
        'Current' : None,
        'Target' : None,
        'Angle' : None,
        'VentilSpeed' : None,
        'FilterSpeed' : None,
        'TimeStamp' : None
    }
 
    sensorHistory = {
        'Current' : [],
        'Target' : [],
        'Angle' : [],
        'VentilSpeed' : [],
        'FilterSpeed' : [],
        'TimeStamp' : []
    }
 
    device = serial.Serial()
    
    serialParams = {
        'port' : None,
        'baudrate' : None,
        'timeout' : None,
        'autoconnect' : False
    }
 
    deviceParams = {
        'tempControlMode' : None, #OK
        'tempControlTarget' : None,
        'doorVentilMaxPos' : None, #OK
        'doorVentilMinPos' : None, #OK
        'doorFilterMaxPos' : None, #OK
        'doorFilterMinPos' : None, #OK
        'doorControlVentilAngle' : None, #OK
        'doorControlFilterAngle' : None,
        'fanControlVentilSpeed' : None, #OK
        'fanControlFilterSpeed' : None, #OK
        'lightControlMode' : None, #OK
        'lightControlSensitive' : None,
        'lightControlInitailStatus' : None #OK
    }
 
 
    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 = {
        'customCommamd'                : '0',
        'writeEEPROM'                : '10',
        'deviceParams'                : '20',
        'doorVentilMaxPos'            : '111',
        'doorVentilMinPos'            : '112',
        'doorFilterMaxPos'            : '113',
        'doorFilterMinPos'            : '114',
        'tempControlMode'            : '200',
        'tempControlTarget'            : '201',
        'tempControlCurrent'        : '202',
        'currentStatus'                : '210',
        'fanEnable'                    : '300',
        'doorControlAngle'            : '311',
        'doorFanSpeed'                : '312',
        'ventilServoAngle'            : '321',
        'ventilFanSpeed'            : '322',
        'filterServoAngle'            : '331',
        'filterFanSpeed'            : '332',
        'lightControlMode'            : '400',
        'lightOnOff'                : '401',
        'lightControlSensitivity'    : '411',
        'lightControlSensCurrent'    : '421'
    }
 
    IDToControlObject = {
        '0'   : 'customCommand',
        '10'  : 'writeEEPROM',
        '20'  : 'deviceParams',
        '111' : 'doorVentilMaxPos',
        '112' : 'doorVentilMinPos',
        '113' : 'doorFilterMaxPos',
        '114' : 'doorFilterMinPos',
        '200' : 'tempControlMode',
        '201' : 'tempControlTarget',
        '202' : 'tempControlCurrent',
        '210' : 'currentStatus',
        '300' : 'fanEnable',
        '311' : 'doorControlAngle',
        '312' : 'doorFanSpeed',
        '321' : 'ventilServoAngle',
        '322' : 'ventilFanSpeed',
        '331' : 'filterServoAngle',
        '332' : 'filterFanSpeed',
        '400' : 'lightControlMode',
        '401' : 'lightOnOff',
        '411' : 'lightControlSensitivity',
        '421' : 'lightControlSensCurrent'
    }    
 
 
    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_send = Thread(target=self.task_serial_send)
            self.task_send.daemon = True
            self.task_send.start()
            self.task_recv = Thread(target=self.task_serial_recv)
            self.task_recv.daemon = True
            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 = False,
            ),
            device = dict(
                tempControlMode = 'MANUAL',
                tempControlTarget = 26,
                
                doorVentilMaxPos = 1875, # Max : 2250
                doorVentilMinPos = 1125,  # Min :  750
                doorFilterMaxPos = 1875, # Max : 2250
                doorFilterMinPos = 1125,  # Min :  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'])
 
            self._logger.debug('saveSettingtoParams')
            for key, value in self.deviceParams.items():
                self._logger.debug('{} : {}'.format(key, value))
 
        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'])
 
            self._logger.debug('saveParamsToSettings')
            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
            self.device.dsrdtr = False
            if self.device.is_open == True :
                self.device.close()
            self.device.open()
            self.device.flush()
            msg = 'CMD O0 R0\r'
            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')
            else:
                self.device.close()
                self._logger.info('Connection error')
        except SerialException as e:
            self.device.close()
            self._logger.error(e)
        except Exception as e:
            self.device.close()
            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)
            self._logger.debug(len(params))
            self._logger.debug(params)
            msg = 'CMD O{} R{} {}\r'.format(self.ControlObjectToID[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 convertBase64StringToDeviceParams(self, data):
        ret = False
        try:
            decoded = base64.b64decode(data)
            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
 
            ret = True
 
            self._logger.info('Successfully received parameters from device.')
 
        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)
            self.device.write(msg.encode('ascii','ignore'))
            r = self.device.read_until('\r')
            if r.startswith('OK')==True:
                tok = r.split(' ')
                ret = self.convertBase64StringToDeviceParams(tok[2])
            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 setWriteEEPROM(self, obj, data):
        ret = False
        try:
            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:
                ret = True
                self._logger.debug('setWriteEEPROM OK')
 
 
        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 is_float(self, value):
        try:
            float(value)
            return True
        except:
            return False
 
    def getCurrentStatus(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(' ')
                if self.is_float(tok[2]):
                    self.sensorStatus['Current'] = float(tok[2])
                if self.is_float(tok[3]):
                    self.sensorStatus['Target'] = float(tok[3])
                if self.is_float(tok[4]):
                    self.sensorStatus['Angle'] = int(tok[4])
                if self.is_float(tok[5]):
                    self.sensorStatus['VentilSpeed'] = int(tok[5])
                if self.is_float(tok[6]):
                    self.sensorStatus['FilterSpeed'] = int(tok[6])
                self.sensorStatus['TimeStamp'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                if len(self.sensorHistory['Current']) < 900 :
                    self.sensorHistory['Current'].append(self.sensorStatus['Current'])
                    self.sensorHistory['Target'].append(self.sensorStatus['Target'])
                    self.sensorHistory['Angle'].append(self.sensorStatus['Angle'])
                    self.sensorHistory['VentilSpeed'].append(self.sensorStatus['VentilSpeed'])
                    self.sensorHistory['FilterSpeed'].append(self.sensorStatus['FilterSpeed'])
                    self.sensorHistory['TimeStamp'].append(self.sensorStatus['TimeStamp'])
                else:
                    for i in range(0, 899) :
                        self.sensorHistory['Current'][i] = self.sensorHistory['Current'][i+1]
                        self.sensorHistory['Target'][i] = self.sensorHistory['Target'][i+1]
                        self.sensorHistory['Angle'][i] = self.sensorHistory['Angle'][i+1]
                        self.sensorHistory['VentilSpeed'][i] = self.sensorHistory['VentilSpeed'][i+1]
                        self.sensorHistory['FilterSpeed'][i] = self.sensorHistory['FilterSpeed'][i+1]
                        self.sensorHistory['TimeStamp'][i] = self.sensorHistory['TimeStamp'][i+1]
                    self.sensorHistory['Current'][899] = self.sensorStatus['Current']
                    self.sensorHistory['Target'][899] = self.sensorStatus['Target']
                    self.sensorHistory['Angle'][899] = self.sensorStatus['Angle']
                    self.sensorHistory['VentilSpeed'][899] = self.sensorStatus['VentilSpeed']
                    self.sensorHistory['FilterSpeed'][899] = self.sensorStatus['FilterSpeed']
                    self.sensorHistory['TimeStamp'][899] = self.sensorStatus['TimeStamp']
                ret = True
                self._plugin_manager.send_plugin_message(self._identifier, dict(sensorStatus=self.sensorStatus))
        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(' ')
                if self.is_float(tok[2]):
                    self.sensorStatus['Current'] = float(tok[2])
                self.sensorStatus['Target'] = self.deviceParams['tempControlTarget']
                self.sensorStatus['TimeStamp'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                if len(self.tempAmbient) < 900 :
                    self.sensorHistory['Current'].append(self.sensorStatus['Current'])
                    self.sensorHistory['Target'].append(self.sensorStatus['Target'])
                    self.sensorHistory['TimeStamp'].append(self.sensorStatus['TimeStamp'])
 
                else :
                    for i in range(0, 899) :
                        self.sensorHistory['Current'][i] = self.sensorHistory['Current'][i+1]
                        self.sensorHistory['Target'][i] = self.sensorHistory['Target'][i+1]
                        self.sensorHistory['TimeStamp'][i] = self.sensorHistory['TimeStamp'][i+1]
                    self.sensorHistory['Current'][899] = self.sensorStatus['Current']
                    self.sensorHistory['Target'][899] = self.sensorStatus['Target']
                    self.sensorHistory['TimeStamp'][899] = self.sensorStatus['TimeStamp']
 
                TempData = {
                    'Actual'    : self.sensorStatus['Current'],
                    'Target'    : self.sensorStatus['Target'],
                    'TimeStamp' : self.sensorStatus['TimeStamp']
                }
                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])
                if obj == 'tempControlMode':
                    tok[2] = self.TempControlModeOptionsCodeToString[tok[2]]
                elif obj == 'lightControlMode':
                    tok[2] = self.LightControlModeOptionsCodeToString[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(control_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(' ')
                if obj == 'tempControlMode' and data == '0':
                    ret = self.convertBase64StringToDeviceParams(tok[2])
                    self.saveParamsToSettings()
                    tok[2] = '0'
                else:
                    ret = True
                self.updateControlValues(obj, tok[2])
                if obj == 'tempControlMode':
                    tok[2] = self.TempControlModeOptionsCodeToString[tok[2]]
                elif obj == 'lightControlMode':
                    tok[2] = self.LightControlModeOptionsCodeToString[tok[2]]
                value = {
                    'object'   : obj,
                    'value'        : tok[2]
                }
                self._plugin_manager.send_plugin_message(self._identifier, dict(control_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 setCustomCommand(self, command):
        ret = False
        try:
            if self.device.is_open == True:
                msg = command + '\r'
                self.device.write(msg.encode('ascii','ignore'))
                r = self.device.read_until('\r')
                if r.startswith('OK') == True:
                    ret = True
        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 task_serial_send(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)
                        elif obj == 'currentStatus':
                            self.getCurrentStatus(obj, value)
                        else:
                            self.getDeviceValue(obj, value)
                    elif mode == 'WRITE' :
                        if obj == 'deviceParams':
                            self.setDeviceParams(obj, value)
                        elif obj == 'writeEEPROM':
                            self.setWriteEEPROM(obj, value)
                        else:
                            self.setDeviceValue(obj, value)
                    elif mode == 'CUSTOM' :
                        self.setCustomCommand(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 task_serial_recv(self):
        while True:
            try:
                id = '10'
                obj = self.IDToControlObject(id)
 
            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 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 :#currentStatus #tempControlCurrent
            self.task_queue.put(('currentStatus', 'READ', '0'))
 
 
    # ~~ Blueprintplugin mixin
    @octoprint.plugin.BlueprintPlugin.route('/getConnectionStatus', methods=['GET'])
    def blueprintPluginGetConnectionStatus(self):
        self._logger.debug('blueprintPluginGetConnectionStatus : {}'.format(self.device.is_open))
        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('/setCustomCommand', methods=['GET'])
    def blueprintPluginSetCustomCommand(self):
        try:
            command = flask.request.values['command'] 
            
            self._logger.debug('Custom Command: {}'.format(command))
            
            if self.device.is_open == True :
                self.task_queue.put(('0', 'CUSTOM', command))
                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.sensorStatus['Current'], self.sensorStatus['Target'], self.sensorStatus['TimeStamp']]
                self._logger.debug('Get current temp')
            elif get_cmd.upper() == 'HISTORY' :
                res = [get_cmd, self.sensorHistory['Current'], self.sensorHistory['Target'], self.sensorHistory['TimeStamp']]
                self._logger.debug('Get temp history')
            elif get_cmd.upper() == 'SENSORHISTORY' :
                res = [get_cmd, self.sensorHistory]
                self._logger.debug('Get sensor 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('Disconnected'),
            serial_autoconnect : ko.observable(false),
            serial_portOptions : ko.observableArray(['/dev/ttyS0', '/dev/ttyS1']),
            serial_baudrateOptions : ko.observableArray([115200]),
            serial_connectionOptions : ko.observableArray(['Connected', 'Disconnected']),
            serial_deviceManageOptions : ko.observableArray(['Download','Upload','Write EEPROM'])
        };
 
        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.lightControlSensCurrent = ko.observable(10);
        self.customCommand = ko.observable('');
 
 
 
        self.changeConnectionStatus = function(mode) {
            if(self.serialParams.serial_connectionStatus() != mode) {
                self.setSerialConnection(mode);
            }
        }
 
        self.setDeviceDownload = function() {
            new PNotify({
                title: "Chamber Manager",
                text: 'Start download',
                type: "info"
            });
            self.getControlValue('deviceParams');
        }
 
        self.setDeviceUpload = function() {
            new PNotify({
                title: "Chamber Manager",
                text: 'Start upload',
                type: "info"
            });
            self.setControlValue('deviceParams', 1);
        }
 
        self.setDeviceWriteEEPROM = function() {
            new PNotify({
                title: "Chamber Manager",
                text: 'Start write EEPROM',
                type: "info"
            });
            self.setControlValue('writeEEPROM', 1);
        }
 
 
        self.setDoorVentilMaxPos = function() {
            self.settings.saveData();
 
            self.setControlValue('doorVentilMaxPos', self.deviceParams.doorVentilMaxPos());
        }
 
        self.setDoorVentilMinPos = function() {
            self.settings.saveData();
 
            self.setControlValue('doorVentilMinPos', self.deviceParams.doorVentilMinPos());
        }
 
        self.setDoorFilterMaxPos = function() {
            self.settings.saveData();
 
            self.setControlValue('doorFilterMaxPos', self.deviceParams.doorFilterMaxPos());
        }
 
        self.setDoorFilterMinPos = function() {
            self.settings.saveData();
 
            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 {
                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 {
                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() {
            try {
                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());
            } catch (ex) {
                new PNotify({
                    title: "Chamber Manager",
                    text: ex.message,
                    type: "error"
                });
            }
        }
 
        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');
                        new PNotify({
                            title: "Chamber Manager",
                            text: 'Connected',
                            type: "info"
                        });
                    } else {
                        self.serialParams.serial_connectionStatus('Disconnected');
                        new PNotify({
                            title: "Chamber Manager",
                            text: 'Disconnected',
                            type: "info"
                        });
                    }
                },
                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) {
                    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) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: textStatus,
                        type: "error"
                    });
                }
            });
        }
 
 
        self.setCustomCommand = function(command) {
            var request = { command };
 
            $.ajax({
                url: self.buildPluginUrl("/setCustomCommand"),
                type: "GET",
                dataType: "json",
                data: request,
                success: function(data) {
                },
                error: function(textStatus) {
                    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: [],
            angles: [],
            ventilSpeeds: [],
            filterSpeeds: [],
            countMax: 900
        };
        self.historyTempLogScale = {
            actuals: new Array(200),
            targets: new Array(200),
            labels: new Array(200),
            angles: new Array(200),
            ventilSpeeds: new Array(200),
            filterSpeeds: new Array(200),
            countMax: 200
        };
 
 
        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,
                            yAxisID: 'y-axis-left',
                        }, {
                            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,                            
                            yAxisID: 'y-axis-left',
                        }, {
                            label: 'Angle',
                            fill: false,
                            backgroundColor: 'rgba(0,255,0,0.8)',
                            borderColor: 'rgba(0,255,0,0.8)',
                            data: [],
                            borderWidth: 1,
                            fill: false,
                            pointRadius: 0,
                            pointHoverRadius: 0,                            
                            yAxisID: 'y-axis-right',
                        }, {
                            label: 'VentilSpeed',
                            fill: false,
                            backgroundColor: 'rgba(0,0,255,0.8)',
                            borderColor: 'rgba(0,0,255,0.8)',
                            data: [],
                            borderWidth: 1,
                            fill: false,
                            pointRadius: 0,
                            pointHoverRadius: 0,                            
                            yAxisID: 'y-axis-right',
                        }, {
                            label: 'FilterSpeed',
                            fill: false,
                            backgroundColor: 'rgba(0,0,255,0.4)',
                            borderColor: 'rgba(0,0,255,0.4)',
                            data: [],
                            borderWidth: 1,
                            fill: false,
                            pointRadius: 0,
                            pointHoverRadius: 0,                            
                            yAxisID: 'y-axis-right',
                        }]
                    },
                    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,
                                position: 'left',
                                id: 'y-axis-left',
                                scaleLabel: {
                                    display: true,
                                    labelString: 'Temperature'
                                },
                                ticks: {
                                    suggestedMin: 10,
                                    suggestedMax: 50
                                }
        
                            }, {
                                display: true,
                                position: 'right',
                                id: 'y-axis-right',
                                gridLines: {
                                    drawOnChartArea: false,
                                },
                                scaleLabel: {
                                    display: true,
                                    labelString: 'Angle'
                                },
                                ticks: {
                                    suggestedMin: 0,
                                    suggestedMax: 90
                                }
        
                            }]
                        }
                    }
                };
 
                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();
                            }
                        } else if(ret[0].toUpperCase() == 'SENSORHISTORY') {
                            if(ret[1].Current.length>self.historyTemp.countMax) {
                                var pos = ret[1].Current.length - self.historyTemp.countMax;
                                self.historyTemp.actuals = ret[1].Current.slice(pos);
                                self.historyTemp.targets = ret[1].Target.slice(pos);
                                self.historyTemp.labels = ret[1].TimeStamp.slice(pos);
                                self.historyTemp.angles = ret[1].Angle.slice(pos);
                                self.historyTemp.ventilSpeeds = ret[1].VentilSpeed.slice(pos);
                                self.historyTemp.filterSpeeds = ret[1].FilterSpeed.slice(pos);
                            } else {
                                self.historyTemp.actuals = ret[1].Current;
                                self.historyTemp.targets = ret[1].Target;
                                self.historyTemp.labels = ret[1].TimeStamp;
                                self.historyTemp.angles = ret[1].Angle;
                                self.historyTemp.ventilSpeeds = ret[1].VentilSpeed;
                                self.historyTemp.filterSpeeds = ret[1].FilterSpeed;
                            }
                        }
                        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.processSensorStatus = function(data) {
            try {
                self.historyTemp.actuals.push(data.Current);
                self.historyTemp.targets.push(data.Target);
                self.historyTemp.labels.push(data.TimeStamp);
                self.historyTemp.angles.push(data.Angle);
                self.historyTemp.ventilSpeeds.push(data.VentilSpeed);
                self.historyTemp.filterSpeeds.push(data.FilterSpeed);
 
                self.deviceParams.tempControlActual(data.Current);
 
                if(self.deviceParams.tempControlMode() != 'Manual') {
                    self.deviceParams.tempControlTarget(data.Target);
                    self.deviceParams.doorControlAngle(data.Angle);
                    self.deviceParams.fanControlVentilSpeed(data.VentilSpeed);
                    self.deviceParams.fanControlFilterSpeed(data.FilterSpeed);
                }
    
                if(self.historyTemp.labels.length>self.historyTemp.countMax) {
                    self.historyTemp.actuals.shift();
                    self.historyTemp.targets.shift();
                    self.historyTemp.labels.shift();
                    self.historyTemp.angles.shift();
                    self.historyTemp.ventilSpeeds.shift();
                    self.historyTemp.filterSpeeds.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;
                    self.ChartConfig.data.datasets[2].data = self.historyTemp.angles;
                    self.ChartConfig.data.datasets[3].data = self.historyTemp.ventilSpeeds;
                    self.ChartConfig.data.datasets[4].data = self.historyTemp.filterSpeeds;
                    
    
                    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.historyTempLogScale.angles[i] = self.historyTemp.angles[index];
                        self.historyTempLogScale.ventilSpeeds[i] = self.historyTemp.ventilSpeeds[index];
                        self.historyTempLogScale.filterSpeeds[i] = self.historyTemp.filterSpeeds[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;
                    self.ChartConfig.data.datasets[2].data = self.historyTempLogScale.angles;
                    self.ChartConfig.data.datasets[3].data = self.historyTempLogScale.ventilSpeeds;
                    self.ChartConfig.data.datasets[4].data = self.historyTempLogScale.filterSpeeds;
 
                    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.bindFromSettings();
            self.getSerialConnectionStatus();
            self.historyTempChecked = true;
            // self.getCurrentTemp('HISTORY');
            self.getCurrentTemp('SENSORHISTORY');
        };
 
        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("sensorStatus")) {
                self.processSensorStatus(data.sensorStatus);
            }
            else if (data.hasOwnProperty("control_value")) {
                try{
                    var key = data.control_value.object;
                    var value = data.control_value.value;
 
                    if(key == 'tempControlMode') {
                        self.deviceParams.tempControlMode(value);
                    }
                    else if(key == 'lightControlSensCurrent') {
                        new PNotify({
                            title: JSON.stringify(key),
                            text: JSON.stringify(value),
                            type: "info"
                        });
                        self.lightControlSensCurrent(ko.observable(value));
                        self.deviceParams.lightControlSensCurrent(ko.observable(value));
                        // self.deviceParams['lightControlSensCurrent'] = ko.observable(value);
                    }
                    else {
                        // self.deviceParams[key] = ko.observable(value);
                        self.deviceParams[key](ko.observable(value));
                    }
                }
                catch (e) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: ex.message,
                        type: "error"
                    });
                }
            }
            else if (data.hasOwnProperty("deviceParams")) {
                try {
                    for(var key in data.deviceParams) {
                        var value = data.deviceParams[key];
                        if(key == 'tempControlMode') {
                            switch(value) {
                                case 1:
                                    value = 'Manual';
                                    break;
                                case 2:
                                    value = 'PID';
                                    break;
                                default:
                                    value = 'Manual';
                                    break;
                            }
                            self.deviceParams.tempControlMode(value);
                        }
                        else if(key == 'lightControlMode') {
                            switch(value) {
                                case 1:
                                    value = 'On';
                                    break;
                                case 2:
                                    value = 'Auto';
                                    break;
                                default:
                                    value = 'Off';
                                    break;
                            }
                            self.deviceParams.lightControlMode(value);
                        }
                        else if(key == 'doorControlVentilAngle') {
                            self.deviceParams.doorControlAngle(value);
                            self.deviceParams.doorControlVentilAngle(value);
                            switch(value) {
                                case 0:
                                    value = 'CLOSE';
                                    break;
                                case 90:
                                    value = 'OPEN';
                                    break;
                                default:
                                    value = 'UNKNOWN';
                            }
                            self.deviceParams.doorControlPosValue(value);
                        }
                        else {
                            // self.deviceParams[key] = ko.observable(value);
                            self.deviceParams[key](value);
                        }
                    }
                }
                catch (e) {
                    new PNotify({
                        title: "Chamber Manager",
                        text: ex.message,
                        type: "error"
                    });
                }
            }
 
        };
 
        self.checkKeyPress= function (data, event) {
            try {
                if (event.which == 13) {
                    self.customCommand(event.target.value);
                    self.setCustomCommand(event.target.value);
                    return false;
                }
                return true;
            }
            catch (e) {
 
            }
        }
 
 
        // 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() {
        }
 
    }
 
    // 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"]
    });
});

[ chambermanager_settings.jinja ]

<fieldset>
    <h4>{{ _('Serial Port') }}</h4>
    <table>
        <tr>
            <td width="200" valign="center">
                <label class="control-label" for="settings-cm_serialPort">{{ _('Serial Port') }}</label>
            </td>
            <td width="400">
                <select id="settings-cm_serialPort" data-bind="options: serialParams.serial_portOptions, value: serialParams.serial_port"></select>
            </td>
        </tr>
        <tr>
            <td valign="center">
                <label class="control-label" for="settings-cm_baudrate">{{ _('Baudrate') }}</label>
            </td>
            <td>
                <select id="settings-cm_baudrate" data-bind="options: serialParams.serial_baudrateOptions, value: serialParams.serial_baudrate"></select>
            </td>
        </tr>
        <tr>
            <td valign="center">
                <label class="control-label" for="settings-cm_timeout">{{ _('Timeout(ms)') }}</label>
            </td>
            <td>
                <input id="settings-cm_timeout" type="number" min="0" max="3000" class="input-mini input-nospin" style="width: 100px" data-bind="value: serialParams.serial_timeout_ms">
            </td>
        </tr>
        <tr>
            <td valign="center">
                <label class="control-label" for="settings-cm_connection">{{ _('Connection Status') }}</label>
            </td>
            <td>
                <div class="serial_connectionOptions">
                    <div class="btn-group" data-toggle="buttons-radio" id="serial_connectionStatus">
                        <!-- ko foreach: serialParams.serial_connectionOptions() -->
                        <button type="button" class="btn distance" style="width: 130px;padding: 3px 0;height: 30px" data-bind="text: $data, click: function() { $root.changeConnectionStatus($data) }, css: { active: $root.serialParams.serial_connectionStatus() === $data }, attr: { id: 'serial_connectionStatus_' + $data }"></button>
                        <!-- /ko -->
                    </div>
                </div>
            </td>
        </tr>
        <tr>
            <td></td>
            <td>
                <input type="checkbox" data-bind="checked: serialParams.serial_autoconnect" id="settings-serialAutoconnect"> {{ _('Auto-connect to printer on server start') }}
            </td>
        </tr>
        <tr>
            <td valign="center">
                <label class="control-label" for="settings-cm_devicemanagement">{{ _('Device Management') }}</label>
            </td>
            <td>
                <div class="serial_deviceManagement">
                    <a class="btn add-on" title="Download" data-bind="click: setDeviceDownload">Download</a>
                    <a class="btn add-on" title="Upload" data-bind="click: setDeviceUpload">Upload</a>
                    <a class="btn add-on" title="Write EEPROM" data-bind="click: setDeviceWriteEEPROM">Write EEPROM</a>
                </div>
            </td>
        </tr>
    </table>
</fieldset>
 
<br>
<fieldset>
    <h4>{{ _('Doors') }}</h4>
    <table>
        <tr>
            <th width="200"> </th>
            <th width="200" align="left">Max Position</th>
            <th width="200" align="left">Min Position</th>
        </tr>
    </table>
    <table>
        <tr>
            <td width="200"><label class="control-label">{{ _('Ventilator') }}</label></td>
            <td width="200" align="left" valign="center">
                <div class="input-prepend input-append">
                    <input id="settings-cm_doorVentilMaxPos" type="number" min="750" max="2250" class="input-mini input-nospin" style="width: 100px" data-bind="value: deviceParams.doorVentilMaxPos">
                    <button type="submit" class="btn btn-primary" data-bind="click: setDoorVentilMaxPos" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                </div>
            </td>
            <td width="200" align="left">
                <div class="input-prepend input-append">
                    <input id="settings-cm_doorVentilMinPos" type="number" min="750" max="2250" class="input-mini input-nospin" style="width: 100px" data-bind="value: deviceParams.doorVentilMinPos">
                    <button type="submit" class="btn btn-primary" data-bind="click: setDoorVentilMinPos" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                </div>
            </td>
        </tr>
        <tr>
            <td width="200"><label class="control-label" for="settings-cm_tempControlActual">{{ _('Filter') }}</label></td>
            <td width="200" align="left">
                <div class="input-prepend input-append">
                    <input id="settings-cm_doorFilterMaxPos" type="number" min="750" max="2250" class="input-mini input-nospin" style="width: 100px" data-bind="value: deviceParams.doorFilterMaxPos">
                    <button type="submit" class="btn btn-primary" data-bind="click: setDoorFilterMaxPos" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                </div>
            </td>
            <td width="200" align="left">
                <div class="input-prepend input-append">
                    <input id="settings-cm_doorFilterMinPos" type="number" min="750" max="2250" class="input-mini input-nospin" style="width: 100px" data-bind="value: deviceParams.doorFilterMinPos">
                    <button type="submit" class="btn btn-primary" data-bind="click: setDoorFilterMinPos" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                </div>
            </td>
        </tr>
    </table>
</fieldset>
 
<br>
<fieldset>
    <h4>{{ _('Lights') }}</h4>
    <table>
        <tr>
            <td width="200">
                <label class="control-label" for="settings-cm_sensitivity">{{ _('Sensitivity') }}</label>
            </td>
            <td width="200" align="left">
                <div class="input-prepend input-append">
                    <span class="add-on">Actual : </span>
                    <input id="lightControlSensCurrent" type="number" min="0" max="1024" class="input-mini input-nospin" style="width: 40px" data-bind="value: deviceParams.lightControlSensCurrent">
                    <button type="submit" class="btn btn-primary" data-bind="click: $root.getLightControlSensCurrent" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                </div>
            </td>
            <td width="200">
                <div class="input-prepend input-append">
                    <input id="settings-cm_sensitivity" type="number" min="0" max="1024" class="input-mini input-nospin" style="width: 100px" data-bind="value: deviceParams.lightControlSensitive">
                    <button type="submit" class="btn btn-primary" data-bind="click: $root.setLightControlSensitive" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                </div>
            </td>
        </tr>
    </table>
</fieldset>

[ chambermanager_tab.jinja ]

<canvas id="AmbientTempChart" width="600vw" height="300vw"></canvas>
 
<div class="control-group">
    <h4>{{ _('Temperature') }}</h4>
    <table>
        <tr>
            <td width="200" valign="center">
                <label class="control-label" for="tempControlMode">{{ _('Control Mode') }}</label>
            </td>
            <td width="400">
                <div class="tempControlOptions">
                    <div class="btn-group" data-toggle="buttons-radio" id="tempControlMode">
                        <!-- ko foreach: deviceParams.tempControlOptions() -->
                        <button type="button" class="btn distance" style="width: 130px;padding: 3px 0;height: 30px" data-bind="text: $data, click: function() { $root.changeControlMode($data) }, css: { active: $root.deviceParams.tempControlMode() === $data }, attr: { id: 'tempControlMode_' + $data }"></button>
                        <!-- /ko -->
                    </div>
                </div>
            </td>
        </tr>
        <tr>
            <td width="200"><label class="control-label" for="settings-tempControlTarget">{{ _('Ambient') }}</label></td>
            <td width="400">
                <table><tr>
                    <td width="120" class="temperature_actual" data-bind="html: 'Actual : ' + formatTemperature(deviceParams.tempControlActual()), attr: {title: formatTemperature(deviceParams.tempControlActual())}"></td>
                    </td>
                    <td class="temperature_target">
                        <div class="input-prepend input-append">
                            <button type="button" class="btn btn-input-dec" data-bind="attr : {'disabled' : $root.disableControl}, click: $root.tempControlDecrementTarget" title="{{ _('Fine adjust: -1°C') }}"><i class="fa fa-minus"></i></button>
                            <input type="number" min="0" max="999" class="input-mini input-nospin" style="width: 30px" data-bind="attr : {'disabled' : $root.disableControl}, value: deviceParams.tempControlTarget(), valueUpdate: 'input'">
                            <span class="add-on">&deg;C</span>
                            <button type="button" class="btn btn-input-inc" data-bind="attr : {'disabled' : $root.disableControl}, click: $root.tempControlIncrementTarget" title="{{ _('Fine adjust: +1°C') }}"><i class="fa fa-plus"></i></button>
                            <button type="submit" class="btn btn-primary" data-bind="attr : {'disabled' : $root.disableControl}, click: $root.setTempControlTarget" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                        </div>
                    </td>
                </tr></table>
            </td>
        </tr>
    </table>
 
 
    
    
</div>
 
<br>
<div class="control-group">
    <h4>{{ _('Doors') }}</h4>
    <table>
        <tr>
            <td width="200" valign="center"><label class="control-label" for="settings-doorControlAngle">{{ _('Angle') }}</label></td>
            <td width="400" align="center">
                <div id="control-door-angle" class="jog-panel">
                    <input type="number" style="width: 350px" data-bind="slider: {min: 0, max: 90, step: 1, value: deviceParams.doorControlAngle, tooltip: 'hide', disabled: $root.disableControl}">
                    <button class="btn btn-block" style="width: 390px" data-bind="attr : {'disabled' : $root.disableControl}, click: function() { $root.setDoorControlAngle() }"><span data-bind="text: deviceParams.doorControlAngle()"></span></button>
                </div>
            </td>
        </tr>
        <tr>
            <td><label class="control-label" for="settings-doorControlPosition">{{ _('Position') }}</label></td>
            <td align="center">
            
                <div class="doorControlPosOptions">
                    <div class="btn-group" data-toggle="buttons-radio" id="doorControlModePosition">
                        <!-- ko foreach: deviceParams.doorControlPosOptions() -->
                        <button type="button" class="btn distance" style="width: 130px;padding: 3px 0;height: 30px" data-bind="text: $data, click: function() { $root.setDoorControlPosition($data) }, css: { active: $root.deviceParams.doorControlPosValue() === $data }, attr: { id: 'doorControlModePosition_' + $data, 'disabled' : $root.disableControl}"></button>
                        <!-- /ko -->
                    </div>
                </div>
            
            </td>
        </tr>
    </table>
</div>
 
<br>
<div class="control-group">
    <h4>{{ _('Fans') }}</h4>
    <table>
        <tr>
            <th width="200"> </th>
            <th width="200"><h4>Ventilator</h4></th>
            <th width="200"><h4>Filter</h4></th>
        </tr>
    </table>
    <table>
        <tr>
            <td width="200" valign="center"><label class="control-label" for="settings-fansControlSpeed">{{ _('Speed') }}</label></td>
            <td width="200" align="center">
                <div id="control-fan-ventil-speed" class="jog-panel">
                    <input type="number" style="width: 153px" data-bind="slider: {min: 0, max: 100, step: 1, value: deviceParams.fanControlVentilSpeed, tooltip: 'hide'}">
                    <button class="btn btn-block" style="width: 169px" data-bind="attr : {'disabled' : $root.disableControl}, click: function() { $root.setVentilFanSpeed() }"><span data-bind="text: $root.deviceParams.fanControlVentilSpeed() + '%'"></span></button>
                </div>
            </td>
            <td width="200" align="center">
                <div id="control-fan-filter-speed" class="jog-panel">
                    <input type="number" style="width: 153px" data-bind="slider: {min: 0, max: 100, step: 1, value: deviceParams.fanControlFilterSpeed, tooltip: 'hide'}">
                    <button class="btn btn-block" style="width: 169px" data-bind="attr : {'disabled' : $root.disableControl}, click: function() { $root.setFilterFanSpeed() }"><span data-bind="text: $root.deviceParams.fanControlFilterSpeed() + '%'"></span></button>
                </div>
            </td>
        </tr>
    </table>
</div>
 
    
<br>
<div class="control-group">
    <h4>{{ _('Lights') }}</h4>
    <table>
        <tr>
            <td width="200">
                <label class="control-label" for="lightControlMode">{{ _('Control Mode') }}</label>
            </td>
            <td width="400">
                <div class="lightControlOptions">
                    <div class="btn-group" data-toggle="buttons-radio" id="lightControlMode">
                        <!-- ko foreach: deviceParams.lightControlOptions() -->
                        <button type="button" class="btn distance" style="width: 130px;padding: 3px 0;height: 30px" data-bind="text: $data, click: function() { $root.setLightControlMode($data) }, css: { active: $root.deviceParams.lightControlMode() === $data }, attr: { id: 'lightControlMode_' + $data }"></button>
                        <!-- /ko -->
                    </div>
                </div>
            </td>
        </tr>
    </table>
</div>
 
<br>
<div class="control-group">
    <h4>{{ _('User Command') }}</h4>
    <table>
        <tr>
            <td width="200">
                <label class="control-label">{{ _('User Command') }}</label>
            </td>
            <td width="400">
                <div class="input-prepend input-append">
                    <input type="text" style="width:325px" data-bind="attr:{id: 'customCommand'}, value: customCommand, event:{keypress: $root.checkKeyPress}">
                    <button type="submit" class="btn btn-primary" data-bind="attr : click: $root.setTempControlTarget" title="{{ _('Set') }}"><i class="fa fa-check"></i></button>
                </div>
            </td>
        </tr>
    </table>
</div>