Exemple #1
0
class MainWindow(QtGui.QMainWindow):
    def __init__(self, parent=None):
        QtGui.QMainWindow.__init__(self, parent)
        
        self.HyperionIP = '10.0.0.55'
        self.si255 = None
        self.__wavelength = None
        self.__scaledWavelength = None
        self.__scalePos = None
        self.isConnected = False
        self.channelList = [1,]
        self.peakList = []
        self.__numPeaksArray = [0,0,0,0]
        self.Monitor = None
        self.__freq = 1 #hyperion Spectrum Divider
        self.__maxTempBuffer = 5000
        self.__tempArray = np.zeros((2,self.__maxTempBuffer))
        self.tempGradientInterval = 60 # in sec
        self.__fbg = FBGData()
        self.logFile = []#None #log-file handle
        
        self.tempConnected = False
        
        self.measurementActive = False
        self.startMeasurementTime = time()
        
        self.plotSpec = pl.Plot(self.channelList)
        self.plotTrace = tl.TracePlot()
        self.plotTab = QtGui.QTabWidget()
        self.plotTab.addTab(self.plotSpec,'Spectra')
        self.plotTab.addTab(self.plotTrace, 'Trace')
        
        self.setWindowTitle(__title__ + ' ' + __version__)
        self.setCentralWidget(self.plotTab)
        
        self.createMenu()
        self.setActionState()
        
    def about(self):
        QtGui.QMessageBox.about(self,'About '+__title__,
            self.tr("""<font size=8 color=red>
                        <b><center>{0}</center></b></font>
                   <br><font size=5 color=blue>
                        <b>{1}</b></font>
                    <br><br>Author: {2}<br>
                    Version: {3}<br>
                    Date: {4}<br><br>""".format(__title__, __about__, __author__, __version__, __date__)+__cp__))
    
    def addActions(self, target, actions):
        for action in actions:
            if action is None:
                target.addSeparator()
            else:
                target.addAction(action)
                
    def calcTempGradient(self, numVal):
        dTime = self.__tempArray[0,numVal-1] - self.__tempArray[0,0]
        intv = self.tempGradientInterval
        if dTime >= intv:
            _min = self.__tempArray[0,numVal-1]-intv
            pos = np.where(self.__tempArray[0,:] >= _min)[0]
            slope = linregress(self.__tempArray[0,pos], self.__tempArray[1,pos])
            slope1 = linregress(self.__tempArray[0,pos], self.__tempArray[2,pos])
            #print (slope[0], '\n',slope1[0])
            _str = str("{0:.3f}".format(slope[0]*60))
            self.tempGrad.setText(_str)
            _str = str("{0:.3f}".format(slope1[0]*60))
            self.tempGrad1.setText(_str)
        #print(timestep)
        
        
    def closeEvent(self, event):
        reply = QtGui.QMessageBox.question(self, 'Message',
            "Are you sure to quit?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)

        if reply == QtGui.QMessageBox.Yes:
            try:
                if self.recordAction.isChecked():
                    self.recordAction.setChecked(False)
                if self.measurementActive:
                    self.stopMeasurement()
                if self.Monitor:
                    if self.Monitor.alive.isSet():
                        self.Monitor.join()
                        self.Monitor = None
                if self.si255.comm.connected:
                    self.si255.comm.close()
                
                if self.tempMon:
                    if self.tempMon.alive.isSet():
                        self.tempMon.join()
                        self.temMon = None
                if self.tempConnected:
                    self.tc08usb.close_unit()
            except:
                pass
            event.accept()
        else:
            event.ignore()
        
    def connectHyperion(self):
        try:
            si255Comm = hyperion.HCommTCPSocket(self.HyperionIP, timeout = 5000)
        except hyperion.HyperionError as e:
            print e , ' \thaha'   
        if si255Comm.connected:
            self.si255 = hyperion.Hyperion(comm = si255Comm)
            self.isConnected=True
            self.__wavelength =np.array(self.si255.wavelengths)
            #get wavelength range to reduce data
            _min = self.minWlSpin.value()
            _max = self.maxWlSpin.value()
            self.__scalePos = np.where((self.__wavelength>=_min) & (self.__wavelength<_max))[0]
            self.__scaledWavelength = self.__wavelength[self.__scalePos]
            
        else:
            self.isConnected=False
            QtGui.QMessageBox.critical(self,'Connection Error',
                                       'Could not connect to Spectrometer. Please try again')
            self.connectAction.setChecked(False)
        self.setActionState()
        
    def connectTemp(self):
        dll_path = os.path.join(os.getenv('ProgramFiles'),'Pico Technology', 'SDK', 'lib')
        try:
            self.tc08usb = TC08USB(dll_path = dll_path)
            if self.tc08usb.open_unit():
                self.initTempArray()
                self.tempQ = Queue.Queue(100)
                self.tempConnected = True
                self.tempMon = MonitorTC08USBThread(self.tc08usb, self.tempQ)
                self.tempMon.start()
                self.updateTempTimer = QtCore.QTimer()
                self.updateTempTimer.timeout.connect(self.getTemp)
                self.updateTempTimer.start(100)
            else:
                self.tempConnected = False
                self.connectThermoAction.setChecked(False)
                QtGui.QMessageBox.critical(self,'Connection Error',
                                       'Could not connect to TC08-USB. Please try again')
                
        except USBTC08_ERROR as e:
            print(e)
            
    def disconnectTemp(self):
        if self.updateTempTimer.isActive():
            self.updateTempTimer.stop()
        if self.tempMon:
            if self.tempMon.alive.isSet():
                self.tempMon.join()
        self.tempMon = None
        self.tc08usb.close_unit()
        self.tc08usb = None
        self.tempConnected = False
        self.__tempArray = None
        self.tempDisplay.setText(' --.-')
        self.tempDisplay1.setText(' --.-')
            
    def createAction(self, text, slot=None, shortcut=None,
                     icon=None,tip=None,checkable=False,
                     signal='triggered()'):
        action = QtGui.QAction(text, self)
        if icon is not None:
            action.setIcon(QtGui.QIcon('../icons/%s.png' % icon))
        if shortcut is not None:
            action.setShortcut(shortcut)
        if tip is not None:
            action.setToolTip(tip)
            action.setStatusTip(tip)
        if slot is not None and not checkable:
            action.triggered.connect(slot)
        elif slot is not None and checkable:
            action.toggled.connect(slot)
        if checkable:
            action.setCheckable(True)
       
        return action
        
    
        
        
    def createMenu(self):
        self.quitAction = self.createAction('Q&uit',slot=self.close,shortcut='Ctrl+Q',
                                            icon='Button Close',tip='Programm schließen')

        self.connectAction = self.createAction('Verbinden', slot=self.connectHyperion,
                                              tip='Spektrometer verbinden', checkable = True,
                                              icon='Button Add')   
        
        self.connectThermoAction = self.createAction('Thermometer', slot=self.toggleThermo, tip='Thermometer verbinden', icon='Thermo', checkable = True)
        
        self.startAction = self.createAction('St&art', slot=self.startMeasurement, shortcut='Ctrl+M',
                                             tip='Messung starten', icon='Button Play')
        
        self.recordAction = self.createAction('Aufnahme', tip='Aufnahme starten',slot=self.startStopRecord, checkable = True, icon='Button Record Red')
        
        self.stopAction = self.createAction('St&op', slot=self.stopMeasurement, shortcut='Ctrl+T',
                                        tip='Messung beenden', icon='Button Stop')
        
        self.channelSelection = ChannelSelection()
        self.channelSelection.setNumPeaks(self.__numPeaksArray)
        self.channelSelection.selectionChanged.connect(self.setChannels)
        self.selectChannelAction = QtGui.QWidgetAction(self)
        self.selectChannelAction.setDefaultWidget(self.channelSelection)
        self.setFreqAction = FreqSpinAction()
        self.toggledBmAction = self.createToggledBm()
        self.scaleAction = self.createScalePlotAction()
        self.tempAction = self.createTempDisplay()
        
        self.toolbar = self.addToolBar('Measurement')
        self.addActions(self.toolbar, (self.connectAction, self.connectThermoAction, None, self.startAction, self.recordAction, self.stopAction,
                                      None,self.selectChannelAction,None,self.tempAction,None, self.setFreqAction,self.toggledBmAction,
                                      self.scaleAction))
    
    def createScalePlotAction(self):
        wa = QtGui.QWidgetAction(self)
        
        self.minWlSpin = QtGui.QDoubleSpinBox()
        self.minWlSpin.setDecimals(3)
        self.minWlSpin.setSuffix(' nm')
        self.minWlSpin.setRange(1460.0,1619.0)
        self.minWlSpin.setValue(1500.0)
        self.minWlSpin.valueChanged.connect(self.scaleInputSpectrum)
        
        self.maxWlSpin = QtGui.QDoubleSpinBox()
        self.maxWlSpin.setDecimals(3)
        self.maxWlSpin.setSuffix(' nm')
        self.maxWlSpin.setRange(1461.0, 1620.0)
        self.maxWlSpin.setValue(1620.0)
        self.maxWlSpin.valueChanged.connect(self.scaleInputSpectrum)
        l = QtGui.QHBoxLayout()
        l.addWidget(self.minWlSpin)
        l.addWidget(QtGui.QLabel(text=' - '))
        l.addWidget(self.maxWlSpin)
        
        w = QtGui.QWidget()
        w.setLayout(l)
        wa.setDefaultWidget(w)
        
        return wa
        
    def createTempDisplay(self):
        a = QtGui.QWidgetAction(self)
        t = QtGui.QWidget()
        l = QtGui.QGridLayout(t)
        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(16)
        self.tempDisplay = QtGui.QLabel(text=' --.--')
        self.tempDisplay.setFont(font)
        self.tempDisplay1 = QtGui.QLabel(text=' --.--')
        self.tempDisplay1.setFont(font)
        self.tempGrad = QtGui.QLabel(text='--.--')
        self.tempGrad.setAlignment(QtCore.Qt.AlignRight)
        self.tempGrad1 = QtGui.QLabel(text='--.--')
        self.tempGrad1.setAlignment(QtCore.Qt.AlignRight)
        l.addWidget(self.tempDisplay,0,0)
        l.addWidget(QtGui.QLabel(text=u'\u00b0C', font=font),0,1)
        l.addWidget(self.tempDisplay1,0,2)
        l.addWidget(QtGui.QLabel(text=u'\u00b0C', font=font),0,3)
        l.addWidget(self.tempGrad,1,0)
        l.addWidget(QtGui.QLabel(text=u'\u00b0C/min'),1,1)
        l.addWidget(self.tempGrad1,1,2)
        l.addWidget(QtGui.QLabel(text=u'\u00b0C/min'),1,3)
        a.setDefaultWidget(t)
        return a
    
    def createToggledBm(self):
        a = QtGui.QWidgetAction(self)
        self.dBmCheck = QtGui.QCheckBox(text='dBm')
        self.dBmCheck.stateChanged.connect(self.showdBm)
        self.dBmCheck.setChecked(True)
        a.setDefaultWidget(self.dBmCheck)
        return a
        
    def getAllFromQueue(self, Q):
        """ Generator to yield one after the others all items 
            currently in the queue Q, without any waiting.
        """
        try:
            while True:
                yield Q.get_nowait( )
        except Queue.Empty:
            raise StopIteration


    def getItemFromQueue(self, Q, timeout=0.01):
        """ Attempts to retrieve an item from the queue Q. If Q is
            empty, None is returned.
            
            Blocks for 'timeout' seconds in case the queue is empty,
            so don't use this method for speedy retrieval of multiple
            items (use get_all_from_queue for that).
        """
        try: 
            item = Q.get(True, timeout)
        except Queue.Empty: 
            return None
        
        return item
        
    def getTemp(self, timeout=0.01):
        try: 
            temp = self.tempQ.get(True, timeout)
        except Queue.Empty:
            return None
        tempStr = str("{0:.2f}".format(float(temp[0])))
        self.tempDisplay.setText(tempStr)
        tempStr = str("{0:.2f}".format(float(temp[1])))
        self.tempDisplay1.setText(tempStr)
        
    def initTempArray(self):
        self.__tempArray = None
        self.__tempArray = np.zeros((3,self.__maxTempBuffer))
        
    
    def readDataFromQ(self):
        qData = list(list(self.getAllFromQueue(self.dataQ)))
        timestamp = 0
        d = None
        if len(qData) > 0:
            d = np.array(qData[-1][0])
            timestamp = qData[-1][1]
            d = d[:,self.__scalePos]
            return d, timestamp , 1
        else:
            return 0,0,0       
            
    def saveLastData(self, numPeaks):
        if self.logFile:
            #print('save Data')
            temp = self.tempDisplay.text()
            temp = temp.split(' ')
            temp1 = self.tempDisplay1.text()
            temp1 = temp1.split(' ')
            for i, chan in enumerate(self.channelList):
                _str = ''
            
                _time, peaks, _max, cmax, cog, fwhm, amp = self.__fbg.channels[chan-1].getLastValues(numPeaks[i])
                _str += str(_time) + '\t' 
                if temp[0]: _str += str(temp[0]) + '\t'
                if temp1[0]: _str += str(temp1[0]) + '\t'
                for j in range(len(peaks)):
                    _str += str("{0:.3f}".format(peaks[j])) + '\t'
                   # _str += str("{0:.3f}".format(cmax[j])) + '\t'
                    #if cog:
                        #_str += str("{0:.3f}".format(cog[j])) + '\t'
                    _str += str("{0:.3f}".format(_max[j])) + '\t'
                    if fwhm:
                        _str += str("{0:.3f}".format(fwhm[j])) + '\t'
                    #if amp:
                       # _str += str(amp[j]) + '\t'
                _str += '\n'
                print(_str)
                self.logFile[i].write(_str)
            
    def saveLastSpectrum(self):
       
            
                    pass
        
            
    def scaleInputSpectrum(self):
        _min = float(self.minWlSpin.value())
        _max = float(self.maxWlSpin.value())
        if _min > _max:
            _min = _max-1
        if _max < _min:
            _max = _min+1
        self.__scalePos = np.where((self.__wavelength>=_min)&(self.__wavelength<=_max))[0]
        self.__scaledWavelength = self.__wavelength[self.__scalePos]
    
    def setActionState(self):
        if self.isConnected:
            if self.measurementActive:
                self.startAction.setEnabled(False)
                self.recordAction.setEnabled(True)
                self.stopAction.setEnabled(True)
            else:
                self.startAction.setEnabled(True)
                self.recordAction.setEnabled(False)
                self.stopAction.setEnabled(False)
        else:
            self.startAction.setEnabled(False)
            self.recordAction.setEnabled(False)
            self.stopAction.setEnabled(False)
            
    def setChannels(self):
        self.channelList = self.channelSelection.getChannelList()
        if self.Monitor:
            self.Monitor.setChannelList(self.channelList)
        self.plotSpec.setChannelList(self.channelList)
        self.plotTrace.setChannelList(self.channelList)
        
    def showdBm(self, state):
        if state:
            self.plotSpec.setdBm(True)
        else:
            self.plotSpec.setdBm(False)
            
    def startMeasurement(self):
        self.__fbg = FBGData()
        self.plotTrace.initTraces([0,],0)
        self.__freq = self.setFreqAction.value()
        self.updateTimer = QtCore.QTimer()
        self.updateTimer.timeout.connect(self.updateData)
        
        #initialize Queue
        self.dataQ = Queue.Queue(100)
        self.initTempArray()
        self.plotTrace.clearPlot()
        self.Monitor = MonitorHyperionThread(self.dataQ, self.si255, 
                                         self.channelList, specDevider=self.__freq)
        self.Monitor.start()
        self.updateTimer.setInterval(25*self.__freq)
            
        self.startMeasurementTime = time()
        self.initTempArray()
        self.lastTime = time()
        self.fps = None
            
        self.measurementActive = True
        self.setActionState()
        
        #start updateMonitor Timer
        self.updateTimer.start()
        
                
    def stopMeasurement(self):
        self.Monitor.join(0.1)
        self.Monitor = None
        self.si255.disable_spectrum_streaming()
        self.recordAction.setChecked(False)
        self.measurementActive = False
        self.updateTimer.stop()
        self.setActionState()
        
    def startStopRecord(self):
        if self.recordAction.isChecked():
            self.initTempArray()
            self.scaleAction.setEnabled(False)
            self.selectChannelAction.setEnabled(False)
            self.__fbg = FBGData()
            self.startMeasurementTime = time()
            timeStr = strftime('%Y%m%d_%H%M%S') 
            self.logFile = []
            
            for i, chan in enumerate(self.channelList):
                fileStr = timeStr + '_Ch' + str(chan) + '.log'
                logFileName = os.path.join(os.getenv('AppData'),'Python', 'MultiSpec', 'LOG', fileStr)
            
                self.logFile.append(open(logFileName,'w'))
            print('Log Files: ', len(self.logFile))
            
        else:
            self.scaleAction.setEnabled(True)
            self.selectChannelAction.setEnabled(True)
            for i in self.logFile:
                i.close()
            
                
        
    def toggleThermo(self):
        if self.connectThermoAction.isChecked():
            self.connectTemp()
        else:
            self.disconnectTemp()
    
    def updateData(self):
        numPeaks = 0
        #data = np.zeros((1,1))
        data, timestamp, success  = self.readDataFromQ()
        if not success: return None
        
        actualTime = timestamp-self.startMeasurementTime
        if self.tempConnected:
            temp = float(self.tempDisplay.text())
            temp1 = float(self.tempDisplay1.text())
            numTempVal = np.count_nonzero(self.__tempArray[0])
            if numTempVal < self.__maxTempBuffer:
                self.__tempArray[1][numTempVal] = temp
                self.__tempArray[2][numTempVal] = temp1
                self.__tempArray[0][numTempVal] = actualTime#-self.startMeasurementTime
            else:
                self.__tempArray[1] = shift(self.__tempArray[1], -1, cval = temp)
                self.__tempArray[2] = shift(self.__tempArray[2], -1, cval = temp1)
                self.__tempArray[0] = shift(self.__tempArray[0], -1, cval = actualTime)#-self.startMeasurementTime)
            
            self.calcTempGradient(numTempVal)

        if len(data[:,0]) == len(self.channelList):
            if self.setFreqAction.value() < 5:
                numPeaks = self.__fbg.searchPeaks(self.__scaledWavelength, data,self.channelList, 
                                       self.channelSelection, actualTime)
            else:
                numPeaks = self.__fbg.searchPeaks(self.__scaledWavelength, data,self.channelList, 
                                       self.channelSelection, actualTime, peakfit=1)
        if self.plotTab.currentIndex() == 0:
            self.plotSpec.plotS(self.__scaledWavelength, data)
        else:
            self.plotTrace.plotTraces(self.channelList, numPeaks, self.__fbg)
            if self.tempConnected:
                self.plotTrace.plotTemp(self.__tempArray[:,:numTempVal])
                
        if self.recordAction.isChecked() and self.__freq >= 10:
            self.saveLastData(numPeaks)
            

        dt = timestamp-self.lastTime
        if timestamp:
            if self.fps is None:
                self.fps = 1.0/dt
            else:
                s = np.clip(dt*3., 0, 1)
                self.fps = self.fps * (1-s) + (1.0/dt) * s
            self.statusBar().showMessage('%0.2f Hz' % (self.fps))
            self.lastTime = timestamp
Exemple #2
0
class MainWindow(QtGui.QMainWindow):
    def __init__(self, parent=None):
        QtGui.QMainWindow.__init__(self, parent)
        
        self.isConnected = False
        self.tempConnected = False
        self.measurementActive = False
        self.si255 = None
        self.tc08usb = None
        self.HyperionIP = '10.0.0.55'
        self.__numChannel = 1
        self.__wavelength = None
        self.__wavelength = np.zeros(20000)
        self.__scaledWavelength = None
        self.__scalePos = None
        self.plotW = pl.Plot()
        
        self.loadSettings()
        
        
        
        self.testModus = 0
        
        
        self.updateTimer = QtCore.QTimer()
        self.updateTimer.timeout.connect(self.getData)
        self.updateTempTimer = QtCore.QTimer()
        self.updateTempTimer.timeout.connect(self.getTemp)
        self.startTime = None
        self.heatingTimer = QtCore.QTimer()
        
        self.setWindowTitle(__title__ + ' ' + __version__)
        self.resize(900, 600)
        
        
        self.prodInfo = productionInfo.ProductionInfo()
        self.waitHeating = False
        self.__activateCooling = False
        self.__finalTemp = 90
        self.cogSpectralWin = 2.5
        self.__SpecWinRL = 2
        
        mainVSplit = QtGui.QSplitter()
        mainVSplit.setOrientation(QtCore.Qt.Vertical)
        mainVSplit.addWidget(self.plotW)
        mainVSplit.addWidget(self.prodInfo)
        
        mainHSplit = QtGui.QSplitter()
        mainHSplit.setOrientation(QtCore.Qt.Horizontal)
        mainHSplit.addWidget(mainVSplit)
        mainHSplit.addWidget(self.createInfoWidget())
        
        self.setCentralWidget(mainHSplit)
        
        self.createMenu()
                
        self.plotW.returnSlope.connect(self.setSlope)
        
        self.slopeCh1Dial.setSlope(0)
        self.setActionState()
        
        self.prodInfo.emitSoll.connect(self.setSollLabel)
        self.prodInfo.emitProdIds.connect(self.setProdIDs)
        self.prodInfo.emitClearIDs.connect(self.clearIDs)
        self.prodInfo.buttons.startButton.clicked.connect(self.prodSequenzClicked)
        self.prodInfo.buttons.backButton.clicked.connect(self.prodSequenzBack)
        
        self.loadSettings()


    
    def initDevice(self):
        if self.isConnected:
            try:
                if self.si255.comm.connected:
                    self.si255.comm.close()
                    self.isConnected = False
                    self.setActionState()
            except:
                pass
        else:
            try:
                si255Comm = hyperion.HCommTCPSocket(self.HyperionIP, timeout = 5000)
            except hyperion.HyperionError as e:
                print e , ' \thaha'   
            if si255Comm.connected:
                self.si255 = hyperion.Hyperion(comm = si255Comm)
                self.isConnected=True
                self.__wavelength =np.array(self.si255.wavelengths)
                self.__scalePos = np.where((self.__wavelength>=self.__minWl) & (self.__wavelength<self.__maxWl))[0]
                self.__scaledWavelength = self.__wavelength[self.__scalePos]
                self.setActionState()   
                return 1
            else:
                self.isConnected=False
                self.printError(5)
                self.setActionState()   
                return 0
         
    def about(self):
        QtGui.QMessageBox.about(self,'About '+__title__,
            self.tr("""<font size=8 color=red>
                        <b><center>{0}</center></b></font>
                   <br><font size=5 color=blue>
                        <b>{1}</b></font>
                    <br><br>Author: {2}<br>
                    Version: {3}<br>
                    Date: {4}<br><br>""".format(__title__, __about__, __author__, __version__, __date__)+__cp__))
                    
    def addActions(self, target, actions):
        for action in actions:
            if action is None:
                target.addSeparator()
            else:
                target.addAction(action)
    
    def calculateLabelColor(self):
        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(24)
        if self.chan1SollLabel.isVisible():
            tol = self.prodInfo.getTolaranz()
            diff = float(self.chan1IsLabel.text())-float(self.chan1SollLabel.text())
            #print(diff, self.sollGreen[self.prodStep], self.sollGreen[self.prodStep]*3)
            if self.prodInfo.getProdPlanNum() == 2:
                if diff < tol:
                    self.chan1IsLabel.setStyleSheet("color: green")
                elif diff < tol*2:
                    self.chan1IsLabel.setStyleSheet("color: orange")
                else:
                    self.chan1IsLabel.setStyleSheet("color: red")
            else:
                if abs(diff) <= tol:
                    self.chan1IsLabel.setStyleSheet("color: green")
                elif abs(diff) <= tol*3:
                    self.chan1IsLabel.setStyleSheet("color: orange")
                else:
                    self.chan1IsLabel.setStyleSheet("color: red")
        else:
            self.chan1IsLabel.setStyleSheet("color: black")
            
    def clearIDs(self):
        self.proID.clear()
        self.fbgID.clear()
        self.sensorID.clear()
            
    def closeEvent(self, event):
        reply = QtGui.QMessageBox.question(self, 'Message',
            "Are you sure to quit?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)

        if reply == QtGui.QMessageBox.Yes:
            try:
                if self.si255.comm.connected:
                    self.si255.comm.close()
                if self.tempConnected:
                    self.tc08usb.close_unit()
            except:
                pass
            event.accept()
        else:
            event.ignore()
             
    def connectTemp(self):
        dll_path = os.path.join(os.getenv('ProgramFiles'),'Pico Technology', 'SDK', 'lib')
        try:
            self.tc08usb = TC08USB(dll_path = dll_path)
            if self.tc08usb.open_unit():
                self.tempQ = Queue.Queue(100)
                self.tempConnected = True
                self.tempMon = MonitorTC08USBThread(self.tc08usb, self.tempQ)
                self.tempMon.start()
                self.tempConnected = True
                self.updateTempTimer.start(250)
                return 1
            else:
                self.tempConnected = False
                #self.connectTempAction.setChecked(False)
                QtGui.QMessageBox.critical(self,'Verbindungsfehler',
                                       'Konnte keine Verbindung zu TC08-USB herstellen. Bitte nochmal versuchen!')
                return 0
                
        except USBTC08_ERROR as e:
            print(e)
            
        self.setActionState()
        
        
    def createAction(self, text, slot=None, shortcut=None,
                     icon=None,tip=None,checkable=False,
                     signal='triggered()'):
        action = QtGui.QAction(text, self)
        if icon is not None:
            action.setIcon(QtGui.QIcon('../icons/%s.png' % icon))
        if shortcut is not None:
            action.setShortcut(shortcut)
        if tip is not None:
            action.setToolTip(tip)
            action.setStatusTip(tip)
        if slot is not None and not checkable:
            action.triggered.connect(slot)
        elif slot is not None and checkable:
            action.toggled.connect(slot)
        if checkable:
            action.setCheckable(True)
       
        return action
       
    def createIdFrame(self):
        f = QtGui.QGroupBox(self, title='IDs:')
        l = QtGui.QGridLayout(f)
        font = QtGui.QFont()
        font.setBold(False)
        font.setPointSize(16)
        prodIdLabel = QtGui.QLabel(text='Produktion:', font=font) 
        self.proID = QtGui.QLineEdit(font=font)
        self.proID.setAlignment(QtCore.Qt.AlignRight)
        fbgIdLabel = QtGui.QLabel(text='Faser:', font=font) 
        self.fbgID = QtGui.QLineEdit(font=font)
        self.fbgID.setAlignment(QtCore.Qt.AlignRight)
        sensorIdLabel = QtGui.QLabel(text='Sensor:', font=font)
        self.sensorID = QtGui.QLineEdit(font=font)
        self.sensorID.setAlignment(QtCore.Qt.AlignRight)
        
        l.addWidget(prodIdLabel,0,0)
        l.addWidget(self.proID,0,1)
        l.addWidget(fbgIdLabel,1,0)
        l.addWidget(self.fbgID,1,1)
        l.addWidget(sensorIdLabel,2,0)
        l.addWidget(self.sensorID,2,1)
        
        return f
        
    def createInfoWidget(self):
        i = QtGui.QFrame()
        #i.setMaximumWidth(400)
        il = QtGui.QVBoxLayout()
        
        logo = QtGui.QLabel()
        logo.setPixmap(QtGui.QPixmap('../pics/Logo loptek.jpg'))
        logoLay = QtGui.QHBoxLayout()
        logoLay.addStretch()
        logoLay.addWidget(logo)
        
        il.addLayout(logoLay)
        il.addWidget(self.createIdFrame())
        
        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(20)
        isLabel = QtGui.QLabel(text='Ist')
        isLabel.setAlignment(QtCore.Qt.AlignCenter)
        isLabel.setFont(font)
        self.sollLabel= QtGui.QLabel(text='Soll')
        self.sollLabel.setAlignment(QtCore.Qt.AlignCenter)
        self.sollLabel.setFont(font)
        self.sollLabel.setVisible(False)
        self.chan1IsLabel = QtGui.QLabel()
        self.chan1IsLabel.setText('0.0')
        self.chan1IsLabel.setFont(font)
        self.chan1SollLabel = QtGui.QLabel()
        #self.chan1SollLabel.setText('----.---')
        self.chan1SollLabel.setFont(font)
        self.chan1SollLabel.setAlignment(QtCore.Qt.AlignRight)
        self.chan1SollLabel.setVisible(False)
        font.setBold(True)
        font.setPointSize(12)
        #slopeLabel = QtGui.QLabel(text='Slope [pm/s]:')
        #slopeLabel.setFont(font)
        self.slopeCh1Dial = SlopeMeter()
        self.tempDisplay = QtGui.QLabel(text=u'-.- \u00b0C')
        font.setBold(True)
        font.setPointSize(16)
        self.tempDisplay.setAlignment(QtCore.Qt.AlignRight)
        self.tempDisplay.setFont(font)
        
        font.setBold(True)
        font.setPointSize(44)
        self.__timeStr = '00:00'        
        self.__timerLabel = QtGui.QLabel(self,text=self.__timeStr)
        self.__timerLabel.setFont(font)
        self.__timerLabel.setFrameShape(QtGui.QFrame.StyledPanel)
        self.__timerLabel.setFrameShadow(QtGui.QFrame.Raised)
        
        style = "font-size: 16px; font-weight: bold"
        self.openSensorButton = QtGui.QPushButton(text='SensorID laden')
        self.openSensorButton.setStyleSheet(style)
        self.openSensorButton.clicked.connect(self.openSensor)     
        self.openSensorButton.setEnabled(False)
        self.openSensorButton.setVisible(False)
        
        valLayout = QtGui.QGridLayout()
        valLayout.addWidget(isLabel,0,0)
        valLayout.addWidget(self.sollLabel,0,1)
        valLayout.addWidget(self.chan1IsLabel,1,0)
        valLayout.addWidget(self.chan1SollLabel,1,1)
        valLayout.addWidget(self.slopeCh1Dial,3,0)
        valLayout.addWidget(self.tempDisplay,2,1)
        #valLayout.addWidget(self.__timerLabel,4,0)
        #valLayout.addWidget(self.openSensorButton,4,0)
        
        
        self.slopeCh1Dial.setValue(0.)
        bottomL = QtGui.QHBoxLayout()
        bottomL.addStretch()
        bottomL.addWidget(self.__timerLabel)
        bottomL.addWidget(self.openSensorButton)
        bottomL.addStretch()
        
        il.addLayout(valLayout)
        il.addStretch()
        il.addLayout(bottomL)
        i.setLayout(il)
        
        return i
        
        
    def createMenu(self):
        
        self.fileMenu = self.menuBar().addMenu('&Datei')
        self.maesMenu = self.menuBar().addMenu('&Messung')
        self.helpMenu = self.menuBar().addMenu('&Hilfe')
        waL = QtGui.QWidgetAction(self)
        dispSpinLabel = QtGui.QLabel(text='Points displayed: ')
        waL.setDefaultWidget(dispSpinLabel)
        
        #self.menuBar().addAction(wa)
        self.quitAction = self.createAction('Q&uit',slot=self.close,shortcut='Ctrl+Q',
                                            icon='Button Close',tip='Close App')
        self.connectAction = self.createAction('Verbinden', slot=self.initDevice,
                                              tip='Verbinde Spectrometer')        
        self.connectTempAction = self.createAction('Thermo', slot=self.tempActionToggled, tip='Verbinde Thermometer',
                                                   icon='Thermo')
        
        self.startAction = self.createAction('St&art', slot=self.startMeasurement, shortcut='Ctrl+M',
                                             tip='Start Messung', icon='Button Play')
#         #self.pauseAction = self.createAction('Pa&use', #slot=self.pauseMeasurement, shortcut='Ctrl+U', 
#          #                                    tip='Pause Measurement', icon='Button Pause')
#         
        self.stopAction = self.createAction('St&op', slot=self.stopMeasurement, shortcut='Ctrl+T',
                                        tip='Stop Messung', icon='Button Stop')
        
        self.buildAction = self.createAction('Aufbau', checkable=True)
        self.siliconAction = self.createAction('Silikon', checkable=True)
        self.terminationAction = self.createAction('Faserterminierung', checkable=True)
        
        self.buildAction.setChecked(True)
        self.buildAction.toggled.connect(self.setBuildAction)
        self.siliconAction.toggled.connect(self.setSiliconAction)
        self.terminationAction.toggled.connect(self.setTerminationAction)
        
        
        self.fileMenu.addAction(self.quitAction)

        aboutAction = self.createAction('About', slot=self.about)
        
        optionAction = self.createAction('O&ptionen', tip='Optionsdialog', slot=self.openOptionsDialog)
                                     
        self.helpMenu.addAction(aboutAction)
        self.helpMenu.addAction(optionAction)
        
        self.toolbar = self.addToolBar('Measurement')
        
        self.addActions(self.toolbar, (self.connectAction, self.connectTempAction, None, self.startAction, self.stopAction, None,
                                       self.buildAction, self.siliconAction, self.terminationAction))#, self.importFileAction, self.importLogAction, self.exportData, None,self.showOptAction,None,self.fitAction, self.showFitAction))
    
    def setBuildAction(self):
        if self.buildAction.isChecked():
            self.siliconAction.setChecked(False)
            self.terminationAction.setChecked(False)
            self.clearIDs()
            
            self.prodInfo.changeProdPlan(0)
                        
            
    def setSiliconAction(self):
        if self.siliconAction.isChecked():
            self.buildAction.setChecked(False)
            self.terminationAction.setChecked(False)
            self.clearIDs()
            
            self.prodInfo.changeProdPlan(1)
            self.__timerLabel.setVisible(False)
                        
    def setTerminationAction(self):
        if self.terminationAction.isChecked():
            self.buildAction.setChecked(False)
            self.siliconAction.setChecked(False)
            self.clearIDs()
            
            self.prodInfo.changeProdPlan(2)
            
            
    def disconnectTemp(self):
        if self.updateTempTimer.isActive():
            self.updateTempTimer.stop()
        if self.tempMon:
            if self.tempMon.alive.isSet():
                self.tempMon.join()
        self.tempMon = None
        self.tc08usb.close_unit()
        self.tc08usb = None
        self.tempConnected = False
        self.tempDisplay = QtGui.QLabel(text=u'-.- \u00b0C')
        
    def getAllFromQueue(self, Q):
        """ Generator to yield one after the others all items 
            currently in the queue Q, without any waiting.
        """
        try:
            while True:
                yield Q.get_nowait( )
        except Queue.Empty:
            raise StopIteration
   
    def getData(self):
        #get spectra
        data, timestamp, success  = self.readDataFromQ()
        if not success: 
            return None
        
        self.dbmData = data[0]
        actualTime = timestamp-self.startTime
        
        wl = self.__scaledWavelength
        self.plotW.plotS(wl,self.dbmData)
        if self.prodInfo.getProdPlanNum() == 2:
            rl = self.calcReturnloss()
            self.chan1IsLabel.setText(str("{0:.1f}".format(rl)))
            self.calculateLabelColor()
        else:
        #get peak data
            numVal = self.getPeakData(wl, self.dbmData, actualTime)
            self.plotW.plotT(self.peaksTime[:numVal-1], self.peaks[:numVal-1])
                
    def readDataFromQ(self):
        qData = list(list(self.getAllFromQueue(self.dataQ)))
        timestamp = 0
        d = None
        if len(qData) > 0:
            d = np.array(qData[-1][0])
            timestamp = qData[-1][1]
            d = d[:,self.__scalePos]
            return d, timestamp , 1
        else:
            return 0,0,0
        
    def getdBmSpec(self):
        try:
            dbmData = np.array(self.si255.get_spectrum([1,]), dtype=float)
            
        except hyperion.HyperionError as e:
            print(e)
        
        return dbmData
        
    def getIDs(self):
        pro = self.proID.text()
        fbg = self.fbgID.text()
        sensor = self.sensorID.text()
        er = self.prodInfo.setIDs(pro, fbg, sensor)        
        return er
        
    def getPeakData(self, wl, dbmData, timestamp):
        peak = self.peakFit(wl, dbmData)[0]
        numVal = np.count_nonzero(self.peaks)
        self.chan1IsLabel.setText(str("{0:.3f}".format(peak)))
        self.calculateLabelColor()
        if self.waitHeating:
            if peak >= self.__heatingStartWl:
                self.heatingTimer.start()
                self.waitHeating = False
                self.prodInfo.buttons.startButton.setEnabled(True)
                self.prodInfo.buttons.backButton.setEnabled(False)
                self.prodInfo.buttons.stopButton.setEnabled(False)
                self.__heatingStartTime = time.time()

                
        if numVal < self.__maxBuffer:
            self.peaks[numVal] = peak
            self.peaksTime[numVal] = timestamp
        else:
            self.peaks = shift(self.peaks, -1, cval = peak)
            self.peaksTime = shift(self.peaksTime, -1, cval = timestamp)
            
        return numVal
        
    def getTemp(self):
        try: 
            temp = self.tempQ.get(True, 0.01)
            
        except Queue.Empty:
            return None
        tempStr = str("{0:.1f}".format(temp)) + u' \u00b0C'
        self.tempDisplay.setText(tempStr)

    def loadSettings(self):
        print('Lade Einstellungen Hauptfenster')
        self.__Vorsp = []
        self.__VorspTol = []
        settings = QtCore.QSettings('test.ini',QtCore.QSettings.IniFormat)
        settings.beginGroup('Produktion')
        self.__heatingTime = settings.value('Heizdauer').toInt()[0]
        vorSp = settings.value('VorspannFein').toFloat()[0]
        deltaHeating = settings.value('HeizDetekt').toFloat()[0]
        self.__SpecWinRL = settings.value('windowRL').toFloat()[0]
        settings.endGroup()
        
        settings.beginGroup('Dateipfade')
        self.specFolder = str(settings.value('Spektrenordner').toString())
        settings.endGroup()
        self.__heatingStartWl = vorSp + deltaHeating
        
        settings.beginGroup('Plot')
        self.__maxBuffer = settings.value('Buffer').toInt()[0]
        self.plotW.setTracePoints(settings.value('TracePunkte').toInt()[0])
        showTrace = settings.value('ShowTrace').toInt()[0]
        showSpec = settings.value('ShowSpec').toInt()[0]
        minWl = settings.value('MinWl').toFloat()[0]
        maxWl = settings.value('MaxWl').toFloat()[0]
        regPoints = settings.value('RegPoints').toInt()[0]
        settings.endGroup()
        self.showPlot(showTrace,showSpec)
        self.scaleInputSpectrum(minWl,maxWl)
        self.setBuffer()
        self.plotW.setRegPoints(regPoints)
        print('Einstellungen Hauptfenster wurden geladen')
        
    
    def openOptionsDialog(self):
        passW, ok = QtGui.QInputDialog.getText(self,"Optionen", "Bitte Password eingeben")
        if ok and passW == 'Test':
            option = OptionDialog()
            if option.exec_():
                self.prodInfo.loadSettings()
                self.loadSettings()

    def openSensor(self):
        ids = self.prodInfo.getSensorIDs() 
        newDia = NewSensorDialog(ids)
        index = 0
        if newDia.exec_():
            index = newDia.setSensor()
            self.setIDbyIndex(index)
            
    def setIDbyIndex(self, index =-1):
        pro, fbg, sens = self.prodInfo.getIDbyIndex(index)
        self.proID.setText(pro)
        self.fbgID.setText(fbg)
        self.sensorID.setText(sens)
        
    def saveSpectrum(self, x, y):
        if len(x) == 0:
            y = self.dbmData
            x = self.__scaledWavelength
        fname = time.strftime('%Y%m%d_%H%M%S') + self.sensorID.text() + '.spc'
        _file = os.path.join(str(self.specFolder) , str(fname))  
        
        File = open(_file,'w')
        for i in range(len(x)):
            File.write(str("{0:.3f}".format(x[i])) + '\t' + str(y[i]) + '\n')
        File.close()
        return fname
            
    def scaleInputSpectrum(self,_min,_max):
        self.__minWl = _min
        self.__maxWl = _max
        self.__scalePos = np.where((self.__wavelength>=self.__minWl)&(self.__wavelength<=self.__maxWl))[0]
        self.__scaledWavelength = self.__wavelength[self.__scalePos]
        
    def setActionState(self):
        if self.isConnected:
            self.connectAction.setIcon(QtGui.QIcon('../icons/Button Delete.png'))
            if self.measurementActive:
                self.connectAction.setEnabled(False)
                self.connectTempAction.setEnabled(False)
                self.startAction.setEnabled(False)
                self.stopAction.setEnabled(True)
            else:
                self.connectAction.setEnabled(True)
                self.connectTempAction.setEnabled(True)
                self.startAction.setEnabled(True)
                self.stopAction.setEnabled(False)
        else:
            self.connectAction.setIcon(QtGui.QIcon('../icons/Button Add.png'))
            self.startAction.setEnabled(False)
            self.stopAction.setEnabled(False)
        if self.tempConnected:
            self.connectTempAction.setIcon(QtGui.QIcon('../icons/Thermo.png'))
        else:
            self.connectTempAction.setIcon(QtGui.QIcon('../icons/NoThermo.png'))
            
    def setBuffer(self):
        self.peaks = np.zeros(self.__maxBuffer)
        self.peaksTime = np.zeros(self.__maxBuffer)
            
    def setProdIDs(self, proID, sensorID, fbgID):
        self.proID.setText(proID)
        self.fbgID.setText(fbgID)
        self.fbgID.setFocus()
        self.sensorID.setText(sensorID)
            
    def setSlope(self, slope):
        self.slopeCh1Dial.setSlope(slope)
        
    def setSollLabel(self, text):
        if text:
            self.sollLabel.setVisible(True)
            self.chan1SollLabel.setVisible(True)
            self.chan1SollLabel.setText(text)
        else:
            self.sollLabel.setVisible(False)
            self.chan1SollLabel.setVisible(False)
            
            
    def setTime(self, sec):
        m, s = divmod(sec, 60)
        timeStr="%02d:%02d" % (m, s)
        self.__timerLabel.setText(timeStr)
        
    def setAutoScale(self, state):
        if state:
            self.minWlSpin.setEnabled(True)
            self.maxWlSpin.setEnabled(True)
            self.plotW.setAutoScaleWavelength(True)
        else:
            self.minWlSpin.setEnabled(False)
            self.maxWlSpin.setEnabled(False)
            self.plotW.setAutoScaleWavelength(False)
        
    def showPlot(self,plotT, plotS):
        self.plotW.setShowPlot(plotT, plotS)
        
    def startMeasurement(self):
        self.setBuffer()
        self.startTime = time.time()
        #initialize Queue
        self.dataQ = Queue.Queue(100)
        #self.initTempArray()
        self.Monitor = MonitorHyperionThread(self.dataQ, self.si255, 
                                         channelList=[1,], specDevider=1)
        self.Monitor.start()
        self.updateTimer.start(100)
        self.measurementActive = True
        self.setActionState()
        
    def stopMeasurement(self):
        self.updateTimer.stop()
        try:
            self.Monitor.join(0.1)
        except:
            pass
        self.Monitor = None
        self.si255.disable_spectrum_streaming()
        self.measurementActive = False
        self.setActionState()
    

    def testChannelForPeaks(self):
        data = self.peakFit(self.__scaledWavelength, self.dbmData)
        #print(data)
        if data[0] > 1543. and data[0] < 1550.:
            print('Peak found')
            FBG = 1
        else:
            FBG = 0
        return FBG
        
    def testSpectrometer(self):
        print('Test for Spectrometer')
        try:
            if self.si255:
                if self.si255.comm.connected:
                    return 1
                else:
                    return self.initDevice()
            else:
                return self.initDevice()
        except:
            pass
            
    def testThermometer(self):
        print('Test for Thermometer')
        try:
            if not self.tempConnected:
                self.connectTemp()
        except:
            pass
        if self.tempConnected:
            return 1
        else:
            self.printError(6)
            return 0
                
    def tempActionToggled(self, state):
        if not self.tempConnected:
            self.connectTemp()
        else:
            self.disconnectTemp()
        self.setActionState()
            
#### Production
            
    def activateTimer(self):
        self.heatingTimer = QtCore.QTimer()
        self.heatingTimer.setInterval(500)
        self.heatingTimer.timeout.connect(self.updateHeatingTimer)
        self.waitHeating = True
        self.prodInfo.buttons.startButton.setEnabled(False)
        self.__timerLabel.setStyleSheet("color: black")
        
    def activateCooling(self):
        self.__activateCooling = True
        
    def activateOpenSensor(self):
        
        if self.prodInfo.getProdPlanNum():
            self.__timerLabel.setVisible(False)
            self.openSensorButton.setVisible(True)
            if self.prodInfo.getProStep() == 0:
                self.clearIDs()
                self.openSensorButton.setEnabled(True)
            else:
                self.openSensorButton.setEnabled(False)
        else:
            self.__timerLabel.setVisible(True)
            self.openSensorButton.setVisible(False)
        
        
    def updateHeatingTimer(self):
        ht = time.time() - self.__heatingStartTime
        self.setTime(ht)
        if ht >= self.__heatingTime:
            self.heatingTimer.stop()
            self.__timerLabel.setStyleSheet("color: green")
#==============================================================================
#             peak = self.chan1IsLabel.text()
#             self.prodInfo.setPeakWavelength(peak)
#             temp = self.tempDisplay.text()
#             self.prodInfo.setTemp(temp)
#             self.prodInfo.buttons.startButton.setEnabled(True)
#             self.prodInfo.buttons.backButton.setEnabled(True)
#             self.prodInfo.buttons.stopButton.setEnabled(True)
#             self.setTime(0)
#==============================================================================
                
    def startProductionSequence(self):
        if not self.testModus:
            if not self.testThermometer(): 
                return 0
            if not self.testSpectrometer(): 
                return 0
            if not self.measurementActive:
                self.startMeasurement()
        print('Starte neue Produktionssequenz')
        self.prodInfo.startProduction()
        
        
    def prodSequenzClicked(self):
        if self.prodInfo.buttons.startButton.text() == 'Start':
            self.startProductionSequence()
            
        elif self.prodInfo.buttons.startButton.text() == 'Weiter':
            print('Next Step')
            if self.prodInfo.getProStep() < self.prodInfo.proStepNb[-1]-2:
                self.prodInfo.buttons.setEnabled(False)
                if self.parseProdCondition():
                    self.parseProdMeas()
                    self.prodInfo.nextProductionStep()
                self.prodInfo.buttons.setEnabled(True)
                
            elif self.prodInfo.getProStep() == self.prodInfo.proStepNb[-1]-2:
                if self.parseProdCondition():
                    self.parseProdMeas()
                    self.prodInfo.buttons.startButton.setText('Neu')
                    self.prodInfo.nextProductionStep()
        elif self.prodInfo.buttons.startButton.text() == 'Neu':
            self.prodInfo.productionSequenzCancel(0)
            
        else:
            print('Error Production Sequenz')
        self.activateOpenSensor()
        #self.prodInfo.buttons.startButton.setFocus()
        
            
    def prodSequenzBack(self):
        if self.prodInfo.getProStep() > 0:
            self.prodInfo.productionSequenzBack()
        self.activateOpenSensor()
            
    def parseProdCondition(self):
        cond = self.prodInfo.getProCondition()
        if cond:
            cond = cond.split(',')
            #print(cond)
            for c in cond:
                c = c.strip()
                if c == 'fbg':
                    if not self.testModus:
                        if not self.testChannelForPeaks():
                            self.printError(0)
                            return 0
                elif c == 'ids':
                    print('Test for IDs')
                    if not self.testModus:
                        if self.prodInfo.getProdPlanNum() == 0:
                            text = self.proID.text()
                            if not text:
                                self.printError(1)
                                self.proID.setFocus()
                                return 0
                            if not self.prodInfo.testID(0,text):
                                self.printError(9)
                                self.proID.clear()
                                self.proID.setFocus()
                                return 0
                                
                            text = self.fbgID.text()
                            fID=text.split('-')
                            if not text.split('-')[1]:
                                self.printError(2)
                                self.fbgID.setFocus()
                                return 0
                            if not self.prodInfo.testID(1,text):
                                if not self.printError(10,1):
                                    self.fbgID.clear()
                                    self.fbgID.setFocus()
                                    return 0
                                
                            text = self.sensorID.text()
                            if not text:
                                self.printError(3)
                                self.sensorID.setFocus()
                                return 0
                            if not self.prodInfo.testID(2,text):
                                if not self.printError(11,1):
                                    self.sensorID.clear()
                                    self.sensorID.setFocus()
                                    return 0
                        else:
                            if not self.proID.text():
                                self.printError(7)
                                return 0
                        
                elif c == 'Zielwert':
                    tol = self.prodInfo.getTolaranz()
                    diff = float(self.chan1IsLabel.text())-float(self.chan1SollLabel.text())
                    msgWl = unicode("""Peakwellenlänge entspricht nicht der Vorgabe!
                                    \n\n Wollen Sie wirklich fortfahren""", 'utf-8')
                    msgRl = unicode("""Rückstreuung entspricht nicht der Vorgabe!
                                    \n\n Wollen Sie wirklich fortfahren""", 'utf-8')
                    if self.prodInfo.getProdPlanNum() == 2:
                        isTol = diff <tol
                        msg = msgRl
                    else:
                        isTol = abs(diff) < tol
                        msg = msgWl
                    if not isTol:
                        reply = QtGui.QMessageBox.question(self, 'Warnung', msg, 
                                    QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)

                        if reply == QtGui.QMessageBox.Yes:
                            return 1
                        else:
                            return 0
        return 1
     
    def parseProdMeas(self):
        if not self.testModus:
            meas = self.prodInfo.getProMeas()
            x = self.__scaledWavelength
            y = self.dbmData
            cenFit = 0.
            cenCoG = 0.
            fwhm = 0
            asym = 0.
            peak = 0.
            if meas:
                meas = meas.split(',')
                #print (meas)
                for m in meas:
                    m = m.strip()
                    if m == 'ids':
                        print('Write ids')
                        if not self.testModus:
                            if not self.getIDs():
                                self.printError(4)
                                return 0
                            
                    elif m == 'date':
                        print('Write date')
                        if not self.testModus:
                            self.prodInfo.setDate()
                    elif m == 'peak':
                        print('Measure Peak Wavelength')
                        if not self.testModus:
                            peak = self.chan1IsLabel.text()
                            self.prodInfo.setPeakWavelength(peak)
                    elif m == 'spectrum':
                        print('Measure Spectrum')
                        if not self.testModus:
                            fname = self.saveSpectrum(x,y)
                            self.prodInfo.setSpecFile(fname)
                    elif m == 'fwhm':
                        print('Determine FWHM')
                        if not self.testModus:
                            cenFit = self.peakFit(x,y)[0]
                            fwhm = self.calcFWHM(x,y)
                            self.prodInfo.setFWHM(fwhm)
                    elif m == 'asymm':
                        print('Determine Asymmety Ratio')
                        if not self.testModus:
                            cenCoG = self.centerOfGravity(x,y, peak)
                            asym = self.calculateAsym(cenFit, cenCoG)
                            self.prodInfo.setAsymmetrie(asym)
                    elif m == 'temp':
                        print('Measure Temperature')
                        if not self.testModus:
                            temp = self.tempDisplay.text()
                            self.prodInfo.setTemp(temp)
                    elif m == 'timer':
                        print('Activate heating Timer.')
                        if not self.testModus:
                            if self.heatingTimer.isActive():
                                self.printError(8)
                                self.prodSequenzBack()
                            else:
                                self.activateTimer()
                    elif m == 'cooling':
                        print('Wait for Temprature = 90°C')
                        if not self.testModus:
                            self.activateCooling()
   
#### calculations
   
    def peakFit(self, x, y):
        y=np.power(10,y/10)
        p0 = [x[np.argmax(y)], 1, .2, 0]
        popt, pcov = curve_fit(self.gauss, x, y, p0)
        return popt
        
    def calcFWHM(self, x,y):
        hmdB = np.max(y) - 3
        maxX = x[np.argmax(y)]
        hmX = x[np.where((y> hmdB-.5) & (y< hmdB+.5) )[0]]
        hm1 = np.mean(hmX[np.where(hmX < maxX)[0]])
        hm2 = np.mean(hmX[np.where(hmX > maxX)[0]])
        fwhm = abs(hm2-hm1)
        print('FWHM: %s'% fwhm)
        return fwhm
   
    def centerOfGravity(self, x, y, peak=None):
        y = np.power(10,y/10)
        if not peak:
            pos = np.where(y>(np.max(y)*.3))[0]
        else:
            print('CoG spectral Window')
            xmin = float(peak)-float(self.cogSpectralWin)
            xmax = float(peak)+float(self.cogSpectralWin)
            pos = np.where((x>=xmin)&(x<=xmax))[0]
        x = x[pos]
        y = y[pos]
           
        cog = (x*y).sum()/y.sum()
        return cog
   
    def calculateAsym(self, pFit, pCOG):
        if pFit:
            return np.abs(pFit-pCOG)
        else:
            return 0
    
    def calcReturnloss(self):
        x = self.__scaledWavelength
        y = self.dbmData
        maxX = x[np.argmax(y)]
        xmin = float(maxX)-float(self.__SpecWinRL)
        xmax = float(maxX)+float(self.__SpecWinRL)
        pos = np.where((x<=xmin)|(x>=xmax))[0]
        return np.mean(y[pos])
                  
    def gauss(self,x, center, amp, sig, off):
        up = x - center
        up2 = up*up
        down = 2*sig*sig
        frac = up2/down * -1
        _exp = np.exp(frac)
        
        return amp*_exp + off
            
    def printError(self, errorCode, warning=0):
        errorHeader = ['Kein FBG gefunden',     #0
                       'Keine Produktions ID',  #1
                       'Keine Faser ID',          #2
                       'Keine Sensor ID',       #3
                       'Schreibfehler',         #4
                       'Kein Spektrometer',     #5
                       'Kein Thermometer',      #6
                       'Kein Sensor geladen',    #7
                       'Timer aktiv',           #8
                       'Produktions ID bereits vorhanden',  #9
                       'Faser ID bereits vorhanden',        #10
                       'Sensor ID bereits vorhanden']       #11
                       
        errorMessage = [unicode('Konnte keinen Peak detektieren. Bitte überprüfen Sie die angeschlossene Faser', 'utf-8'),
                        unicode('Bitte geben Sie eine Produktions-Identifikationsnummer ein.', 'utf-8'),
                        unicode('Bitte geben Sie eine Faser-Identifikationsnummer ein.', 'utf-8'),
                        unicode('Bitte geben Sie eine Sensor-Identifikationsnummer ein.', 'utf-8'),
                        unicode('Konnte Identifikationsnummern nicht in Tabelle schreiben.', 'utf-8'),
                        unicode('Bitte überprüfen Sie ob das Spektrometer angeschaltet bzw. angeschlossen ist.', 'utf-8'),
                        unicode('Bitte überprüfen Sie ob das Thermometer angeschaltet bzw. angeschlossen ist.', 'utf-8'),
                        unicode('Bitte SensorID laden.','utf-8'),
                        unicode('Bitte warten bis die aktuelle Heizperiode beendet ist.','utf-8'),
                        unicode('Die gewählte Produktions ID ist bereits vorhanden.\nBitte geben Sie eine neue ID ein.','utf-8'),
                        unicode('Die gewählte Faser ID ist bereits vorhanden.\n\nWollen Sie wirklich fortfahren?','utf-8'),
                        unicode('Die gewählte Sensor ID ist bereits vorhanden.\n\nWollen Sie wirklich fortfahren?','utf-8')]
        
        if warning:
            reply = QtGui.QMessageBox.question(self, errorHeader[errorCode], errorMessage[errorCode] ,
                                    QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                return 1
            else:
                return 0
        else:
            QtGui.QMessageBox.critical(self,errorHeader[errorCode],errorMessage[errorCode])