def start_q_watcher(app, emu_window, proc_comms_q_to_em, proc_comms_q_from_em): # need to spawn a worker thread that watches the proc_comms_q # need to seperate queue function from queue thread # http://stackoverflow.com/questions/4323678/threading-and-signals-problem # -in-pyqt q_watcher = QueueWatcher(app, emu_window, proc_comms_q_to_em, proc_comms_q_from_em) q_watcher_thread = QThread() q_watcher.moveToThread(q_watcher_thread) q_watcher_thread.started.connect(q_watcher.check_queue) # now that we've set up the thread, let's set up rest of signals/slots q_watcher.set_out_enable.connect(emu_window.set_output_enable) q_watcher.set_out_disable.connect(emu_window.set_output_disable) q_watcher.get_in.connect(emu_window.get_input) q_watcher.get_out.connect(emu_window.get_output) emu_window.send_output.connect(q_watcher.send_get_out_pin_result) emu_window.send_input.connect(q_watcher.send_get_in_pin_result) emu_window.interrupt_flagger.connect(q_watcher.handle_interrupt) # not sure why this doesn't work by connecting to q_watcher_thread.quit def about_to_quit(): q_watcher_thread.quit() app.aboutToQuit.connect(about_to_quit) q_watcher_thread.start()
def _refresh(self): 'Refresh the list of Computers' self._btnRefresh.setEnabled(False) self._btnRefresh.setText('Scanning...') self._model.clear() typ = self.wizard().field('type') if typ == len(ComputerTypes): # Custom Computer Type didx = self.wizard().field('driver') drvr = list_drivers().keys()[didx] dopt = self.wizard().field('driveropt') else: # Predefined Computer Type drvr = ComputerTypes[typ]['driver'] dopt = ComputerTypes[typ]['driveropt'] dclass = list_drivers()[drvr]['class'] doptions = [] if dopt == '' else dopt.split(':') thread = QThread(self) #FIXME: ZOMG HAX: Garbage Collector will eat DiscoveryWorker when moveToThread is called #NOTE: Qt.QueuedConnection is important... self.worker = None self.worker = DiscoveryWorker(dclass, doptions) self.worker.moveToThread(thread) thread.started.connect(self.worker.start, Qt.QueuedConnection) self.worker.foundDevice.connect(self._model.addItem, Qt.QueuedConnection) self.worker.finished.connect(self._discoverFinished, Qt.QueuedConnection) self.worker.finished.connect(self.worker.deleteLater, Qt.QueuedConnection) self.worker.finished.connect(thread.deleteLater, Qt.QueuedConnection) thread.start()
def __init__(self, patches, db, parent=None): QThread.__init__(self, parent) self.logger = logging.getLogger(__name__) self.process = None self.patches = patches self.parentDb = db
def __init__(self, instruments, name=None, settings=None, log_output=None, timeout=1000000000): self._recording = False self._timeout = timeout Script.__init__(self, name, settings, instruments, log_output=log_output) QThread.__init__(self) self.sweeper = self.instruments['zihf2'].daq.sweep(self._timeout) self.sweeper.set('sweep/device', self.instruments['zihf2'].device) self.data = deque() # todo: clean this up! and plot data in gui! self._sweep_values = { 'frequency': [], 'x': [], 'y': [], 'phase': [], 'r': [] }.keys()
def __init__(self, quitNetclient, name="NetClient"): # Call the thread's constructor QThread.__init__(self) # Initialize the net client. Variables to keep track of glance counts self.On = True # self.glance = [] # self.frame = [] self.oneCount = 0 self.zeroCount = 0 self.maxOnes = 0 self.lowCount = 0 self.warnCount = 0 self.dangerCount = 0 self.resetCount = 0 # self.duration = [] # self.listOfDict = [] # Not sure if this is going to work. This might not even be used... self.usage = __doc__ self.parser = optparse.OptionParser(self.usage) self.options, self.args = self.parser.parse_args() quitNetclient.connect(self.exitAll, Qt.QueuedConnection)
def testQThreadReceiversExtern(self): #QThread.receivers() - Inherited protected method obj = QThread() self.assertEqual(obj.receivers(SIGNAL('destroyed()')), 0) QObject.connect(obj, SIGNAL("destroyed()"), self.cb) self.assertEqual(obj.receivers(SIGNAL("destroyed()")), 1)
def __init__(self, inp=None, dur=None, thr_counter=0): QThread.__init__(self) self.inp = inp self.dur = dur self.outp = None self.abo = None self.thr_counter = thr_counter
def __init__(self): QThread.__init__(self) Bin.exporter = JupiterExporter() BinPacking.bin_packing_progress = self self.directory = None self.images = [] self.method = BinPackingThread.METHODS[0] self.bin_size = BinPackingThread.SIZES[0] self.bin_parameter = { "next_fit_shelf": {}, "first_fit_shelf": { "selection_variant": FirstFitShelfBin.BEST_VARIANTS, "selection_heuristic": FirstFitShelfBin.SHORT_SIDE_FIT, }, "guillotine": { "selection_variant": GuillotineBin.BEST_VARIANTS, "selection_heuristic": GuillotineBin.SHORT_SIDE_FIT, "split_rule": Rect.RULE_SAS, }, "max_rects": {}, }
def __init__(self): QThread.__init__(self) self.camera = CameraFixe() self.imageCount = 1 self.nombreDImage = 3 self.nombreDeForme = 4 self.localisationIles = LocalisationIle() self.localisationRobot = LocalisationRobot() self.localisationRepere = LocalisationRepere() self.localisationTresor = LocalisationTresor() self.afficheurImage = AfficheurImage() self.couleurCarreTrouvee = "" self.xPositionCarreTrouvee = 0 self.yPositionCarreTrouvee = 0 self.couleurTriangleTrouvee = "" self.xPositionTriangleTrouvee = 0 self.yPositionTriangleTrouvee = 0 self.couleurCercleTrouvee = "" self.xPositionCercleTrouvee = 0 self.yPositionCercleTrouvee = 0 self.couleurPentagoneTrouvee = "" self.xPositionPentagoneTrouvee = 0 self.yPositionPentagoneTrouvee = 0 self.xPositionRobotTrouvee = 0 self.yPositionRobotTrouvee = 0 self.carreIndex = 0 self.triangleIndex = 0 self.cercleIndex = 0 self.pentagoneIndex = 0 self.detectionIlesTimeout = 10 self.ratioMaximum = 0.14 self.listeFormesThread = [] self.listeCouleursThread = [] self.listePositionsThread = [] self.positionRobotThread = [] self.conteurDetectionIles = 0 self.conteurDetectionTresor = 0 self.conteurDetectionRepere = 0 self.time = None self.timeImage = time.time() self.estVerouillee = False self.sauvegardePath = "C:\Users\phili_000\Desktop\Design 3\Design3\Code\Projet\photos\\table_iles_robot_MOD.jpg" self.photo = None self.reset = False self.startCycle = False
def reset (self): self.serial.setDTR (False) self.serial.setRTS (False) QThread.msleep (250) self.serial.setDTR (True) self.serial.setRTS (True) QThread.msleep (50)
def __init__(self): QThread.__init__(self) self.code = "" self.carte = Carte() self.planification = Cheminement(self.carte) self.voltageRestant = "" self.ileCible = -1 self.positionTresor = [] self.destination = [] self.pause = True self.reset = False self.startCycle = False self.demiCercle = 180 self.tempAttenteRotation = 9 self.delaiAjustement = 4.5 self.metreSeconde = 15 self.metre = 100 self.actionPrecedente = "" self.actionCourrante = "" self.nouvelleAction = False self.finCycle = False self.connected = False self.noPathFound = False self.aIle = False self.diametreIle = 2.125 self.deltaPosition = 15 self.deltaAngle = 4 self.deltaDiametreIle = 0.125
def __init__( self, account, call, #dbus_handler, ): """ account: An account. call is one of 'HomeTimeline': Fetch the home time line 'Mentions': Fetch user mentions 'DMs': Fetch direct messages 'Search:*': Fetch search results where * is the terms to search for 'RetrieveLists': Retrive lists 'List:*:*': The first * should be replace with the user and the second with the id 'Near:*:*': Fetch tweets near (1km) a the specified location. The first start is the the first geocode and the second * is the second geocode. """ QThread.__init__(self) self.account = account self.call = call #self.dbus_handler = dbus_handler socket.setdefaulttimeout(60)
def __init__(self): QThread.__init__(self) self.running = True self.queue = queue.Queue() # If we have internet connetction we can receive dat from server self.data_from_server = True # Offsets period self.p_offsets = config['p_offsets'] # Offsets stack size self.n_samples = config['o_buffer'] # Offsets list self.offsets = None # Socket self.sock_con = None # Graph density. Send to pipeline every n-th sample self.density = calculateDensity(config['time_axe_range']) # self.calculateDensity(2) # Data server if self.data_from_server: self.host = config['host'] # self.host = 'localhost' self.port = config['port']
def _btnTransferClicked(self): 'Transfer Dives' idx = self._cbxComputer.currentIndex() dc = self._cbxComputer.itemData(idx, Qt.UserRole+0) if self._logbook.session.dirty: print "Flushing dirty session" self._logbook.rollback() self._txtLogbook.setEnabled(False) self._btnBrowse.setEnabled(False) self._cbxComputer.setEnabled(False) self._btnAddComputer.setEnabled(False) self._btnRemoveComputer.setEnabled(False) self._btnTransfer.setEnabled(False) self._btnExit.setEnabled(False) self._txtStatus.clear() thread = QThread(self) #FIXME: ZOMG HAX: Garbage Collector will eat TransferWorker when moveToThread is called #NOTE: Qt.QueuedConnection is important... self.worker = None self.worker = TransferWorker(dc) thread.started.connect(self.worker.start, Qt.QueuedConnection) self.worker.moveToThread(thread) self.worker.finished.connect(self._transferFinished, Qt.QueuedConnection) self.worker.finished.connect(self.worker.deleteLater, Qt.QueuedConnection) self.worker.finished.connect(thread.deleteLater, Qt.QueuedConnection) self.worker.progress.connect(self._transferProgress, Qt.QueuedConnection) self.worker.started.connect(self._transferStart, Qt.QueuedConnection) self.worker.status.connect(self._transferStatus, Qt.QueuedConnection) thread.start()
def __init__(self, scripts, name=None, settings=None, log_output=None, timeout=1000000000): self._recording = False self._timeout = timeout Script.__init__(self, name, settings, scripts=scripts, log_output=log_output) QThread.__init__(self) self.data = deque() # todo: clean this up! and plot data in gui! self._sweep_values = { 'frequency': [], 'x': [], 'y': [], 'phase': [], 'r': [] }.keys()
def onLogin(self, host, username, passwd, ssl): """ Slot. Triggers a log in request to the server. :param host: Indicates the hostname of the FTP server :param username: Username to log in into the FTP server :param passwd: Password to log in into the FTP server :param ssl: Indicates whether the FTP needs SSL support """ self.sync = Sync(host, ssl) self.syncStarted.connect(self.sync.initQueue) self.sync.server.downloadProgress.connect(self.onDownloadProgress) self.sync.server.uploadProgress.connect(self.onUploadProgress) self.sync.server.fileEvent.connect(self.onFileEvent) self.sync.server.badFilenameFound.connect(self.badNameWarning) self.sync.server.loginCompleted.connect(self.onLoginCompleted) self.sync.server.fileEventCompleted.connect(self.onFileEventCompleted) self.sync.server.ioError.connect(self.onIOError) # Added by Si self.sync.server.textStatus.connect(self.setStatus) self.sync.statusChanged.connect(self.setStatus) self.loginRequested.connect(self.sync.server.onLogin) self.syncThread = QThread() self.sync.moveToThread(self.syncThread) self.syncThread.start() QApplication.instance().lastWindowClosed.connect(self.syncThread.quit) self.loginRequested.emit(username, passwd)
def start_q_watcher(app, emu_window, proc_comms_q_to_em, proc_comms_q_from_em): # need to spawn a worker thread that watches the proc_comms_q # need to seperate queue function from queue thread # http://stackoverflow.com/questions/4323678/threading-and-signals-problem # -in-pyqt q_watcher = QueueWatcher( app, emu_window, proc_comms_q_to_em, proc_comms_q_from_em) q_watcher_thread = QThread() q_watcher.moveToThread(q_watcher_thread) q_watcher_thread.started.connect(q_watcher.check_queue) # now that we've set up the thread, let's set up rest of signals/slots q_watcher.set_out_enable.connect(emu_window.set_output_enable) q_watcher.set_out_disable.connect(emu_window.set_output_disable) q_watcher.get_in.connect(emu_window.get_input) q_watcher.get_out.connect(emu_window.get_output) emu_window.send_output.connect(q_watcher.send_get_out_pin_result) emu_window.send_input.connect(q_watcher.send_get_in_pin_result) emu_window.interrupt_flagger.connect(q_watcher.handle_interrupt) # not sure why this doesn't work by connecting to q_watcher_thread.quit def about_to_quit(): q_watcher_thread.quit() app.aboutToQuit.connect(about_to_quit) q_watcher_thread.start()
def __init__(self, instruments, name = None, settings = None, log_output = None): self._recording = False Script.__init__(self, name, settings, instruments, log_output = log_output) QThread.__init__(self) self.data = deque()
def __init__(self): QThread.__init__(self) self.grblWriter = None self.gcode = None self.stopFlag = False self.pauseFlag = False self.currentLine = 0 self.waitForPause = False
def __init__(self, todo=None, dur=None, ip=None, vidl=None): QThread.__init__(self) self.todo = todo self.dur = dur self.ip = ip self.vidl = vidl self.outp = None self.abo = None
def __init__(self, maximum, parent=None): QThread.__init__(self, parent) self.maximum = maximum # this semaphore is used to stop the thread from outside. As long # as the thread is permitted to run, it has yet a single resource # available. If the thread is stopped, this resource is acquired, # and the thread breaks its counting loop at the next iteration. self._run_semaphore = QSemaphore(1)
def __init__(self, user, parent=None): QThread.__init__(self, parent) self.exiting = False self.refreshed = MySignal() self.dumpuser = MySignal() self.newcourses = CoursesSignal() self.removable = CoursesSignal() self.user = user
def __init__(self, *params): QThread.__init__(self) self.parms = params self.ret_code = None self.output = StringIO() self.procs = [] self.procs_str = '' Logger.getLoggerFor(self.__class__)
def __init__(self, network, logLevel=None, **kwargs): assert (isinstance(network, Network)) self._network = network self.sim_start = self.sim_end = None self.stepsLeft = 0 self.logger = logging.getLogger('pymote.simulation') self.logger.level = logLevel or logging.DEBUG QThread.__init__(self)
def __init__(self, port): QThread.__init__(self) self._port = port self._serial = None self._parser = Parser() self._cancel = False self._timeout = None
def __init__(self): QThread.__init__(self) self.__service = RunDefService() self.__pid = None self.__id = None
def __init__(self, monitorable, args=(), kwargs=None): QThread.__init__(self) self._monitorable = monitorable self._args = args if kwargs is None: kwargs = {} self._kwargs = kwargs self._is_cancelled = False
def __init__(self): QThread.__init__(self) self.grblWriter = None self.gcode = None self.stopFlag = False self.pauseFlag = False self.currentLine = 0 self.waitForPause = False self.errorStatus = False
def __init__(self, script): """ This is a wrapper for scripts that are not QThread, to execute them on a different thread than the gui Args: script: script to be executed """ self.script = script QThread.__init__(self)
def __init__(self, network, logLevel=None, **kwargs): assert(isinstance(network, Network)) self._network = network self.stepsLeft = 0 self.logger = logging.getLogger('pymote.simulation') self.logger.level = logLevel or logging.DEBUG self.logger.debug('Simulation %s created successfully.' % (hex(id(self)))) QThread.__init__(self)
def __init__(self, network, logLevel=None, **kwargs): assert (isinstance(network, Network)) self._network = network self.stepsLeft = 0 self.logger = logging.getLogger('pymote.simulation') self.logger.level = logLevel or logging.DEBUG self.logger.debug('Simulation %s created successfully.' % (hex(id(self)))) QThread.__init__(self)
def __init__(self, instruments, scripts, name = None, settings = None, log_output = None): """ Example of a script that emits a QT signal for the gui Args: name (optional): name of script, if empty same as class name settings (optional): settings for this script, if empty same as default settings """ Script.__init__(self, name, settings = settings,scripts =scripts, instruments = instruments, log_output = log_output) QThread.__init__(self)
def Record(self): if self.action_Record.isChecked(): if not self.acquiring: self.workerThread = QThread(self) self.workerThread.start() self.worker = Worker(self) self.worker.moveToThread(self.workerThread) try: self.start_rec.disconnect() except: pass while 1: try: self.sock.send('StartAcquisition') self.sock.recv() except: continue break while 1: try: self.sock.send('StartRecord') self.sock.recv() except: continue break self.vidbuffer = [] self.start_rec.connect(self.worker.acquire) self.recording = True self.start_rec.emit('start!') else: while 1: try: self.sock.send('StartRecord') self.sock.recv() except: continue break self.vidbuffer = [] self.recording = True record_icon = self.style().standardIcon(QStyle.SP_DialogNoButton) #set the icon for the action self.action_Record.setIcon(record_icon) self.action_Record.setEnabled(False) self.action_Acq.setChecked(False) self.action_Acq.setEnabled(True)
def __init__(self, name, readTimeout=1000, dev = None, parent=None): Keithley.__init__(self,dev) QThread.__init__(self) self.name = name self.readTimeout = readTimeout self.connectInstrument() self.selectCurrent() self.zeroCorrect() self.sr = SignalReceiver(self) self.sr.moveToThread(self)
def __init__(self, url): QThread.__init__(self) self.url = url self.new_version = None self.frozenapp = esky.Esky(sys.executable, self.url) try: log.Debug('Checking for new version at {0}'.format(self.url)) self.new_version = self.frozenapp.find_update() except Exception, e: log.Error(str(e))
def __init__(self, name=None, settings=None, log_output=None): """ Example of a script that emits a QT signal for the gui Args: name (optional): name of script, if empty same as class name settings (optional): settings for this script, if empty same as default settings """ Script.__init__(self, name, settings, log_output=log_output) # QtCore.QThread.__init__(self) QThread.__init__(self)
def __init__(self, app, *args, **kwargs): QThread.__init__(self, *args, **kwargs) self.app = app self.status = STATUS_NONE self.last_sync = datetime.now() self.timer = QTimer() self.timer.timeout.connect(self.sync) self.update_timer() self.wait_condition = QWaitCondition() self.mutex = QMutex()
def __init__(self, cmd, img): """Initialize executor. Args: cmd -- command to execute (str) img -- path to resulting image (the renderer output) (str) """ super().__init__(QCoreApplication.instance()) self.thread = QThread() self.worker = Worker(cmd, img) self.thread.setObjectName("fcd-renderexec")
def __init__(self, path=None, db=[], key=None): QThread.__init__(self) self.path = path self.session = db[2] self.File = db[3] self.Folder = db[4] self.key = key self.estmf = self.session.query(self.Folder).count() self.estm = self.session.query(self.File).count() self.abo = None self.err = None
def __init__(self, netclient, parID_Signal, name="Receiver"): # Call the thread's constructor QThread.__init__(self) # Set the thread's data self.name = name # Initialize the variables self.netFileData = [] self.recFileData = [] self.receiverData = { "FRAME": '0', "GAZE": '0', "OneCount": '0', "ZeroCount": '0', "MaxCount": '0', "WarnCount": '0', "DangerCount": '0', "RstCount": '0', "GlanceCount": '0', "LowCount": '0' } self.frameValue = 0 self.logStream = 0 self.laneDepart = 0.0 self.laneDeviation = 0.0 self.distance = 0.0 self.bumperTime = 0.0 self.bumperDist = 0.0 self.collisionTime = 0.0 self.leadVehVel = 0.0 self.numCollision = 0 self.chassisAccel = 0.0 self.participantID = 'Default' # Connecting to the netclient signal netclient.receiverDataSignal.connect(self.setReceiverVars, Qt.QueuedConnection) parID_Signal.connect(self.setReceiverParID, Qt.QueuedConnection) try: # Create a new socket, use IPv4 and UDP # Then bind the socket to localhost and the port self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.socket.bind(('', 1224)) except socket.error as err: # Could not create the socket, bind it, or listen on the port. # Print the error message print "Could not create the socket:", err self.socket = None
def __init__(self): QThread.__init__(self) self.code = "" self.carte = Carte() self.planification = Cheminement(self.carte) self.voltageRestant = 0 self.ileCible = -1 self.positionTresor = [] self.destination = [] self.pause = True self.reset = False
def __init__(self, parameters=None): QThread.__init__(self) self.interrupt_flag = False self.pause_flag = False self.pause_time = 10 if parameters is None: self.parameters = None else: self.set_parameters(parameters)
def __init__(self, *args, **kwargs): QThread.__init__(self, *args, **kwargs) self.app = AppClass.instance() self.status = STATUS_NONE self.last_sync = datetime.now() self.update_count = 0 self.timer = QTimer() self.timer.timeout.connect(self.sync) self.update_timer() self.wait_condition = QWaitCondition() self.mutex = QMutex()
def __init__(self, name=None, target=None, args=None, kwargs=None): self._target = target if args is None: args = tuple() if kwargs is None: kwargs = dict() self._args = args self._kwargs = kwargs QThread.__init__(self) self.setObjectName(name)
def __init__(self, scripts, name = None, settings = None, log_output = None, timeout = 1000000000): self._recording = False self._timeout = timeout Script.__init__(self, name, settings, scripts = scripts, log_output = log_output) QThread.__init__(self) self.data = deque() # todo: clean this up! and plot data in gui! self._sweep_values = {'frequency' : [], 'x' : [], 'y' : [], 'phase': [], 'r':[]}.keys()
def __init__(self): QThread.__init__(self) self.running = True self.data_from_server = False self.queue = queue.Queue() # Data server if self.data_from_server: self.host = '188.244.51.15' self.port = 5000
def __init__(self): QThread.__init__(self) self.killMe = False pygame.init() pygame.joystick.init() #print "Number of joysticks:", pygame.joystick.get_count() if pygame.joystick.get_count() == 0: print "No Joystick available" self.joystick = None else: self.joystick = pygame.joystick.Joystick(0) self.joystick.init()
def __init__(self, *args, **kwargs): QThread.__init__(self, *args, **kwargs) self.input_buffer = "" # по этой ссылке храниться все входящие данные от последовательного порта self.out_cmd_queue = Queue( ) # в очередь кладутся словари формата {"command": комманда, "expected_regexp": RegExp ожидаемого ответа, # "additionTimeout": дополнительный таймут между ответами, по умоличани это 0} self.standart_timeout = 0.1 # self._config_object = config_object self.last_answer = None # последний ответ, на случай если произошла ошибка в процессе запросов self.last_request = None # последний запрос, на случай если произошла ошибка в процессе запросов self.debug_msg = None # debug сообщение, в случае неудачного запроса self.steps = 0 # шаги, которые нужно выполнить self.total_cmd_commands = 0 # полное количество последовательных команд
class RendererExecutorGui(QObject): """A class to execute a rendering engine in Graphical User Interface mode. This class is designed to run a renderer in a separate thread, keeping GUI responsive. Meanwhile, stdout/stderr are piped to FreeCAD console, in such a way it is possible to follow the evolution of the rendering. To achieve that, renderer is executed in a separate thread, using **QThread**. Nota: in this class, it is assumed that Qt GUI is up, so it is not tested anywhere. """ def __init__(self, cmd, img): """Initialize executor. Args: cmd -- command to execute (str) img -- path to resulting image (the renderer output) (str) """ super().__init__(QCoreApplication.instance()) self.thread = QThread() self.worker = Worker(cmd, img) self.thread.setObjectName("fcd-renderexec") def start(self): """Start executor.""" # Move worker to thread self.worker.moveToThread(self.thread) # Connect signals and slots # pylint: disable=no-member self.thread.started.connect(self.worker.run) self.worker.finished.connect(self.thread.quit) self.worker.finished.connect(self.worker.deleteLater) self.worker.finished.connect(self.thread.exit) self.thread.finished.connect(self.thread.deleteLater) # self.thread.finished.connect(lambda: print("Thread finished")) # Dbg self.worker.result_ready.connect(display_image) # Start the thread self.thread.start() def join(self): """Join thread. This method is provided for consistency with CLI executor, but it should not be of much use in GUI context. """ loop = QEventLoop() self.thread.finished.connect(loop.quit) # pylint: disable=no-member if not self.thread.isFinished(): loop.exec_(flags=QEventLoop.ExcludeUserInputEvents)
def __init__(self, probes, refresh_interval = 0.5): """ probes: dictionary of probes where keys are names and values are Probe objects refresh_interval: time between reads in s """ assert isinstance(probes, dict) assert isinstance(refresh_interval, float) self.refresh_interval = refresh_interval self._running = False self.probes = probes self.probes_values = None QThread.__init__(self)
def __init__(self, instruments, name = None, settings = None, log_output = None, timeout = 1000000000): self._recording = False self._timeout = timeout Script.__init__(self, name, settings, instruments, log_output = log_output) QThread.__init__(self) self.sweeper = self.instruments['zihf2'].daq.sweep(self._timeout) self.sweeper.set('sweep/device', self.instruments['zihf2'].device) self.data = deque() # todo: clean this up! and plot data in gui! self._sweep_values = {'frequency' : [], 'x' : [], 'y' : [], 'phase': [], 'r':[]}.keys()
def __init__(self, dir_from, dir_to, some): QThread.__init__(self, None) box = Communicate() box.mBox.connect(m_box_exec) try: self.processo = subprocess.Popen( ["rsync", "-av", "--progress", "--size-only", "%s" % dir_from, "%s" % dir_to], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) self.some = some except Exception as e: box.mBox.emit(u"Error invoking rsync, please check if you have rsync installed.\n:= %s" % e.message) print(e)