source: trunk/synapse/Puzzlebox/Synapse/Interface.py @ 167

Last change on this file since 167 was 167, checked in by sc, 12 years ago

synapse/Puzzlebox/Synapse/Interface_Design.py:

  • tab order fixed

synapse/Puzzlebox/Synapse/Interface.py:

  • second graph added to raw eeg wave tab
  • Property svn:executable set to *
File size: 20.0 KB
Line 
1# -*- coding: utf-8 -*-
2
3# Copyright Puzzlebox Productions, LLC (2010)
4#
5# This code is released under the GNU Pulic License (GPL) version 2
6# For more information please refer to http://www.gnu.org/copyleft/gpl.html
7
8# Old Class Names:
9#       puzzlebox_synapse_interface = QtUI
10
11__changelog__ = """\
12Last Update: 2010.08.25
13
14"""
15
16__todo__ = """
17- update configuration.ini file with settings entered into interface
18
19"""
20
21### IMPORTS ###
22import os, sys
23import simplejson as json
24
25import random
26from numpy import arange, sin, pi
27from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
28from matplotlib.figure import Figure
29
30if (sys.platform != 'win32'):
31        import bluetooth
32        DEFAULT_IMAGE_PATH = '/usr/share/puzzlebox_synapse/images'
33else:
34        import serial
35        DEFAULT_IMAGE_PATH = 'images'
36
37try:
38        import PySide as PyQt4
39        from PySide import QtCore, QtGui
40except:
41        print "Using PyQt4 module"
42        from PyQt4 import QtCore, QtGui
43else:
44        print "Using PySide module"
45
46# from puzzlebox_synapse_interface_design import Ui_Form
47from Interface_Design import Ui_Form as Design
48
49import Configuration as configuration
50import Server as synapse_server
51import Client as thinkgear_client
52#import puzzlebox_logger
53
54### GLOBALS ###
55
56DEBUG = 1
57
58THINKGEAR_SERVER_HOST = configuration.THINKGEAR_SERVER_HOST
59THINKGEAR_SERVER_PORT = configuration.THINKGEAR_SERVER_PORT
60
61THINKGEAR_EEG_POWER_BAND_ORDER = configuration.THINKGEAR_EEG_POWER_BAND_ORDER
62
63THINKGEAR_EMULATION_MAX_ESENSE_VALUE = \
64        configuration.THINKGEAR_EMULATION_MAX_ESENSE_VALUE
65THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE = \
66        configuration.THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
67
68PATH_TO_HCITOOL = '/usr/bin/hcitool'
69
70#UPDATE_INTERFACE_VIA_TIMER = True # Alternative is to establish a
71                                  ## ThinkGear Connect client which
72                                  ## updates the interface on demand
73                                  ## as packets are received
74
75UPDATE_INTERFACE_VIA_TIMER = False
76
77#INTERFACE_UPDATE_FREQUENCY = (1 / 512) * 1000 # ms (512 Hz)
78INTERFACE_UPDATE_FREQUENCY = 1000 # ms
79
80INTERFACE_RAW_EEG_UPDATE_FREQUENCY = 256
81
82### CLASSES ###
83
84class QtUI(QtGui.QWidget, Design):
85       
86        def __init__(self, log, server=None, DEBUG=DEBUG, parent = None):
87               
88                self.log = log
89                self.DEBUG = DEBUG
90               
91                QtGui.QWidget.__init__(self, parent)
92                self.setupUi(self)
93               
94                self.configureSettings()
95                self.connectWidgets()
96               
97                self.name = "Synapse Interface"
98               
99                self.thinkGearConnectServer = None
100                self.thinkgearConnectClient = None
101               
102                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
103               
104                self.debug_console_buffer = ''
105               
106                if UPDATE_INTERFACE_VIA_TIMER:
107                        self.updateInterfaceTimer = QtCore.QTimer()
108                        QtCore.QObject.connect(self.updateInterfaceTimer, \
109                                                    QtCore.SIGNAL("timeout()"), \
110                                                    self.updateInterface)
111       
112       
113        ##################################################################
114       
115        def configureSettings(self):
116               
117                # Synapse Interface
118                image_path = "puzzlebox.ico"
119                if not os.path.exists(image_path):
120                        image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path)
121               
122                if os.path.exists(image_path):
123                        icon = QtGui.QIcon()
124                        icon.addPixmap(QtGui.QPixmap(image_path), \
125                                            QtGui.QIcon.Normal, \
126                                            QtGui.QIcon.Off)
127                        self.setWindowIcon(icon)
128               
129                image_path = "puzzlebox_logo.png"
130                if not os.path.exists(image_path):
131                        image_path = os.path.join(DEFAULT_IMAGE_PATH, image_path)
132                if os.path.exists(image_path):
133                        self.labelPuzzleboxIcon.setPixmap(QtGui.QPixmap(image_path))
134               
135               
136                # ThinkGear Device
137                self.searchForThinkGearDevices()
138               
139               
140                # ThinkGear Connect Server
141                self.textLabelBluetoothStatus.setText("Status: Disconnected")
142               
143                # Display Host for ThinkGear Connect Socket Server
144                self.lineEditThinkGearHost.setText(THINKGEAR_SERVER_HOST)
145               
146                # Display Port for ThinkGear Connect Socket Server
147                self.lineEditThinkGearPort.setText('%i' % THINKGEAR_SERVER_PORT)
148               
149               
150                # ThinkgGear Progress Bars
151                self.progressBarEEGDelta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
152                self.progressBarEEGTheta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
153                self.progressBarEEGLowAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
154                self.progressBarEEGHighAlpha.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
155                self.progressBarEEGLowBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
156                self.progressBarEEGHighBeta.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
157                self.progressBarEEGLowGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
158                self.progressBarEEGMidGamma.setMaximum(THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE)
159               
160                self.progressBarAttention.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE)
161                self.progressBarMeditation.setMaximum(THINKGEAR_EMULATION_MAX_ESENSE_VALUE)
162               
163                self.progressBarSignalContactQuality.setMaximum(200)
164               
165               
166                self.matplot = dynamicMatplotlibCanvas(self.tabEEGSignals, \
167                                                       width=8, \
168                                                       height=4, \
169                                                       dpi=100, \
170                                                       title='Raw EEG Waves')
171       
172       
173        ##################################################################
174       
175        def connectWidgets(self):
176               
177                self.connect(self.pushButtonBluetoothSearch, \
178                                  QtCore.SIGNAL("clicked()"), \
179                                  self.searchForThinkGearDevices)
180               
181                self.connect(self.pushButtonBluetoothConnect, \
182                                  QtCore.SIGNAL("clicked()"), \
183                                  self.connectToThinkGearDevice)
184               
185                self.connect(self.pushButtonThinkGearConnect, \
186                                  QtCore.SIGNAL("clicked()"), \
187                                  self.startThinkGearConnectServer)
188       
189       
190        ##################################################################
191       
192        def connectToThinkGearDevice(self):
193               
194                device_selection = self.comboBoxDeviceSelect.currentText()
195               
196                self.disconnect(self.pushButtonBluetoothConnect, \
197                                     QtCore.SIGNAL("clicked()"), \
198                                     self.connectToThinkGearDevice)
199               
200                self.connect(self.pushButtonBluetoothConnect, \
201                                  QtCore.SIGNAL("clicked()"), \
202                                  self.disconnectFromThinkGearDevice)
203               
204                self.textLabelBluetoothStatus.setText("Status: Connected")
205               
206                self.pushButtonBluetoothSearch.setEnabled(False)
207               
208                self.pushButtonBluetoothConnect.setText('Disconnect')
209                self.pushButtonBluetoothConnect.setChecked(True)
210               
211                self.comboBoxDeviceSelect.setEnabled(False)
212       
213       
214        ##################################################################
215       
216        def disconnectFromThinkGearDevice(self):
217               
218                self.disconnect(self.pushButtonBluetoothConnect, \
219                                     QtCore.SIGNAL("clicked()"), \
220                                     self.disconnectFromThinkGearDevice)
221               
222                self.connect(self.pushButtonBluetoothConnect, \
223                                  QtCore.SIGNAL("clicked()"), \
224                                  self.connectToThinkGearDevice)
225               
226                self.textLabelBluetoothStatus.setText("Status: Disconnected")
227               
228                self.pushButtonBluetoothSearch.setEnabled(True)
229               
230                self.pushButtonBluetoothConnect.setText('Connect')
231                self.pushButtonBluetoothConnect.setChecked(False)
232               
233                self.comboBoxDeviceSelect.setEnabled(True)
234               
235               
236                self.progressBarEEGDelta.setValue(0)
237                self.progressBarEEGTheta.setValue(0)
238                self.progressBarEEGLowAlpha.setValue(0)
239                self.progressBarEEGHighAlpha.setValue(0)
240                self.progressBarEEGLowBeta.setValue(0)
241                self.progressBarEEGHighBeta.setValue(0)
242                self.progressBarEEGLowGamma.setValue(0)
243                self.progressBarEEGMidGamma.setValue(0)
244               
245                self.progressBarAttention.setValue(0)
246                self.progressBarMeditation.setValue(0)
247               
248                self.progressBarSignalContactQuality.setValue(0)
249               
250                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
251               
252                # In case the user connects to a MindSet, then disconnects
253                # and re-connects to a MindSet Emulator,
254                # we need to reset the max power values
255                self.progressBarEEGDelta.setMaximum(self.maxEEGPower)
256                self.progressBarEEGTheta.setMaximum(self.maxEEGPower)
257                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower)
258                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower)
259                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower)
260                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower)
261                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower)
262                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower)
263       
264       
265        ##################################################################
266       
267        def startThinkGearConnectServer(self):
268               
269                # Ensure EEG device is connected first
270               
271                if not self.pushButtonBluetoothConnect.isChecked():
272                        self.connectToThinkGearDevice()
273               
274               
275                self.pushButtonBluetoothSearch.setEnabled(False)
276                self.pushButtonBluetoothConnect.setEnabled(False)
277               
278                server_interface = str(self.lineEditThinkGearHost.text())
279                server_port = int(self.lineEditThinkGearPort.text())
280                device_address = str(self.comboBoxDeviceSelect.currentText())
281                emulate_headset_data = (device_address == 'MindSet Emulator')
282               
283               
284                self.thinkGearConnectServer = \
285                        synapse_server.ThinkgearServer( \
286                                self.log, \
287                                server_interface=server_interface, \
288                                server_port=server_port, \
289                                device_address=device_address, \
290                                emulate_headset_data=emulate_headset_data, \
291                                DEBUG=DEBUG, \
292                                parent=self)
293               
294                self.thinkGearConnectServer.start()
295               
296               
297                if UPDATE_INTERFACE_VIA_TIMER:
298                        self.updateInterfaceTimer.start(INTERFACE_UPDATE_FREQUENCY)
299               
300                else:
301                        self.thinkgearConnectClient = \
302                                thinkgear_client.QtClient( \
303                                        self.log, \
304                                        server_host=server_interface, \
305                                        server_port=server_port, \
306                                        DEBUG=0, \
307                                        parent=self)
308                       
309                        self.thinkgearConnectClient.start()
310               
311               
312                self.disconnect(self.pushButtonThinkGearConnect, \
313                                     QtCore.SIGNAL("clicked()"), \
314                                     self.startThinkGearConnectServer)
315               
316                self.connect(self.pushButtonThinkGearConnect, \
317                                  QtCore.SIGNAL("clicked()"), \
318                                  self.stopThinkGearConnectServer)
319               
320                self.lineEditThinkGearHost.setEnabled(False)
321                self.lineEditThinkGearPort.setEnabled(False)
322               
323                self.pushButtonThinkGearConnect.setText('Stop')
324       
325       
326        ##################################################################
327       
328        def stopThinkGearConnectServer(self):
329               
330                if UPDATE_INTERFACE_VIA_TIMER:
331                        self.updateInterfaceTimer.stop()
332                else:
333                        self.thinkgearConnectClient.disconnectFromHost()
334               
335                self.thinkGearConnectServer.exitThread()
336               
337                self.disconnect(self.pushButtonThinkGearConnect, \
338                                     QtCore.SIGNAL("clicked()"), \
339                                     self.stopThinkGearConnectServer)
340               
341                self.connect(self.pushButtonThinkGearConnect, \
342                                  QtCore.SIGNAL("clicked()"), \
343                                  self.startThinkGearConnectServer)
344               
345                self.lineEditThinkGearHost.setEnabled(True)
346                self.lineEditThinkGearPort.setEnabled(True)
347               
348                self.pushButtonThinkGearConnect.setText('Start')
349               
350                #self.pushButtonBluetoothSearch.setEnabled(True)
351                self.pushButtonBluetoothConnect.setEnabled(True)
352       
353       
354        ##################################################################
355       
356        def updateInterface(self):
357               
358                if not self.thinkGearConnectServer.emulate_headset_data:
359                        self.processPacketThinkGear( \
360                                self.thinkGearConnectServer.protocol.data_packet)
361       
362       
363        ##################################################################
364       
365        def updateRawEegInterface(self):
366               
367                pass
368       
369       
370        ##################################################################
371       
372        def processPacketThinkGear(self, packet):
373               
374                if self.DEBUG > 2:
375                        print packet
376               
377               
378                if ('rawEeg' in packet.keys()):
379                        value = packet['rawEeg']
380                        self.matplot.update_figure(value)
381               
382               
383                if ('poorSignalLevel' in packet.keys()):
384                        value = 200 - packet['poorSignalLevel']
385                        self.progressBarSignalContactQuality.setValue(value)
386                        self.textEditDebugConsole.append("")
387                        self.textEditDebugConsole.append("poorSignalLevel: %i" % \
388                                                              packet['poorSignalLevel'])
389               
390               
391                if ('eSense' in packet.keys()):
392                       
393                        if ('attention' in packet['eSense'].keys()):
394                                value = packet['eSense']['attention']
395                                self.progressBarAttention.setValue(value)
396                                self.textEditDebugConsole.append("eSense attention: %i" % value)
397                       
398                        if ('meditation' in packet['eSense'].keys()):
399                                value = packet['eSense']['meditation']
400                                self.progressBarMeditation.setValue(value)
401                                self.textEditDebugConsole.append("eSense meditation: %i" % value)
402               
403               
404                if ('eegPower' in packet.keys()):
405                       
406                        # If we are not emulating packets we'll set the maximum EEG Power value
407                        # threshold to the default (or maximum value found within this packet)
408                        if not self.thinkGearConnectServer.emulate_headset_data:
409                                self.maxEEGPower = THINKGEAR_EMULATION_MAX_EEG_POWER_VALUE
410                       
411                        for value in packet['eegPower'].keys():
412                                if packet['eegPower'][value] > self.maxEEGPower:
413                                        self.maxEEGPower = packet['eegPower'][value]
414                       
415                       
416                        if ('delta' in packet['eegPower'].keys()):
417                                value = packet['eegPower']['delta']
418                                self.progressBarEEGDelta.setMaximum(self.maxEEGPower)
419                                self.progressBarEEGDelta.setValue(value)
420                                self.textEditDebugConsole.append("delta: %i" % value)
421                       
422                        if ('theta' in packet['eegPower'].keys()):
423                                value = packet['eegPower']['theta']
424                                self.progressBarEEGTheta.setMaximum(self.maxEEGPower)
425                                self.progressBarEEGTheta.setValue(value)
426                                self.textEditDebugConsole.append("theta: %i" % value)
427                       
428                        if ('lowAlpha' in packet['eegPower'].keys()):
429                                value = packet['eegPower']['lowAlpha']
430                                self.progressBarEEGLowAlpha.setMaximum(self.maxEEGPower)
431                                self.progressBarEEGLowAlpha.setValue(value)
432                                self.textEditDebugConsole.append("lowAlpha: %i" % value)
433                       
434                        if ('highAlpha' in packet['eegPower'].keys()):
435                                value = packet['eegPower']['highAlpha']
436                                self.progressBarEEGHighAlpha.setMaximum(self.maxEEGPower)
437                                self.progressBarEEGHighAlpha.setValue(value)
438                                self.textEditDebugConsole.append("highAlpha: %i" % value)
439                       
440                        if ('lowBeta' in packet['eegPower'].keys()):
441                                value = packet['eegPower']['lowBeta']
442                                self.progressBarEEGLowBeta.setMaximum(self.maxEEGPower)
443                                self.progressBarEEGLowBeta.setValue(value)
444                                self.textEditDebugConsole.append("lowBeta: %i" % value)
445                       
446                        if ('highBeta' in packet['eegPower'].keys()):
447                                value = packet['eegPower']['highBeta']
448                                self.progressBarEEGHighBeta.setMaximum(self.maxEEGPower)
449                                self.progressBarEEGHighBeta.setValue(value)
450                                self.textEditDebugConsole.append("highBeta: %i" % value)
451                       
452                        if ('lowGamma' in packet['eegPower'].keys()):
453                                value = packet['eegPower']['lowGamma']
454                                self.progressBarEEGLowGamma.setMaximum(self.maxEEGPower)
455                                self.progressBarEEGLowGamma.setValue(value)
456                                self.textEditDebugConsole.append("lowGamma: %i" % value)
457                       
458                        if ('highGamma' in packet['eegPower'].keys()):
459                                value = packet['eegPower']['highGamma']
460                                self.progressBarEEGMidGamma.setMaximum(self.maxEEGPower)
461                                self.progressBarEEGMidGamma.setValue(value)
462                                self.textEditDebugConsole.append("highGamma: %i" % value)
463       
464       
465        ##################################################################
466       
467        def enumerateSerialPorts(self):
468               
469                """ Uses the Win32 registry to return an
470                iterator of serial (COM) ports
471                existing on this computer.
472               
473                from http://eli.thegreenplace.net/2009/07/31/listing-all-serial-ports-on-windows-with-python/
474                """
475         
476                path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM'
477                try:
478                        key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
479                except WindowsError:
480                        raise IterationError
481               
482                for i in itertools.count():
483                        try:
484                                val = winreg.EnumValue(key, i)
485                                yield str(val[1])
486                        except EnvironmentError:
487                                break
488       
489       
490        ##################################################################
491       
492        def fullPortName(self, portname):
493               
494                """ Given a port-name (of the form COM7,
495                COM12, CNCA0, etc.) returns a full
496                name suitable for opening with the
497                Serial class.
498                """
499               
500                m = re.match('^COM(\d+)$', portname)
501                if m and int(m.group(1)) < 10:
502                        return portname
503               
504                return '\\\\.\\' + portname
505       
506       
507        ##################################################################
508       
509        def searchForThinkGearDevices(self):
510               
511                #self.pushButtonBluetoothSearch.setText('Searching')
512               
513                mindset_devices = []
514               
515                if (sys.platform == 'win32'):
516                       
517                        for portname in self.enumerateSerialPorts():
518                               
519                                #portname = self.fullPortName(portname)
520                                mindset_devices.append(portname)
521               
522               
523                else:
524                       
525                        # Bluetooth module doesn't compile properly under Windows
526                       
527                        bluetooth_devices = []
528                       
529                        #bluetooth_devices = bluetooth.discover_devices( \
530                                                    #duration=5, \
531                                                    #flush_cache=True, \
532                                                    #lookup_names=True)
533                       
534                        command = '%s con' % PATH_TO_HCITOOL
535                       
536                        output = os.popen(command, 'r')
537                       
538                        for line in output.readlines():
539                                try:
540                                        address = line.split(' ')[2]
541                                except:
542                                        pass
543                                else:
544                                        bluetooth_devices.append(address)
545                       
546                        for address in bluetooth_devices:
547                                device_name = bluetooth.lookup_name(address)
548                                if device_name == 'MindSet':
549                                        mindset_devices.append(address)
550                       
551                       
552                        if self.DEBUG:
553                                print "Bluetooth MindSet devices found:",
554                                print mindset_devices
555                       
556                       
557                        self.comboBoxDeviceSelect.clear()
558                       
559                        self.comboBoxDeviceSelect.addItem('MindSet Emulator')
560               
561               
562                for mindset_device in mindset_devices:
563                        self.comboBoxDeviceSelect.addItem(mindset_device)
564               
565               
566                #self.pushButtonBluetoothSearch.setText('Search')
567       
568       
569        ##################################################################
570       
571        def closeEvent(self, event):
572               
573                quit_message = "Are you sure you want to exit the program?"
574               
575                reply = QtGui.QMessageBox.question( \
576                           self, \
577                          'Message', \
578                           quit_message, \
579                           QtGui.QMessageBox.Yes, \
580                           QtGui.QMessageBox.No)
581               
582                if reply == QtGui.QMessageBox.Yes:
583                       
584                        if UPDATE_INTERFACE_VIA_TIMER:
585                                self.updateInterfaceTimer.stop()
586                        else:
587                                if self.thinkgearConnectClient != None:
588                                        self.thinkgearConnectClient.disconnectFromHost()
589                       
590                        if self.thinkGearConnectServer != None:
591                                self.thinkGearConnectServer.exitThread()
592                       
593                        event.accept()
594               
595                else:
596                        event.ignore()
597
598
599#####################################################################
600#####################################################################
601
602class matplotlibCanvas(FigureCanvas):
603       
604        """Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
605       
606        def __init__(self, parent=None, width=8, height=4, dpi=100, title=None):
607               
608                fig = Figure(figsize=(width, height), dpi=dpi)
609                self.axes_top = fig.add_subplot(211)
610                self.axes_bottom = fig.add_subplot(212)
611                # We want the axes cleared every time plot() is called
612                self.axes_top.hold(False)
613                self.axes_bottom.hold(False)
614               
615                if title != None:
616                        fig.suptitle(title, fontsize=12)
617               
618                FigureCanvas.__init__(self, fig)
619                self.setParent(parent)
620               
621                FigureCanvas.setSizePolicy(self,
622                                                                                        QtGui.QSizePolicy.Expanding,
623                                                                                        QtGui.QSizePolicy.Expanding)
624                FigureCanvas.updateGeometry(self)
625
626
627#####################################################################
628#####################################################################
629
630class dynamicMatplotlibCanvas(matplotlibCanvas):
631       
632        def __init__(self,  *args, **kwargs):
633               
634                matplotlibCanvas.__init__(self, *args, **kwargs)
635               
636                self.DEBUG=DEBUG
637               
638                #timer = QtCore.QTimer(self)
639                #QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"), self.update_figure)
640                #timer.start(256)
641               
642                self.update_top_frequency = \
643                   INTERFACE_RAW_EEG_UPDATE_FREQUENCY * 2
644                self.update_bottom_frequency = \
645                   INTERFACE_RAW_EEG_UPDATE_FREQUENCY
646               
647                self.values_top = []
648                self.values_bottom = []
649               
650                self.axes_top.set_xbound(0, self.update_top_frequency)
651                self.axes_top.set_ybound(-2048, 2047)
652               
653                self.axes_bottom.set_xbound(0, self.update_bottom_frequency)
654                self.axes_bottom.set_ybound(-512, 512)
655               
656                self.axes_top.set_autoscale_on(False)
657                self.axes_bottom.set_autoscale_on(False)
658       
659       
660        ##################################################################
661       
662        def update_figure(self, value):
663               
664                self.values_top.append(value)
665                self.values_bottom.append(value)
666               
667                if len(self.values_top) == self.update_top_frequency:
668                       
669                        self.axes_top.plot(range(self.update_top_frequency), \
670                                       self.values_top, \
671                                       'b-', \
672                                       scalex=False, \
673                                       scaley=False)
674                       
675                        self.draw()
676                       
677                        self.values_top = []
678               
679               
680                if len(self.values_bottom) == self.update_bottom_frequency:
681                       
682                        self.axes_bottom.plot(range(self.update_bottom_frequency), \
683                                       self.values_bottom, \
684                                       'r-', \
685                                       scalex=False, \
686                                       scaley=False)
687                       
688                        self.draw()
689                       
690                        self.values_bottom = []
691       
692       
Note: See TracBrowser for help on using the repository browser.