コード例 #1
0
    def getSettings(self, fileName):
        """
        Loads settings from the first lines
        of the data file
        """
        s = SessionSettings()  # template
        d = s.__dict__  # get all the fields needed

        f = open(fileName, 'r')

        for line in f:
            if line[0] is '#':
                a = line[2:].strip().split(",")
                if len(a) > 1 and a[0] in d:
                    d[a[0]] = a[1]

        s.sanitise()
        return s
コード例 #2
0
    def getSettings(self, fileName):
        """
        Loads settings from the first lines
        of the data file
        """
        s = SessionSettings() # template
        d = s.__dict__ # get all the fields needed

        f = open(fileName, 'r')

        for line in f:
            if line[0] is '#':
                a = line[2:].strip().split(",")
                if len(a) > 1 and a[0] in d:
                    d[a[0]] = a[1]

        s.sanitise()
        return s
コード例 #3
0
ファイル: session.py プロジェクト: kieranrcampbell/mallard
    def __init__(self, globalSession, errorFnc):
        self.settings = SessionSettings()
        self.fileManager = FileManager(self.settings)
        self.dmanager = DataManager(self.settings, 
                                    globalSession,
                                    errorFnc) 

        self.needsSaved = False # captured data that needs saved
        
        # method that updates statusbar
        self.globalSession = globalSession
        
        # method displays error popup
        self.errorFnc = errorFnc

        # if we load in a session from file, we don't want to
        # wipe it over in a new capture, so we set the
        # read only flag to true
        self.readOnly = False 

        self.running = True
        self.dmanager.running = self.running
コード例 #4
0
ファイル: session.py プロジェクト: kieranrcampbell/mallard
class CaptureSession:
    """
    Interfaces between card, gui and data buffers
    """    
    def __init__(self, globalSession, errorFnc):
        self.settings = SessionSettings()
        self.fileManager = FileManager(self.settings)
        self.dmanager = DataManager(self.settings, 
                                    globalSession,
                                    errorFnc) 

        self.needsSaved = False # captured data that needs saved
        
        # method that updates statusbar
        self.globalSession = globalSession
        
        # method displays error popup
        self.errorFnc = errorFnc

        # if we load in a session from file, we don't want to
        # wipe it over in a new capture, so we set the
        # read only flag to true
        self.readOnly = False 

        self.running = True
        self.dmanager.running = self.running


    def setName(self, name):
        """
        Change the name of the current session
        """
        self.settings.name = name

    def getName(self):
        return self.settings.name


    def loadSettings(self, path):
        """
        Loads just settings from file
        """
        self.settings = self.fileManager.getSettings(path)
        self.settings.filename = ""


    def saveSession(self):
        """
        Save session to current filename
        """
        self.fileManager.writeCapture(self.dmanager.getRawCountData(),
                                      self.dmanager.getRawAIData(),
                                      self.dmanager.getCombinedData())
        self.needsSaved = False


    def saveSessionAs(self, path):
        """
        Save session to new filename
        """
        self.settings.filename = path
        self.saveSession()

    def startCapture(self):
        """
        Need to reinitialise dmanager. Can't rely on
        the fact that self.settings is a pointer as
        need to recalculate stuff like voltage intervals 
        """
        self.settings.sanitise()
        
        # reinitialise data manager to do things like voltage calcs
        self.dmanager.initialise(self.settings, 
                                 self.globalSession,
                                 self.errorFnc) 

        # queue for passing data between acquisition and dmanager
        q = Queue()

        # set up acquisition process and start
        self.captureProcess = Process(target=acquire,
                                      args=(self.settings, 
                                            q, self.running))
        self.captureProcess.start()

        # set up data capture process and start
        self.dAcqThread = Thread(target=self.dmanager.dataCallback, 
                                 args=(q,))
        self.dAcqThread.start()

        self.needsSaved = True

    def registerGraphManager(self, graphManager):
        self.dmanager.registerGraphManager(graphManager)


    def getRange(self):
        """
        Returns the range required for gauge
        """
        self.settings.sanitise()
        return self.settings.scans

        
    def clearGraph(self):
        self.dmanager.graphManager.clearPlot()

    def killCapture(self):
        """
        Kills running capture. Program's behaviour
        may become undefined
        """
        try:
            self.captureProcess.terminate()
        except:
            self.errorFnc("Could not stop capture process")

        self.dAcqThread._Thread__stop()
        self.clearDevice()

    def stopCapture(self):
        """
        Stops running capture at end of scan
        (bit of cheat, just deletes the scan before)
        """
        self.running = False
        self.dmanager.running = False
        try:
            self.captureProcess.terminate()
        except:
            self.errorFnc("Could not stop capture process")


    def isCapturing(self):
        """
        Returns true if capturing is in progress
        """
        return self.captureProcess.is_alive()

    def setGlobalSettings(self, settings):
        self.globalSettings = settings