def __init__( self, dequePLOT, dequeIN, dequeOUT, port_num='/dev/ttyUSB0', #port_num='/dev/ttyACM0', port_baud=115200, port_stopbits=serial.STOPBITS_ONE, port_parity=serial.PARITY_NONE, port_timeout=0.1, parent=None): QtCore.QThread.__init__(self) self.daemon = True self.mutex = QMutex() self.serial_port = None self.serial_arg = dict(port=port_num, baudrate=port_baud, stopbits=port_stopbits, parity=port_parity, timeout=port_timeout) self.signal = QtCore.SIGNAL("signal") self.CONTENEDORplot = dequePLOT self.dequeIN = dequeIN self.dequeOUT = dequeOUT
def __init__(self, Celda, FilaPlot, parent=None): # QtCore.QThread.__init__(self) super(PLOTEOTR, self).__init__() self.Celda = Celda self.CONTENEDOR = FilaPlot self.mutex = QMutex() self.Active = True
def __init__(self, parent, db): QObject.__init__(self, parent) self.internet_connection_failed = False self._parent = parent self.no_internet_msg = _('Cannot download news as no internet connection ' 'is active') self.no_internet_dialog = d = error_dialog(self._parent, self.no_internet_msg, _('No internet connection'), show_copy_button=False) d.setModal(False) self.recipe_model = RecipeModel() self.db = db self.lock = QMutex(QMutex.Recursive) self.download_queue = set([]) self.news_menu = QMenu() self.news_icon = QIcon(I('news.png')) self.scheduler_action = QAction(QIcon(I('scheduler.png')), _('Schedule news download'), self) self.news_menu.addAction(self.scheduler_action) self.scheduler_action.triggered[bool].connect(self.show_dialog) self.cac = QAction(QIcon(I('user_profile.png')), _('Add a custom news source'), self) self.cac.triggered[bool].connect(self.customize_feeds) self.news_menu.addAction(self.cac) self.news_menu.addSeparator() self.all_action = self.news_menu.addAction( _('Download all scheduled news sources'), self.download_all_scheduled) self.timer = QTimer(self) self.timer.start(int(self.INTERVAL * 60 * 1000)) self.timer.timeout.connect(self.check) self.oldest = gconf['oldest_news'] QTimer.singleShot(5 * 1000, self.oldest_check)
def __init__(self, parent=None): locale = unicode(QtCore.QLocale.system().name()) QtGui.QWidget.__init__(self, parent) self.ui = loadUi(GraphicInterface, self) self.flagVTR = False self.flagPLOTVTR = False self.Ploteo1 = self.ui.plot.addPlot( row=0, col=0, axisItems={'left': NonScientific(orientation='left')}) self.Ploteo2 = self.ui.plot.addPlot( row=1, col=0, axisItems={'left': NonScientific(orientation='left')}) self.threadPool = [] self.threadOne = [] #DatosIndependietes DatosCompartidos self.threadTwo = [] #PLOTEOTR self.mutex = QMutex() self.filaPloteo = deque(maxlen=16000) self.filaDatos = deque(maxlen=16000) self.dequeSetting = deque(maxlen=100) self.threadOne.append( DatosIndependientes.DatosCompartidos(self.dequeSetting, self.filaPloteo)) print("valor de len de thread one menos 1 es " + str(len(self.threadOne) - 1), file=log) self.threadOne[len(self.threadOne) - 1].start() self.connect(self.threadOne[len(self.threadOne) - 1], self.threadOne[len(self.threadOne) - 1].signal, self.ActualValores) self.connect(self.threadOne[len(self.threadOne) - 1], self.threadOne[len(self.threadOne) - 1].signalSingleShot, self.LlenoCamposCondGuardado) #QObject.connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType = Qt.AutoConnection) -> bool self.connect(self.threadOne[len(self.threadOne) - 1], self.threadOne[len(self.threadOne) - 1].parocelda, self.PararCelda) self.ui.BotActivo.setCheckable(True) self.ui.BotSetearC.setCheckable(True) self.ui.BotSetearV.setCheckable(True) self.ui.BotParaPlot.setCheckable(True) self.ui.AYUDA.append('<a href="ayuda/readme.html"> AYUDA </a>') self.CargoCorrecionDeI()
def shown(self): # Disable mouse handler ctx.mainScreen.dontAskCmbAgain = True ctx.mainScreen.theme_shortcut.setEnabled(False) ctx.mainScreen.ui.system_menu.setEnabled(False) # start installer thread ctx.logger.debug("Copy system thread is creating...") self.mutex = QMutex() self.wait_condition = QWaitCondition() self.queue = Queue() self.sys_copier = SystemCopy(self.queue, self.mutex, self.wait_condition, self.retry_answer) self.poll_timer.start(500) # start installer polling ctx.logger.debug("Calling SystemCopy.start...") self.sys_copier.start() ctx.mainScreen.disableNext() ctx.mainScreen.disableBack() # start 30 seconds self.timer.start(1000 * 30) self.installProgress.showInstallProgress()
def __init__(self): QtCore.QObject.__init__(self) #Read from Penning_trap_cxn_dictionaries relevant information mapping ISEG units to trap #surfaces in order to start the relevant sessions. self.trap_surfaces = iseg_controlled_trap_surfaces.keys() self.num_trap_surfs = len(self.trap_surfaces) self.INST_IDs_4_TRAP_SURFs = [ trap_surf_dict[self.trap_surfaces[i]]['INST_ID'] for i in range(len(self.trap_surfaces)) ] self.VISA_IDs_4_TRAP_SURFs = [ trap_surf_dict[self.trap_surfaces[i]]['VISA_ID'] for i in range(len(self.trap_surfaces)) ] # Setup connections to individual iseg units assigned to trap surface control self.iseg_modules = ISEG_Command(self.VISA_IDs_4_TRAP_SURFs) self.running = True self.temp_volt_dict = deepcopy(volt_config_dict) self.create_thread_shuttling() self.mutex = QMutex() self.colours = [ trap_surf_dict[c]['COLOUR'] for c in self.trap_surfaces ] self.num_completed_shuttling_cycles = 0 self.reinitialize_shuttling_sequence = True
class PLOTEOTR(pg.QtCore.QThread): newData1 = pg.QtCore.Signal(object) newData2 = pg.QtCore.Signal(object) def __init__(self, Celda, FilaPlot, parent=None): # QtCore.QThread.__init__(self) super(PLOTEOTR, self).__init__() self.Celda = Celda self.CONTENEDOR = FilaPlot self.mutex = QMutex() self.Active = True def __del__(self): self.wait( ) # This will (should) ensure that the thread stops processing before it gets destroyed. def run(self): # global CondPaBarrer # [celda, barrido (actual), Tinicio] Listax = deque(maxlen=16000) Listay = deque(maxlen=16000) print("runing start", file=log) while self.Active: time.sleep(0.01) if int(len(self.CONTENEDOR)) >= 1: #time.sleep(0.01) self.mutex.lock() separado = self.CONTENEDOR.popleft() self.mutex.unlock() if separado[0] == str(self.Celda): if separado[1] == 0 and separado[2] == 0 and separado[ 3] == 0: self.Active = False print("Parando PloteoTR", file=log) Tension = separado[2] * (0.001) Corriente = separado[3] * (0.001) Listax.append(Tension) # tension Listay.append(Corriente) # corriente data1 = Listax data2 = Listay self.newData1.emit(data1) self.newData2.emit(data2) # time.sleep(0.05) """buscar otra forma de controlarlo evitando entrar en los botones"""
def __init__(self, ISEG_VISA_IDs): QtCore.QObject.__init__(self) self.ISEG_VISA_IDs = ISEG_VISA_IDs self.num_channels = len(self.ISEG_VISA_IDs) print self.ISEG_VISA_IDs #iseg module parameters self.num_time_segs = None self.V_ramp_list_array = None self.ramp_speed_list_array = None self.tau = None self.repetition_time_delay = None self.V_initial_list = None self.V_final_list = None self.running = True self.connect(self.ISEG_VISA_IDs) self.mutex = QMutex() self.micro = 10**(-6)
def __init__(self, dequeSettings, dequePLOT, parent=None): print("[" + str(datetime.datetime.now()) + "][DCOMP] initing", file=log) self.a = DatosCelda("a") self.b = DatosCelda("b") #2 self.c = DatosCelda("c") #3 self.d = DatosCelda("d") #4 self.e = DatosCelda("e") #5 self.f = DatosCelda("f") #6 self.g = DatosCelda("g") #7 self.h = DatosCelda("h") #8 self.i = DatosCelda("i") #9 self.j = DatosCelda("j") #10 self.k = DatosCelda("k") #11 self.l = DatosCelda("l") #12 self.m = DatosCelda("m") #13 self.n = DatosCelda("n") #14 self.o = DatosCelda("o") #15 self.p = DatosCelda("p") #16 QtCore.QThread.__init__(self) self.mutex = QMutex() self.daemon = True self.signal = QtCore.SIGNAL("realTimeData") self.signalSingleShot = QtCore.SIGNAL("UIConditions") self.parocelda = QtCore.SIGNAL("parocelda") self.celdaEnTiempoReal = None self.celdaCondUI = None self.celdaPLOTTR = None """DEQUES de comunicacion""" self.dequeSettings = dequeSettings #desde UI self.dequePLOT = dequePLOT #hacia UI?? self.dequeOUT = deque(maxlen=16000) #seteos de celdas a puerto self.dequeIN = deque(maxlen=16000) #desde puerto crudo """""" #print( "arranco thread de lectura desde DatosIndependientes", file=log) self.PoolThread.append( ProcesoPuerto.LECTURA(self.dequePLOT, self.dequeOUT, self.dequeIN))
def __init__(self): QtCore.QObject.__init__(self) self.egun1_surfs_iseg = iseg_controlled_egun_surfaces.keys() self.egun1_surfs_MX100TP = MX100TP_controlled_egun_surfaces.keys() self.egun1_surfs_all = self.egun1_surfs_MX100TP + self.egun1_surfs_iseg self.INST_IDs_iseg_egun1 = [ egun1_surf_dict[self.egun1_surfs_iseg[i]]['INST_ID'] for i in range(len(self.egun1_surfs_iseg)) ] self.VISA_IDs_iseg_egun1 = [ egun1_surf_dict[self.egun1_surfs_iseg[i]]['VISA_ID'] for i in range(len(self.egun1_surfs_iseg)) ] self.INST_IDs_MX100TP_egun1 = [ egun1_surf_dict[self.egun1_surfs_MX100TP[i]]['INST_ID'] for i in range(len(self.egun1_surfs_MX100TP)) ] self.VISA_IDs_MX100TP_egun1 = [ egun1_surf_dict[self.egun1_surfs_MX100TP[i]]['VISA_ID'] for i in range(len(self.egun1_surfs_MX100TP)) ] self.VISA_ID_MX100TP_egun1 = self.VISA_IDs_MX100TP_egun1[0] # create iseg modele objects for egun control self.iseg_modules_egun1 = ISEG_Command(self.VISA_IDs_iseg_egun1) # create MX100TP modele object for egun control self.MX100TP_module_egun1 = MX100TP_Command(self.VISA_ID_MX100TP_egun1) self.execute_default_settings() self.running = True self.update_MX100TP_voltages = None self.temp_volt_dict = None self.mutex = QMutex()
def __init__(self, conf): self.path = conf.getAttribute("loc") self.max_wrong = int(conf.getAttribute("max_fails")) temp_re = re.compile(conf.getAttribute("re")) if (not re): temp_re = ".*" self.re = re.compile(temp_re) self.log = logging.getLogger("umati.UmatiUserDirectory.UserDirectory") if (self.path == ""): self.path = UserDirectory.FILE_LOC if (os.path.exists(self.path)): p = pickle.Unpickler(open(self.path, 'rb')) self.db = p.load() else: self.db = {} self.__lock = QMutex() self.__last_updated = time.time() self.__hasChanged = False self.updater = UpdaterThread(self) self.updater.start()
class Myform(QtGui.QMainWindow): def __init__(self, parent=None): locale = unicode(QtCore.QLocale.system().name()) QtGui.QWidget.__init__(self, parent) self.ui = loadUi(GraphicInterface, self) self.flagVTR = False self.flagPLOTVTR = False self.Ploteo1 = self.ui.plot.addPlot( row=0, col=0, axisItems={'left': NonScientific(orientation='left')}) self.Ploteo2 = self.ui.plot.addPlot( row=1, col=0, axisItems={'left': NonScientific(orientation='left')}) self.threadPool = [] self.threadOne = [] #DatosIndependietes DatosCompartidos self.threadTwo = [] #PLOTEOTR self.mutex = QMutex() self.filaPloteo = deque(maxlen=16000) self.filaDatos = deque(maxlen=16000) self.dequeSetting = deque(maxlen=100) self.threadOne.append( DatosIndependientes.DatosCompartidos(self.dequeSetting, self.filaPloteo)) print("valor de len de thread one menos 1 es " + str(len(self.threadOne) - 1), file=log) self.threadOne[len(self.threadOne) - 1].start() self.connect(self.threadOne[len(self.threadOne) - 1], self.threadOne[len(self.threadOne) - 1].signal, self.ActualValores) self.connect(self.threadOne[len(self.threadOne) - 1], self.threadOne[len(self.threadOne) - 1].signalSingleShot, self.LlenoCamposCondGuardado) #QObject.connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType = Qt.AutoConnection) -> bool self.connect(self.threadOne[len(self.threadOne) - 1], self.threadOne[len(self.threadOne) - 1].parocelda, self.PararCelda) self.ui.BotActivo.setCheckable(True) self.ui.BotSetearC.setCheckable(True) self.ui.BotSetearV.setCheckable(True) self.ui.BotParaPlot.setCheckable(True) self.ui.AYUDA.append('<a href="ayuda/readme.html"> AYUDA </a>') self.CargoCorrecionDeI() def inicioVOC(self): Celda = unicode(self.ui.cmbCelV.currentText()) Promedio = float(self.ui.cmbPromV.currentText()) T_Max = int(self.ui.LinEdTiemV.text()) print("[" + str(datetime.datetime.now()) + "][UICICL] datos " + str([ "SETV", str(Celda), 1, 999999, -999999, T_Max, 0, Promedio, False ]), file=log) self.mutex.lock() self.dequeSetting.append([ "SETV", str(Celda), 1, 999999, -999999, T_Max, 0, Promedio, False ]) self.mutex.unlock() self.inicio(Celda) def inicioCiclado(self): # seteo valores para el proceso Celda = self.ui.cmbCelC.currentText() Promedio = float(self.ui.cmbProm.currentText()) Corriente = int(self.ui.LinEdCorri.text()) Ciclos = int(self.ui.LinEdCiclos.text()) V_lim_inf = float(self.ui.LinEdVLInf.text()) * 1000 V_lim_sup = float(self.ui.LinEdVLSup.text()) * 1000 T_Max = int(self.ui.LinEdTMax.text()) if Corriente > 0: CargaOdescarga = True else: CargaOdescarga = False print("[" + str(datetime.datetime.now()) + "][UICICL] datos " + str([ "SETC", Celda, Ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaOdescarga ]), file=log) #print("["+str(datetime.datetime.now())+"UICICL] datos " + str( # ["SETC", Celda, Ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaOdescarga])) self.mutex.lock() self.dequeSetting.append([ "SETC", Celda, Ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaOdescarga ]) self.mutex.unlock() self.inicio( Celda ) # Celda, Promedio, Corriente, Ciclos, V_lim_inf, V_lim_sup, T_Max # self.connect(self.threadPool[len(self.threadPool) - 1], # self.threadPool[len(self.threadPool) - 1].signal, # self.ActualValores) # self.connect(self.threadOne[len(self.threadOne) - 1], # self.threadOne[len(self.threadOne) - 1].signal, # self.ActualValores) # self.connect(self.threadOne[len(self.threadOne) - 1], # self.threadOne[len(self.threadOne) - 1].signalSingleShot, # self.LlenoCamposCondGuardado) def inicio(self, Celda): if self.ui.BotActivo.isChecked(): self.ui.BotSetearV.setChecked(False) self.ui.BotSetearC.setChecked(False) # self.ui.labelInfo("no puedo setear la celda") else: #Iniciar Ciclado con start de Datos self.ui.BotSetearV.setChecked(False) self.ui.BotSetearC.setChecked(False) self.ui.BotActivo.setChecked(True) self.chequeaRB(Celda, True) def chequeaRB(self, celda, estado): if celda == 'a': self.ui.RBa.setChecked(estado) elif celda == 'b': self.ui.RBb.setChecked(estado) elif celda == 'c': self.ui.RBc.setChecked(estado) elif celda == 'd': self.ui.RBd.setChecked(estado) elif celda == 'e': self.ui.RBe.setChecked(estado) elif celda == 'f': self.ui.RBf.setChecked(estado) elif celda == 'g': self.ui.RBg.setChecked(estado) elif celda == 'h': self.ui.RBh.setChecked(estado) elif celda == 'i': self.ui.RBi.setChecked(estado) elif celda == 'j': self.ui.RBj.setChecked(estado) elif celda == 'k': self.ui.RBk.setChecked(estado) elif celda == 'l': self.ui.RBl.setChecked(estado) elif celda == 'm': self.ui.RBm.setChecked(estado) elif celda == 'n': self.ui.RBn.setChecked(estado) elif celda == 'o': self.ui.RBo.setChecked(estado) elif celda == 'p': self.ui.RBp.setChecked(estado) def PararCelda(self, Celda=None): if Celda is None: Celda = self.ui.cmbCelC.currentText() print("[" + str(datetime.datetime.now()) + "UICICL] datos " + str(["FINV", Celda, 0, 0, 0, 0, 0, 0, False]), file=log) self.mutex.lock() self.dequeSetting.append(["FINV", Celda, 0, 0, 0, 0, 0, 0, False]) self.mutex.unlock() self.chequeaRB(Celda, False) def ActCondUi(self): Celda = self.ui.cmbCelC.currentText() print("[" + str(datetime.datetime.now()) + "][UICICL] datos " + str(["AUI", Celda, None, None, None, None, None, None, None]), file=log) self.mutex.lock() self.dequeSetting.append( ["AUI", Celda, None, None, None, None, None, None, None]) self.mutex.unlock() def Recalibrar(self): lines = [] lines.append("a=" + str(self.ui.FCA.text()) + "\n") lines.append("b=" + str(self.ui.FCB.text()) + "\n") lines.append("c=" + str(self.ui.FCC.text()) + "\n") lines.append("d=" + str(self.ui.FCD.text()) + "\n") lines.append("e=" + str(self.ui.FCE.text()) + "\n") lines.append("f=" + str(self.ui.FCF.text()) + "\n") lines.append("g=" + str(self.ui.FCG.text()) + "\n") lines.append("h=" + str(self.ui.FCH.text()) + "\n") lines.append("i=" + str(self.ui.FCI.text()) + "\n") lines.append("j=" + str(self.ui.FCJ.text()) + "\n") lines.append("k=" + str(self.ui.FCK.text()) + "\n") lines.append("l=" + str(self.ui.FCL.text()) + "\n") lines.append("m=" + str(self.ui.FCM.text()) + "\n") lines.append("n=" + str(self.ui.FCN.text()) + "\n") lines.append("o=" + str(self.ui.FCO.text()) + "\n") lines.append("p=" + str(self.ui.FCP.text()) + "\n") with open("correccionI.txt", "wr") as in_file: in_file.writelines(lines) def CargoCorrecionDeI(self): lines = [] try: with open("correccionI.txt", "rt") as in_file: for line in in_file: lines.append(line) self.ui.FCA.setText(str(lines[0][2:-1])) self.ui.FCB.setText(str(lines[1][2:-1])) self.ui.FCC.setText(str(lines[2][2:-1])) self.ui.FCD.setText(str(lines[3][2:-1])) self.ui.FCE.setText(str(lines[4][2:-1])) self.ui.FCF.setText(str(lines[5][2:-1])) self.ui.FCG.setText(str(lines[6][2:-1])) self.ui.FCH.setText(str(lines[7][2:-1])) self.ui.FCI.setText(str(lines[8][2:-1])) self.ui.FCJ.setText(str(lines[9][2:-1])) self.ui.FCK.setText(str(lines[10][2:-1])) self.ui.FCL.setText(str(lines[11][2:-1])) self.ui.FCM.setText(str(lines[12][2:-1])) self.ui.FCN.setText(str(lines[13][2:-1])) self.ui.FCO.setText(str(lines[14][2:-1])) self.ui.FCP.setText(str(lines[15][2:-1])) except: lines.append("a=" + str(self.ui.FCA.text()) + "\n") lines.append("b=" + str(self.ui.FCB.text()) + "\n") lines.append("c=" + str(self.ui.FCC.text()) + "\n") lines.append("d=" + str(self.ui.FCD.text()) + "\n") lines.append("e=" + str(self.ui.FCE.text()) + "\n") lines.append("f=" + str(self.ui.FCF.text()) + "\n") lines.append("g=" + str(self.ui.FCG.text()) + "\n") lines.append("h=" + str(self.ui.FCH.text()) + "\n") lines.append("i=" + str(self.ui.FCI.text()) + "\n") lines.append("j=" + str(self.ui.FCJ.text()) + "\n") lines.append("k=" + str(self.ui.FCK.text()) + "\n") lines.append("l=" + str(self.ui.FCL.text()) + "\n") lines.append("m=" + str(self.ui.FCM.text()) + "\n") lines.append("n=" + str(self.ui.FCN.text()) + "\n") lines.append("o=" + str(self.ui.FCO.text()) + "\n") lines.append("p=" + str(self.ui.FCP.text()) + "\n") with open("correccionI.txt", "wr") as in_file: in_file.writelines(lines) def LlenoCamposCondGuardado(self, corriente, ciclos, vli, vls, tmax, prom): self.ui.LinEdCorri.setText(str(corriente)) self.ui.LinEdCiclos.setText(str(ciclos)) self.ui.LinEdVLInf.setText(str(vli)) self.ui.LinEdVLSup.setText(str(vls)) self.ui.LinEdTMax.setText(str(tmax)) if prom == 100: self.ui.cmbProm.setCurrentIndex(7) self.ui.cmbProm.setCurrentIndex(6) elif prom == 25: self.ui.cmbProm.setCurrentIndex(5) elif prom == 10: self.ui.cmbProm.setCurrentIndex(4) elif prom == 5: self.ui.cmbProm.setCurrentIndex(3) elif prom == 1: self.ui.cmbProm.setCurrentIndex(2) elif prom == 0.5: self.ui.cmbProm.setCurrentIndex(1) else: self.ui.cmbProm.setCurrentIndex(0) def Reseteo(self): # Voc self.ui.cmbCelV.setCurrentIndex(0) self.ui.LinEdTiemV.setText('5') self.ui.cmbPromV.setCurrentIndex(5) # Ciclado self.ui.cmbCelC.setCurrentIndex(0) self.ui.LinEdCorri.setText('1000') self.ui.LinEdCiclos.setText('3') self.ui.LinEdVLInf.setText('-999.999') self.ui.LinEdVLSup.setText('999.999') self.ui.LinEdTMax.setText('12') self.ui.cmbProm.setCurrentIndex(7) def PararGrafico(self): Celda = self.ui.cmbCelPlot.currentText() print("[" + str(datetime.datetime.now()) + "][CICL] Parar plot para " + str(Celda), file=log) self.mutex.lock() self.dequeSetting.append( ["FPlot", Celda, None, None, None, None, None, None, None]) self.mutex.unlock() def ValTiempoReal(self): Celda = self.ui.cmbCelTReal.currentText() self.mutex.lock() self.flagVTR = not self.flagVTR if self.flagVTR: print("[" + str(datetime.datetime.now()) + "][CICL] inicia val en tiempo REAL con " + str(Celda), file=log) self.dequeSetting.append( ["VTR", Celda, None, None, None, None, None, None, None]) else: print("[" + str(datetime.datetime.now()) + "][CICL] Finaliza val en tiempo REAL con " + str(Celda), file=log) self.dequeSetting.append( ["FTR", Celda, None, None, None, None, None, None, None]) self.mutex.unlock() def ActualValores(self, barrido, Vin, Iin, Tiem, TiempoTotal, Ingresos): if barrido != 0 and Vin != 0 and Iin != 0 and Tiem != 0 and Ingresos != 0: #print("["+str(datetime.datetime.now())+"][CICL] -val-", file=log) barridos_real = (int(barrido) / 2) + (int(barrido) % 2) self.ui.SalBarrido.setText(str(barridos_real)) self.ui.SalVInst.setText(str(int(Vin) / 1000.0)) self.ui.SalIInst.setText(str(int(Iin) / 1000000.0)) self.ui.SalTiemp.setText(str('{:014.2f}'.format(float(Tiem)))) self.ui.SalTiempTot.setText( str('{:015.1f}'.format(float(TiempoTotal)))) self.ui.SalMuestrasInst.setText(str(Ingresos)) else: print("[" + str(datetime.datetime.now()) + "][CICL] Actualizo valores - FIN", file=log) """ ############################################################## PLOTEO """ def LimPant(self): self.Ploteo1.clear() self.Ploteo2.clear() def Plot(self): Celda = self.ui.cmbCelPlot.currentText() if self.ui.RBTiemReal.isChecked(): print("[" + str(datetime.datetime.now()) + "][CICL_PLOT] Starts plot en tiempo REAL", file=log) self.mutex.lock() self.flagPLOTVTR = not self.flagPLOTVTR if self.flagPLOTVTR: self.dequeSetting.append( ["Plot", Celda, None, None, None, None, None, None, None]) else: self.dequeSetting.append( ["FPlot", None, None, None, None, None, None, None, None]) self.mutex.unlock() ploteo1 = self.Ploteo1.plot() ploteo2 = self.Ploteo2.plot() self.threadTwo.append(PLOTEOTR.PLOTEOTR(Celda, self.filaPloteo)) self.threadTwo[len(self.threadTwo) - 1].newData1.connect( self.update1) self.threadTwo[len(self.threadTwo) - 1].newData2.connect( self.update2) self.threadTwo[len(self.threadTwo) - 1].start() elif self.ui.RBPlotFin.isChecked(): listaBarr = str(self.ui.LELisBarridos.text()) listaBarr = listaBarr.split(',') self.PlotFinal(str(Celda), listaBarr) elif self.ui.RDdefinido.isChecked(): Inicial = int(self.ui.LEBarIn.text()) Final = int(self.ui.LEBarFin.text()) self.PlotEntreVal(Inicial, Final, Celda) elif self.ui.RBCapac.isChecked(): PesoAnodo = float(self.ui.LEPesoAnodo.text()) self.PlotFinalCapacidades(Celda, PesoAnodo) def update1(self, data1): self.Ploteo1.plot(data1, pen='g', clear=True) # data2,clear=True) self.Ploteo1.setLabel('left', text='Tension', units='mV', unitPrefix=None) self.Ploteo1.showGrid(x=True, y=True, alpha=None) # setLabel(axis, text=None, units=None, unitPrefix=None, **args) def update2(self, data2): self.Ploteo2.plot(data2, pen='r', clear=True) self.Ploteo2.setLabel('left', text='Corriente', units='uA', unitPrefix=None) self.Ploteo2.showGrid(x=True, y=True, alpha=None) def PlotFinal(self, Celda, barridos): DequePLOT = deque() nombre = 'Arch_Cn-' + str(Celda) + '.csv' with open(nombre) as f: reader = csv.reader(f, delimiter="\t") next(f) for line in reader: linea = line[0].split(',', 3) renglon = [] for elemento in linea: if elemento == ' ----- ': break else: renglon += float(elemento), DequePLOT.append(renglon) ValT = [] ValX = [] self.Ploteo1.clear() self.Ploteo2.clear() for j in barridos: j = int(j) print(str(len(DequePLOT)), file=log) for i in range(len(DequePLOT) - 2): if DequePLOT[i][0] >= j: if DequePLOT[i][3] == 0 and len(ValT) != 0: self.Ploteo1.plot(ValT, ValX, pen=(j, len(barridos))) print('carga ' + str(len(ValT)), file=log) ValT = [] ValX = [] ValT += DequePLOT[i][3], ValX += DequePLOT[i][1], # tension else: ValT += DequePLOT[i][3], ValX += DequePLOT[i][1], # tension if DequePLOT[i][0] > j: print('descarga ' + str(len(ValT)), file=log) self.Ploteo1.plot(ValT, ValX, pen=(j, len(barridos))) ValT = [] ValX = [] break self.Ploteo1.setLabel('left', text='Tension', units='mV', unitPrefix=None) self.Ploteo1.showGrid(x=True, y=True, alpha=None) DequePLOT.clear() def PlotFinalCapacidades(self, Celda, PesoAnodo): DequePLOT = deque() nombre = 'Arch_Cn-' + str(Celda) + '.csv' with open(nombre) as f: reader = csv.reader(f, delimiter="\t") next(f) for line in reader: linea = line[0].split(',', 3) renglon = [] for elemento in linea: if elemento == ' ----- ': break else: renglon += float(elemento), DequePLOT.append(renglon) barridoMax = DequePLOT[len(DequePLOT) - 2][0] print('barrido ultimo: ' + str(barridoMax), file=log) ValCapacidades = [] for i in range(1, int(barridoMax) + 1): corriente = tiempo = 0.0 samples = 0 for j in range(len(DequePLOT) - 1): if DequePLOT[j][0] == i: samples += 1 corriente += DequePLOT[j][2] if DequePLOT[j][3] > tiempo: tiempo = DequePLOT[j][3] ValCapacidades += (corriente / (samples)) * (tiempo / PesoAnodo), print(ValCapacidades, file=log) # symbol='o', self.Ploteo2.clear() self.Ploteo2.plot( ValCapacidades, symbol='+', pen='r' ) # self.Ploteo2. setLabel('left' , text='Capacidad Anodica', units='[uA*s/gr]',unitPrefix=None) self.Ploteo2.showGrid(x=True, y=True, alpha=None) # lr2 = pg.LinearRegionItem([0,100]) # lr2.setZValue(-10) # self.Ploteo2.addItem(lr2) #################################################################ver # self.Ploteo1.plot(ValX, pen='r') # def updatePlot(): # self.Ploteo1.setXRange(*lr2.getRegion(), padding=0) # def updateRegion(): # lr2.setRegion(self.Ploteo1.getViewBox().viewRange()[0]) # lr2.sigRegionChanged.connect(updatePlot) # self.Ploteo1.sigXRangeChanged.connect(updateRegion) # updatePlot() def PlotEntreVal(self, Inicial, Final, Celda): DequePLOT = deque() nombre = 'Arch_Cn-' + str(Celda) + '.csv' with open(nombre) as f: reader = csv.reader(f, delimiter="\t") next(f) for line in reader: linea = line[0].split(',', 3) renglon = [] for elemento in linea: if elemento == ' ----- ': break else: renglon += float(elemento), DequePLOT.append(renglon) ValT = [] ValX = [] ValY = [] for i in range(len(DequePLOT) - 2): # le cambie el comienzo if DequePLOT[i][0] >= Inicial: ValT += DequePLOT[i][3], ValX += DequePLOT[i][1], # tension ValY += DequePLOT[i][2], # corriente if DequePLOT[i][0] > Final: break DequePLOT.clear() self.Ploteo1.clear() self.Ploteo2.clear() self.Ploteo2.plot(ValX, pen='r') self.Ploteo2.plot(ValY, pen='g') self.Ploteo2.setLabel('left', text='Corriente', units='uA', unitPrefix=None) self.Ploteo2.showGrid(x=True, y=True, alpha=None) lr2 = pg.LinearRegionItem([0, 100]) lr2.setZValue(-10) self.Ploteo2.addItem(lr2) self.Ploteo1.plot(ValX, pen='r') def updatePlot(): self.Ploteo1.setXRange(*lr2.getRegion(), padding=0) def updateRegion(): lr2.setRegion(self.Ploteo1.getViewBox().viewRange()[0]) lr2.sigRegionChanged.connect(updatePlot) self.Ploteo1.sigXRangeChanged.connect(updateRegion) updatePlot() """############################################################## FUNCIONES Dependientes"""
from PyQt4.Qt import QSettings, QVariant, QThread, QMutex, QTimer from PyQt4.QtCore import pyqtSignal as Signal from PyQt4.QtGui import QApplication, QMainWindow, QLabel, QComboBox import AboutDialog import Settings import Temperature import convertFahrenheit import time APP_VERSION = '1.0.0' APP_NAME = 'PerlustroC' ORG_NAME = 'Gatituz Inc' ORG_DOMAIN = 'www.gatituz.duckdns.org' mutex = QMutex() class MainWindow(Temperature.Ui_MainWindow, QMainWindow): def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setupUi(self) self.setWindowTitle(APP_NAME) self.array_values = array.array('h') self.list_x = [x for x in xrange(0, 60)] self.load_save_settings() self.label_usb = QLabel('USB Port:')
def __init__(self, maxSize=10): self.maxSize = maxSize self._q = deque() self.mutex = QMutex()
class Scheduler(QObject): INTERVAL = 1 # minutes delete_old_news = pyqtSignal(object) start_recipe_fetch = pyqtSignal(object) def __init__(self, parent, db): QObject.__init__(self, parent) self.internet_connection_failed = False self._parent = parent self.no_internet_msg = _('Cannot download news as no internet connection ' 'is active') self.no_internet_dialog = d = error_dialog(self._parent, self.no_internet_msg, _('No internet connection'), show_copy_button=False) d.setModal(False) self.recipe_model = RecipeModel() self.db = db self.lock = QMutex(QMutex.Recursive) self.download_queue = set([]) self.news_menu = QMenu() self.news_icon = QIcon(I('news.png')) self.scheduler_action = QAction(QIcon(I('scheduler.png')), _('Schedule news download'), self) self.news_menu.addAction(self.scheduler_action) self.scheduler_action.triggered[bool].connect(self.show_dialog) self.cac = QAction(QIcon(I('user_profile.png')), _('Add a custom news source'), self) self.cac.triggered[bool].connect(self.customize_feeds) self.news_menu.addAction(self.cac) self.news_menu.addSeparator() self.all_action = self.news_menu.addAction( _('Download all scheduled news sources'), self.download_all_scheduled) self.timer = QTimer(self) self.timer.start(int(self.INTERVAL * 60 * 1000)) self.timer.timeout.connect(self.check) self.oldest = gconf['oldest_news'] QTimer.singleShot(5 * 1000, self.oldest_check) def database_changed(self, db): self.db = db def oldest_check(self): if self.oldest > 0: delta = timedelta(days=self.oldest) try: ids = list(self.db.tags_older_than(_('News'), delta, must_have_authors=['calibre'])) except: # Happens if library is being switched ids = [] if ids: if ids: self.delete_old_news.emit(ids) QTimer.singleShot(60 * 60 * 1000, self.oldest_check) def show_dialog(self, *args): self.lock.lock() try: d = SchedulerDialog(self.recipe_model) d.download.connect(self.download_clicked) d.exec_() gconf['oldest_news'] = self.oldest = d.old_news.value() d.break_cycles() finally: self.lock.unlock() def customize_feeds(self, *args): from calibre.gui2.dialogs.user_profiles import UserProfiles d = UserProfiles(self._parent, self.recipe_model) d.exec_() d.break_cycles() def do_download(self, urn): self.lock.lock() try: account_info = self.recipe_model.get_account_info(urn) customize_info = self.recipe_model.get_customize_info(urn) recipe = self.recipe_model.recipe_from_urn(urn) un = pw = None if account_info is not None: un, pw = account_info add_title_tag, custom_tags, keep_issues = customize_info script = self.recipe_model.get_recipe(urn) pt = PersistentTemporaryFile('_builtin.recipe') pt.write(script) pt.close() arg = { 'username': un, 'password': pw, 'add_title_tag':add_title_tag, 'custom_tags':custom_tags, 'recipe':pt.name, 'title':recipe.get('title',''), 'urn':urn, 'keep_issues':keep_issues } self.download_queue.add(urn) self.start_recipe_fetch.emit(arg) finally: self.lock.unlock() def recipe_downloaded(self, arg): self.lock.lock() try: self.recipe_model.update_last_downloaded(arg['urn']) self.download_queue.remove(arg['urn']) finally: self.lock.unlock() def recipe_download_failed(self, arg): self.lock.lock() try: self.recipe_model.update_last_downloaded(arg['urn']) self.download_queue.remove(arg['urn']) finally: self.lock.unlock() def download_clicked(self, urn): if urn is not None: return self.download(urn) for urn in self.recipe_model.scheduled_urns(): if not self.download(urn): break def download_all_scheduled(self): self.download_clicked(None) def has_internet_connection(self): if not internet_connected(): if not self.internet_connection_failed: self.internet_connection_failed = True if self._parent.is_minimized_to_tray: self._parent.status_bar.show_message(self.no_internet_msg, 5000) elif not self.no_internet_dialog.isVisible(): self.no_internet_dialog.show() return False self.internet_connection_failed = False if self.no_internet_dialog.isVisible(): self.no_internet_dialog.hide() return True def download(self, urn): self.lock.lock() if not self.has_internet_connection(): return False doit = urn not in self.download_queue self.lock.unlock() if doit: self.do_download(urn) return True def check(self): recipes = self.recipe_model.get_to_be_downloaded_recipes() for urn in recipes: if not self.download(urn): # No internet connection, we will try again in a minute break
class ISEG_Command(QtCore.QObject): """This is a class""" ramp_finished = QtCore.pyqtSignal() update_TVD = QtCore.pyqtSignal() measure_currents_finished = QtCore.pyqtSignal() def __init__(self, ISEG_VISA_IDs): QtCore.QObject.__init__(self) self.ISEG_VISA_IDs = ISEG_VISA_IDs self.num_channels = len(self.ISEG_VISA_IDs) print self.ISEG_VISA_IDs #iseg module parameters self.num_time_segs = None self.V_ramp_list_array = None self.ramp_speed_list_array = None self.tau = None self.repetition_time_delay = None self.V_initial_list = None self.V_final_list = None self.running = True self.connect(self.ISEG_VISA_IDs) self.mutex = QMutex() self.micro = 10**(-6) def connect(self, ISEG_VISA_IDs): """ this is a function """ self.rm = visa.ResourceManager() self.inst_channels = [] for i in range(self.num_channels): inst = self.rm.open_resource(ISEG_VISA_IDs[i]) inst.write('*CLS') inst.write('*RST') inst.write(":CONF:ECHO OFF") inst.write(":CONF:ECHO OFF") attempts = 0 while attempts < 3: try: print 'started session: instrument ID: iseg:', self.get_SN( inst) break except visa.VisaIOError: print 'Visa IO Error: ' + str( self.rm.last_status) + ' Attempt {}/2'.format(attempts) time.sleep(0.5) attempts += 1 continue self.inst_channels.append(inst) def query(self, inst, querystr): return inst.query(querystr) def measure_volts(self): V_measured = [] for i in range(self.num_channels): v = self.query(self.inst_channels[i], ':MEAS:VOLT?') V_measured.append(float(v[0:len(v) - 3])) #V_measured.append(v) V_measured_rounded = ['%.2f' % elem for elem in V_measured] return V_measured_rounded def measure_currents(self): I_measured = [] self.mutex.lock() for i in range(self.num_channels): current = self.query(self.inst_channels[i], ':MEAS:CURR?') I_num_amps = float(current[0:len(current) - 3]) I_str_uamps = str(I_num_amps / self.micro) + ' uA' #I_measured.append(float(current[0:len(current)-3])) I_measured.append(I_str_uamps) self.mutex.unlock() return I_measured print 'ISEG command: curents measured' self.measure_currents_finished.emit() def set_initial_voltages(self, V_initial_list): for i in range(self.num_channels): self.inst_channels[i].write(":CONF:RAMP:VOLT " + str(10)) self.inst_channels[i].write(":VOLT " + str(abs(V_initial_list[i]))) def set_final_voltages(self, V_final_list): for i in range(self.num_channels): self.inst_channels[i].write(":CONF:RAMP:VOLT " + str(10)) self.inst_channels[i].write(":VOLT " + str(abs(V_final_list[i]))) def ramp(self, inst, ramp_speed, V_end): inst.write(":CONF:RAMP:VOLT " + str(ramp_speed)) inst.write(":VOLT " + str(abs(V_end))) def get_SN(self, inst): SN = self.query(inst, '*IDN?') return SN[36:42] def close(self): for inst in self.inst_channels: inst.close() def ramp_sequence(self): time.sleep(self.repetition_time_delay / 2) tic_RS = time.time() for k in range(self.num_time_segs): if self.running: tic_ramp = time.time() self.mutex.lock() for i in range(self.num_channels): self.ramp(self.inst_channels[i], self.ramp_speed_list_array[i, k], self.V_ramp_list_array[i, k + 1]) self.mutex.unlock() time.sleep(self.tau) toc_ramp = abs(tic_ramp - time.time()) print 'ISEG command: ramp time: {} seconds'.format(toc_ramp) self.update_TVD.emit() toc_RS = time.time() - tic_RS print 'ISEG command: ramp sequence total time: {} seconds'.format( toc_RS) time.sleep(self.repetition_time_delay / 2) self.ramp_finished.emit() def update_ramp_params(parameter_list): pass
class queue: def __init__(self, maxSize=10): self.maxSize = maxSize self._q = deque() self.mutex = QMutex() def urgentFrame(self, item): self.mutex.lock() self._q.clear() self._q.appendleft(item) self.mutex.unlock() def push(self, item): self.mutex.lock() self._q.appendleft(item) self.mutex.unlock() def pop(self): self.mutex.lock() item = self._q.pop() self.mutex.unlock() return item def size(self): return len(self._q) def isEmpty(self): return len(self._q)==0
class DatosCompartidos(QtCore.QThread): class Modos: inactiva, ciclando, voc = range(3) PoolThread = [] celdasAenviar = [] hayAlgo = 0 #timerOkRececpcion = QTimer() def __init__(self, dequeSettings, dequePLOT, parent=None): print("[" + str(datetime.datetime.now()) + "][DCOMP] initing", file=log) self.a = DatosCelda("a") self.b = DatosCelda("b") #2 self.c = DatosCelda("c") #3 self.d = DatosCelda("d") #4 self.e = DatosCelda("e") #5 self.f = DatosCelda("f") #6 self.g = DatosCelda("g") #7 self.h = DatosCelda("h") #8 self.i = DatosCelda("i") #9 self.j = DatosCelda("j") #10 self.k = DatosCelda("k") #11 self.l = DatosCelda("l") #12 self.m = DatosCelda("m") #13 self.n = DatosCelda("n") #14 self.o = DatosCelda("o") #15 self.p = DatosCelda("p") #16 QtCore.QThread.__init__(self) self.mutex = QMutex() self.daemon = True self.signal = QtCore.SIGNAL("realTimeData") self.signalSingleShot = QtCore.SIGNAL("UIConditions") self.parocelda = QtCore.SIGNAL("parocelda") self.celdaEnTiempoReal = None self.celdaCondUI = None self.celdaPLOTTR = None """DEQUES de comunicacion""" self.dequeSettings = dequeSettings #desde UI self.dequePLOT = dequePLOT #hacia UI?? self.dequeOUT = deque(maxlen=16000) #seteos de celdas a puerto self.dequeIN = deque(maxlen=16000) #desde puerto crudo """""" #print( "arranco thread de lectura desde DatosIndependientes", file=log) self.PoolThread.append( ProcesoPuerto.LECTURA(self.dequePLOT, self.dequeOUT, self.dequeIN)) #self.PoolThread[len(self.PoolThread) - 1].start() def __del__(self): # This will (should) ensure that the thread stops processing before it gets destroyed. self.wait() def run(self): self.PoolThread[len(self.PoolThread) - 1].start() while True: time.sleep(0.001) #proceso desde UI hacia puerto if int(len(self.dequeSettings)) >= 1: try: self.mutex.lock() [ mensaje, Celda, Ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaOdescarga ] = self.dequeSettings.pop() self.mutex.unlock() except IndexError: mensaje = Celda = Corriente = None if mensaje == "SETC" or mensaje == "SETV" or mensaje == "FINV": print("[" + str(datetime.datetime.now()) + "][DIND] recibo set" + str([ Celda, Ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaOdescarga ]), file=log) if self.xIsActive(Celda): print("[" + str(datetime.datetime.now()) + "][DIND|" + str(Celda) + "]activada", file=log) if mensaje == "FINV": print("[" + str(datetime.datetime.now()) + "][DIND|" + str(Celda) + "] desactiva por boton", file=log) self.xPararCelda(Celda) if Celda == self.celdaPLOTTR: self.mutex.lock() self.dequePLOT.append([Celda, 0, 0, 0, 0]) self.mutex.unlock() if Celda == self.celdaPLOTTR: self.emit(self.signal, str(0), str(0), str(0), str(0), str(0), str(0)) else: if mensaje == "SETC": self.xSetActive(Celda, self.Modos.ciclando) elif mensaje == "SETV": self.xSetActive(Celda, self.Modos.voc) self.xEnviarPS(Celda, 1) self.xCondicionesDeGuardado(Celda, Ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaOdescarga) if mensaje == "VTR": print("[" + str(datetime.datetime.now()) + "][DIND] Celda en tiempo REAL " + str(Celda), file=log) self.celdaEnTiempoReal = Celda if mensaje == "FTR": print("[" + str(datetime.datetime.now()) + "][DIND] FINALIZA Celda en tiempo REAL " + str(self.celdaEnTiempoReal), file=log) self.celdaEnTiempoReal = None if mensaje == "Plot": print("[" + str(datetime.datetime.now()) + "][DIND] Celda PLOTEO en tiempo REAL " + str(Celda), file=log) self.celdaPLOTTR = Celda if mensaje == "FPlot": print("[" + str(datetime.datetime.now()) + "][DIND] FINALIZA Celda PLOTEO en tiempo REAL " + str(Celda), file=log) if Celda == self.celdaPLOTTR: # Intento Parar Plot self.mutex.lock() self.dequePLOT.append([Celda, 0, 0, 0, 0]) self.mutex.unlock() self.celdaPLOTTR = None self.dequePLOT.clear() if mensaje == "AUI": print("[" + str(datetime.datetime.now()) + "][DIND] Celda valores en tiempo REAL " + str(Celda), file=log) self.celdaCondUI = Celda # proceso desde puerto hacia csv's if int(len(self.dequeIN)) >= 1: try: self.mutex.lock() [mensaje, Celda, Tension, Corriente, Tiempo] = self.dequeIN.pop() self.mutex.unlock() except IndexError: mensaje = Celda = Tension = Corriente = Tiempo = None print("[" + str(datetime.datetime.now()) + "][DIND] error extrayendo datos", file=log) if mensaje == "RAW": if self.xIsActive(Celda): cambio = self.xActualizoCampo(Celda, Tension, Corriente, Tiempo) #print( "["+str(datetime.datetime.now())+"][DIND] Cambio = "+str(cambio), file=log) if cambio == 1 or cambio == 2: Corriente, ciclos, vli, vls, tmax, prom = self.xGetCondGuardado( Celda) self.mutex.lock() self.dequeOUT.append(["SETI", Celda, Corriente]) self.mutex.unlock() if cambio == 2: print( "[" + str(datetime.datetime.now()) + "][DIND] termino ploteo en TR y datos en tiempo R ", file=log) self.xPararCelda(Celda) if Celda == self.celdaPLOTTR: # Intento Parar Plot self.mutex.lock() self.dequePLOT.append([Celda, 0, 0, 0, 0]) self.mutex.unlock() if Celda == self.celdaPLOTTR: # Parar datos en tiempo real self.emit(self.signal, str(0), str(0), str(0), str(0), str(0), str(0)) self.emit(self.parocelda, Celda) if self.enColaPorEnviar() != 0: Celda, Corriente = self.xGetPorSetear() self.mutex.lock() self.dequeOUT.append(["SETI", Celda, Corriente]) self.mutex.unlock() self.xEnviarPS(Celda, 2) if Celda == self.celdaEnTiempoReal: [ corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct ] = self.xGetCondTiempoReal(Celda) #print("["+str(datetime.datetime.now())+"][DIND] EMIT val en tiempo REAL (ingresos " + str(ingresos) + ")", file=log) self.emit(self.signal, str(ciclos), str(voltios), str(corriente), str(tiempoCAct), str(tiempoTot), str(ingresos)) if Celda == self.celdaCondUI: print("[" + str(datetime.datetime.now()) + "][DIND] -ui-", file=log) [corriente, ciclos, vli, vls, tmax, prom] = self.xGetCondGuardado(Celda) self.emit(self.signalSingleShot, str(corriente), str(ciclos), str(vli), str(vls), str(tmax), str(prom)) if Celda == self.celdaPLOTTR: #print( "["+str(datetime.datetime.now())+"][DIND] PLOT TIEMPO REAL", file=log) [ corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct ] = self.xGetCondTiempoReal(Celda) self.mutex.lock() self.dequePLOT.append([ Celda, ciclos, voltios, corriente, tiempoCAct ]) self.mutex.unlock() if mensaje == "OK!": print("[" + str(datetime.datetime.now()) + "][DIND] recibo OK!", file=log) #self.xEnviarPS(Celda, 2) def xIsActive(self, num): if num == "a" or num == 1: return self.a.Activada() elif num == "b" or num == 2: return self.b.Activada() elif num == "c" or num == 3: return self.c.Activada() elif num == "d" or num == 4: return self.d.Activada() elif num == "e" or num == 5: return self.e.Activada() elif num == "f" or num == 6: return self.f.Activada() elif num == "g" or num == 7: return self.g.Activada() elif num == "h" or num == 8: return self.h.Activada() elif num == "i" or num == 9: return self.i.Activada() elif num == "j" or num == 10: return self.j.Activada() elif num == "k" or num == 11: return self.k.Activada() elif num == "l" or num == 12: return self.l.Activada() elif num == "m" or num == 13: return self.m.Activada() elif num == "n" or num == 14: return self.n.Activada() elif num == "o" or num == 15: return self.o.Activada() elif num == "p" or num == 16: return self.p.Activada() else: print("[" + str(datetime.datetime.now()) + "][DIND|xIsActive]- Atrib error", file=log) return False def xSetActive(self, num, modo): if num in (1, "a"): return self.a.CambiaModo(modo) elif num == "b" or num == 2: return self.b.CambiaModo(modo) elif num == "c" or num == 3: return self.c.CambiaModo(modo) elif num == "d" or num == 4: return self.d.CambiaModo(modo) elif num == "e" or num == 5: return self.e.CambiaModo(modo) elif num == "f" or num == 6: return self.f.CambiaModo(modo) elif num == "g" or num == 7: return self.g.CambiaModo(modo) elif num == "h" or num == 8: return self.h.CambiaModo(modo) elif num == "i" or num == 9: return self.i.CambiaModo(modo) elif num == "j" or num == 10: return self.j.CambiaModo(modo) elif num == "k" or num == 11: return self.k.CambiaModo(modo) elif num == "l" or num == 12: return self.l.CambiaModo(modo) elif num == "m" or num == 13: return self.m.CambiaModo(modo) elif num == "n" or num == 14: return self.n.CambiaModo(modo) elif num == "o" or num == 15: return self.o.CambiaModo(modo) elif num == "p" or num == 16: return self.p.CambiaModo(modo) else: print("[" + str(datetime.datetime.now()) + "][DIND|xSetActive]- Atrib error", file=log) return False def xCondicionesDeGuardado(self, num, ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga): if num == "a" or num == 1: return self.a.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "b" or num == 2: return self.b.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "c" or num == 3: return self.c.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "d" or num == 4: return self.d.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "e" or num == 5: return self.e.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "f" or num == 6: return self.f.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "g" or num == 7: return self.g.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "h" or num == 8: return self.h.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "i" or num == 9: return self.i.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "j" or num == 10: return self.j.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "k" or num == 11: return self.k.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "l" or num == 12: return self.l.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "m" or num == 13: return self.m.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "n" or num == 14: return self.n.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "o" or num == 15: return self.o.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) elif num == "p" or num == 16: return self.p.CondicionesDeGuardado(ciclos, V_lim_sup, V_lim_inf, T_Max, Corriente, Promedio, CargaoDescarga) else: print("[" + str(datetime.datetime.now()) + "][DIND|xCondGuard] Attr Error", file=log) return False def enColaPorEnviar(self): #print("[" + str(datetime.datetime.now()) + "][DIND] longitud de cola de envio " + str(self.celdasAenviar.__len__()), file=log) return self.celdasAenviar.__len__() def xEnviarPS(self, num, val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] longitud de cola de envio para " + str(num) + " es " + str(self.enColaPorEnviar()), file=log) #print("["+str(datetime.datetime.now())+"][DIND][xEnvPS] num y val " + str(num) + " " + str(val), file=log) if val == 2: self.hayAlgo = 0 if self.enColaPorEnviar() >= 1: num = self.celdasAenviar.pop(0) print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] saco a " + num + " de la fila para enviar", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no tengo ninguna celda en cola, error ", file=log) if val == 1: self.hayAlgo = self.hayAlgo + 1 self.celdasAenviar.extend(str(num)) print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] hay algo " + str(self.hayAlgo), file=log) return True """ if num == "a" or num == 1: if self.a.NecesitoEnviar(val): print("["+str(datetime.datetime.now())+"][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("["+str(datetime.datetime.now())+"][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "b" or num == 2: if self.b.NecesitoEnviar(val): print("["+str(datetime.datetime.now())+"][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "c" or num == 3: if self.c.NecesitoEnviar(val): print("["+str(datetime.datetime.now())+"][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "d" or num == 4: if self.d.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "e" or num == 5: if self.e.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "f" or num == 6: if self.f.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "g" or num == 7: if self.g.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "h" or num == 8: if self.h.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "i" or num == 9: if self.i.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "j" or num == 10: if self.j.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "k" or num == 11: if self.k.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "l" or num == 12: if self.l.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "m" or num == 13: if self.m.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "n" or num == 14: if self.n.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "o" or num == 15: if self.o.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False elif num == "p" or num == 16: if self.p.NecesitoEnviar(val): print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] por enviar corriente", file=log) return True else: print("[" + str(datetime.datetime.now()) + "][DIND][xEnvPS] no se pudo enviar corriente", file=log) return False else: print("datos independientes- EnviarPS - Atrib error", file=log) """ def xPararCelda(self, num): if num == "a" or num == 1: if self.a.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda " + str(num), file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda " + str(num), file=log) elif num == "b" or num == 2: if self.b.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "c" or num == 3: if self.c.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "d" or num == 4: if self.d.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "e" or num == 5: if self.e.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "f" or num == 6: if self.f.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "g" or num == 7: if self.g.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "h" or num == 8: if self.h.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "i" or num == 9: if self.i.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "j" or num == 10: if self.j.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "k" or num == 11: if self.k.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "l" or num == 12: if self.l.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "m" or num == 13: if self.m.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "n" or num == 14: if self.n.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "o" or num == 15: if self.o.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) elif num == "p" or num == 16: if self.p.PararCelda(): print("[" + str(datetime.datetime.now()) + "][DIND]- parando celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND]- no se pudo parar celda", file=log) else: print("[" + str(datetime.datetime.now()) + "][DIND] - parar celda - Atrib error", file=log) def xGetCondTiempoReal(self, num): if num == "a" or num == 1: corriente = self.a.microAmperes ciclos = self.a.barridoActual voltios = self.a.milivoltios ingresos = self.a.ingresos tiempoTot = self.a.segundos tiempoCAct = self.a.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "b" or num == 2: corriente = self.b.microAmperes ciclos = self.b.barridoActual voltios = self.b.milivoltios ingresos = self.b.ingresos tiempoTot = self.b.segundos tiempoCAct = self.b.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "c" or num == 3: corriente = self.c.microAmperes ciclos = self.c.barridoActual voltios = self.c.milivoltios ingresos = self.c.ingresos tiempoTot = self.c.segundos tiempoCAct = self.c.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "d" or num == 4: corriente = self.d.microAmperes ciclos = self.d.barridoActual voltios = self.d.milivoltios ingresos = self.d.ingresos tiempoTot = self.d.segundos tiempoCAct = self.d.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "e" or num == 5: corriente = self.e.microAmperes ciclos = self.e.barridoActual voltios = self.e.milivoltios ingresos = self.e.ingresos tiempoTot = self.e.segundos tiempoCAct = self.e.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "f" or num == 6: corriente = self.f.microAmperes ciclos = self.f.barridoActual voltios = self.f.milivoltios ingresos = self.f.ingresos tiempoTot = self.f.segundos tiempoCAct = self.f.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "g" or num == 7: corriente = self.g.microAmperes ciclos = self.g.barridoActual voltios = self.g.milivoltios ingresos = self.g.ingresos tiempoTot = self.g.segundos tiempoCAct = self.g.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "h" or num == 8: corriente = self.h.microAmperes ciclos = self.h.barridoActual voltios = self.h.milivoltios ingresos = self.h.ingresos tiempoTot = self.h.segundos tiempoCAct = self.h.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "i" or num == 9: corriente = self.i.microAmperes ciclos = self.i.barridoActual voltios = self.i.milivoltios ingresos = self.i.ingresos tiempoTot = self.i.segundos tiempoCAct = self.i.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "j" or num == 10: corriente = self.j.microAmperes ciclos = self.j.barridoActual voltios = self.j.milivoltios ingresos = self.j.ingresos tiempoTot = self.j.segundos tiempoCAct = self.j.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "k" or num == 11: corriente = self.k.microAmperes ciclos = self.k.barridoActual voltios = self.k.milivoltios ingresos = self.k.ingresos tiempoTot = self.k.segundos tiempoCAct = self.k.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "l" or num == 12: corriente = self.l.microAmperes ciclos = self.l.barridoActual voltios = self.l.milivoltios ingresos = self.l.ingresos tiempoTot = self.l.segundos tiempoCAct = self.l.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "m" or num == 13: corriente = self.m.microAmperes ciclos = self.m.barridoActual voltios = self.m.milivoltios ingresos = self.m.ingresos tiempoTot = self.m.segundos tiempoCAct = self.m.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "n" or num == 14: corriente = self.n.microAmperes ciclos = self.n.barridoActual voltios = self.n.milivoltios ingresos = self.n.ingresos tiempoTot = self.n.segundos tiempoCAct = self.n.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "o" or num == 15: corriente = self.o.microAmperes ciclos = self.o.barridoActual voltios = self.o.milivoltios ingresos = self.o.ingresos tiempoTot = self.o.segundos tiempoCAct = self.o.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct if num == "p" or num == 16: corriente = self.p.microAmperes ciclos = self.p.barridoActual voltios = self.p.milivoltios ingresos = self.p.ingresos tiempoTot = self.p.segundos tiempoCAct = self.p.tiempoCicloActual return corriente, ciclos, voltios, ingresos, tiempoTot, tiempoCAct def xGetCondGuardado(self, num): if num == "a" or num == 1: corriente = self.a.corrienteSetActual ciclos = self.a.barridosMax vli = self.a.voltajeLimInferior vls = self.a.voltajeLimSuperior tmax = self.a.tiempoMaxBarrido prom = self.a.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "b" or num == 2: corriente = self.b.corrienteSetActual ciclos = self.b.barridosMax vli = self.b.voltajeLimInferior vls = self.b.voltajeLimSuperior tmax = self.b.tiempoMaxBarrido prom = self.b.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "c" or num == 3: corriente = self.c.corrienteSetActual ciclos = self.c.barridosMax vli = self.c.voltajeLimInferior vls = self.c.voltajeLimSuperior tmax = self.c.tiempoMaxBarrido prom = self.c.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "d" or num == 4: corriente = self.d.corrienteSetActual ciclos = self.d.barridosMax vli = self.d.voltajeLimInferior vls = self.d.voltajeLimSuperior tmax = self.d.tiempoMaxBarrido prom = self.d.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "e" or num == 5: corriente = self.e.corrienteSetActual ciclos = self.e.barridosMax vli = self.e.voltajeLimInferior vls = self.e.voltajeLimSuperior tmax = self.e.tiempoMaxBarrido prom = self.e.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "f" or num == 6: corriente = self.f.corrienteSetActual ciclos = self.f.barridosMax vli = self.f.voltajeLimInferior vls = self.f.voltajeLimSuperior tmax = self.f.tiempoMaxBarrido prom = self.f.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "g" or num == 7: corriente = self.g.corrienteSetActual ciclos = self.g.barridosMax vli = self.g.voltajeLimInferior vls = self.g.voltajeLimSuperior tmax = self.g.tiempoMaxBarrido prom = self.g.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "h" or num == 8: corriente = self.h.corrienteSetActual ciclos = self.h.barridosMax vli = self.h.voltajeLimInferior vls = self.h.voltajeLimSuperior tmax = self.h.tiempoMaxBarrido prom = self.h.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "i" or num == 9: corriente = self.i.corrienteSetActual ciclos = self.i.barridosMax vli = self.i.voltajeLimInferior vls = self.i.voltajeLimSuperior tmax = self.i.tiempoMaxBarrido prom = self.i.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "j" or num == 10: corriente = self.j.corrienteSetActual ciclos = self.j.barridosMax vli = self.j.voltajeLimInferior vls = self.j.voltajeLimSuperior tmax = self.j.tiempoMaxBarrido prom = self.j.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "k" or num == 11: corriente = self.k.corrienteSetActual ciclos = self.k.barridosMax vli = self.k.voltajeLimInferior vls = self.k.voltajeLimSuperior tmax = self.k.tiempoMaxBarrido prom = self.k.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "l" or num == 12: corriente = self.l.corrienteSetActual ciclos = self.l.barridosMax vli = self.l.voltajeLimInferior vls = self.l.voltajeLimSuperior tmax = self.l.tiempoMaxBarrido prom = self.l.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "m" or num == 13: corriente = self.m.corrienteSetActual ciclos = self.m.barridosMax vli = self.m.voltajeLimInferior vls = self.m.voltajeLimSuperior tmax = self.m.tiempoMaxBarrido prom = self.m.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "n" or num == 14: corriente = self.n.corrienteSetActual ciclos = self.n.barridosMax vli = self.n.voltajeLimInferior vls = self.n.voltajeLimSuperior tmax = self.n.tiempoMaxBarrido prom = self.n.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "o" or num == 15: corriente = self.o.corrienteSetActual ciclos = self.o.barridosMax vli = self.o.voltajeLimInferior vls = self.o.voltajeLimSuperior tmax = self.o.tiempoMaxBarrido prom = self.o.promediado return corriente, ciclos, vli, vls, tmax, prom if num == "p" or num == 16: corriente = self.p.corrienteSetActual ciclos = self.p.barridosMax vli = self.p.voltajeLimInferior vls = self.p.voltajeLimSuperior tmax = self.p.tiempoMaxBarrido prom = self.p.promediado return corriente, ciclos, vli, vls, tmax, prom def xActualizoCampo(self, num, tension, corriente, tiempo): if num == "a" or num == 1: return self.a.ActualizoCampos(tiempo, tension, corriente) elif num == "b" or num == 2: return self.b.ActualizoCampos(tiempo, tension, corriente) elif num == "c" or num == 3: return self.c.ActualizoCampos(tiempo, tension, corriente) elif num == "d" or num == 4: return self.d.ActualizoCampos(tiempo, tension, corriente) elif num == "e" or num == 5: return self.e.ActualizoCampos(tiempo, tension, corriente) elif num == "f" or num == 6: return self.f.ActualizoCampos(tiempo, tension, corriente) elif num == "g" or num == 7: return self.g.ActualizoCampos(tiempo, tension, corriente) elif num == "h" or num == 8: return self.h.ActualizoCampos(tiempo, tension, corriente) elif num == "i" or num == 9: return self.i.ActualizoCampos(tiempo, tension, corriente) elif num == "j" or num == 10: return self.j.ActualizoCampos(tiempo, tension, corriente) elif num == "k" or num == 11: return self.k.ActualizoCampos(tiempo, tension, corriente) elif num == "l" or num == 12: return self.l.ActualizoCampos(tiempo, tension, corriente) elif num == "m" or num == 13: return self.m.ActualizoCampos(tiempo, tension, corriente) elif num == "n" or num == 14: return self.n.ActualizoCampos(tiempo, tension, corriente) elif num == "o" or num == 15: return self.o.ActualizoCampos(tiempo, tension, corriente) elif num == "p" or num == 16: return self.p.ActualizoCampos(tiempo, tension, corriente) else: print("[" + str(datetime.datetime.now()) + "][DIND|xActCampo] - Atrib error", file=log) """ def xGetBarrYTiempo(self, num): if num == "a" or 1: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "b" or 2: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "c" or 3: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "d" or 4: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "e" or 5: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "f" or 6: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "g" or 7: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "h" or 8: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "i" or 9: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "j" or 10: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "k" or 11: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "l" or 12: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "m" or 13: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "n" or 14: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "o" or 15: return self.a.barridoActual, self.a.tiempoCicloActual elif num == "p" or 16: return self.a.barridoActual, self.a.tiempoCicloActual else: print( "["+str(datetime.datetime.now())+"][DIND|xGetBarryT- Atrib error", file=log) def xGetValTiempoReal(self, num): if num == "a" or 1: return self.a.barridoActual, self.a.milivoltios, self.a.microAmperes, self.a.tiempoCicloActual elif num == "b" or 2: return self.b.barridoActual, self.b.milivoltios, self.b.microAmperes, self.b.tiempoCicloActual elif num == "c" or 3: return self.c.barridoActual, self.c.milivoltios, self.c.microAmperes, self.c.tiempoCicloActual elif num == "d" or 4: return self.d.barridoActual, self.d.milivoltios, self.d.microAmperes, self.d.tiempoCicloActual elif num == "e" or 5: return self.e.barridoActual, self.e.milivoltios, self.e.microAmperes, self.e.tiempoCicloActual elif num == "f" or 6: return self.f.barridoActual, self.f.milivoltios, self.f.microAmperes, self.f.tiempoCicloActual elif num == "g" or 7: return self.g.barridoActual, self.g.milivoltios, self.g.microAmperes, self.g.tiempoCicloActual elif num == "h" or 8: return self.h.barridoActual, self.h.milivoltios, self.h.microAmperes, self.h.tiempoCicloActual elif num == "i" or 9: return self.i.barridoActual, self.i.milivoltios, self.i.microAmperes, self.i.tiempoCicloActual elif num == "j" or 10: return self.j.barridoActual, self.j.milivoltios, self.j.microAmperes, self.j.tiempoCicloActual elif num == "k" or 11: return self.k.barridoActual, self.k.milivoltios, self.k.microAmperes, self.k.tiempoCicloActual elif num == "l" or 12: return self.l.barridoActual, self.l.milivoltios, self.l.microAmperes, self.l.tiempoCicloActual elif num == "m" or 13: return self.m.barridoActual, self.m.milivoltios, self.m.microAmperes, self.m.tiempoCicloActual elif num == "n" or 14: return self.n.barridoActual, self.n.milivoltios, self.n.microAmperes, self.n.tiempoCicloActual elif num == "o" or 15: return self.o.barridoActual, self.o.milivoltios, self.o.microAmperes, self.o.tiempoCicloActual elif num == "p" or 16: return self.p.barridoActual, self.p.milivoltios, self.p.microAmperes, self.p.tiempoCicloActual else: print( "datos independientes - Atrib error", file=log) """ """tengo que devolver""" #celda = char #corriente = por setearle def xGetPorSetear(self): celda = self.celdasAenviar[self.enColaPorEnviar() - 1] corriente, a, b, c, d, e = self.xGetCondGuardado(celda) print("[" + str(datetime.datetime.now()) + "][DIND] xget por setear " + str(celda) + " " + str(corriente), file=log) return celda, corriente def AllDisable(self): algunaActiva = (self.a.activa or self.b.activa or self.c.activa or self.d.activa or self.e.activa or self.f.activa or self.g.activa or self.h.activa or self.i.activa or self.j.activa or self.k.activa or self.l.activa or self.m.activa or self.n.activa or self.o.activa or self.o.activa) return algunaActiva
class LECTURA(QtCore.QThread): def __init__( self, dequePLOT, dequeIN, dequeOUT, port_num='/dev/ttyUSB0', #port_num='/dev/ttyACM0', port_baud=115200, port_stopbits=serial.STOPBITS_ONE, port_parity=serial.PARITY_NONE, port_timeout=0.1, parent=None): QtCore.QThread.__init__(self) self.daemon = True self.mutex = QMutex() self.serial_port = None self.serial_arg = dict(port=port_num, baudrate=port_baud, stopbits=port_stopbits, parity=port_parity, timeout=port_timeout) self.signal = QtCore.SIGNAL("signal") self.CONTENEDORplot = dequePLOT self.dequeIN = dequeIN self.dequeOUT = dequeOUT def __del__(self): self.wait( ) # This will (should) ensure that the thread stops processing before it gets destroyed. def run(self): try: if self.serial_port: self.serial_port.close() self.serial_port = serial.Serial(**self.serial_arg) except serial.SerialException: print("[" + str(datetime.datetime.now()) + "][PORT] error en el try del serial port", file=log) return while self.serial_port.is_open: time.sleep(0.00001) #puede llegar a necesitar estar mas alto flagSend = False try: recepcion = self.RecibirPS() + '#' + str(time.time() - 1500000000) except: recepcion = "$#$#$#$" separado = recepcion.split('#', 4) # [char(celda), string(tension), string(corriente), string(tiempo)] """variables para guardado""" if separado[0].startswith("ok"): self.mutex.lock() print("[" + str(datetime.datetime.now()) + "][PORT mensaje ok completo " + str(separado), file=log) self.dequeOUT.append(["OK!", celda, None, Corriente, None]) self.mutex.unlock() elif separado[0] != '$' or separado[1] != '$' or separado[ 2] != '$' or len(separado) != 4: try: celda = separado[0] except: celda = "x" """conversion de tension (pasa a mV)""" try: Tension = int((int(separado[1]) * (0.375)) - 6144) except: Tension = "NAN" #(-1)*int((int(separado[1])*(3.0/8))-6144) """conversion de corriente (pasa a uA)""" try: Corriente = int(separado[2]) - 1024 except: Corriente = "NAN" try: Tiempo = float(separado[3]) except: Tiempo = "NAN" #Append en la deque de salida if celda != "x" and Tension != "NAN" and Corriente != "NAN" and Tiempo != "NAN": self.mutex.lock() self.dequeOUT.append( ["RAW", celda, Tension, Corriente, Tiempo]) self.mutex.unlock() if int(len(self.dequeIN)) > 0: self.mutex.lock() [mensaje, celda, Corriente] = self.dequeIN.pop() #print "mensaje y demas " + str([mensaje, celda, Corriente]) self.mutex.unlock() """Ninguna activa""" if mensaje is "END": print("[" + str(datetime.datetime.now()) + "][PORT] cortando loop de lectura", file=log) break """Hay celdas por setear""" if 112 >= ord(celda) >= 97: if mensaje == "SETI": correccion = self.CargoCorreccion(celda) print("[" + str(datetime.datetime.now()) + "][PORT|" + str(celda) + "] SETI arrived with " + str(Corriente) + " corrijo con: " + str(correccion), file=log) self.EnviarPS_I(Corriente + correccion, celda) # clean up if self.serial_port: self.serial_port.close() def CargoCorreccion(self, celda): lines = [] try: with open("correccionI.txt", "rt") as in_file: for line in in_file: lines.append(line) for i in range(lines.__len__()): if i == self.NumDeCelda(celda): return int(lines[i][2:-1]) except: return 0 def EnviarPS_I(self, ua, celda): print("[" + str(datetime.datetime.now()) + "][PORT|send] celda a enviar " + str(celda) + " len es: " + str(len(celda)), file=log) self.serial_port.write_timeout = 0.3 """si uso el time out de escritura meter un try catch""" # I=0 con uA=0 en cualquier descarga # 2 unidades = 1uA 2048 =0A MatConv = [['h', 2], ['f', 2], ['d', 2], ['b', 2], ['h', 1], ['f', 1], ['d', 1], ['b', 1], ['e', 2], ['g', 2], ['a', 2], ['c', 2], ['e', 1], ['g', 1], ['a', 1], ['c', 1]] # cada renglon es el orden en asccii, dentro la primer columna es el caracter dentro del dac cuyo numero es la otra # letra a enviar MatConv[NumDeCelda(str(celda))][0] # numero a enviar MatConv[NumDeCelda(str(celda))][1] ####################################################################V #si esta invertida la corriente tiene que ser por esto if ua < 0: Descarga = True else: Descarga = False if Descarga: num = int(2048 - (abs(ua) * 2)) else: num = int((abs(ua) * 2) + 2048) print("[" + str(datetime.datetime.now()) + "][PORT|send] abs(ua): " + str(abs(ua)) + " " + str(type(ua)) + "Descarga: " + str(Descarga) + " " + str(type(Descarga)) + "Celda: " + str(celda) + " " + str(type(celda))) if 0 <= num <= 4095: mil = num / 1000 cien = (num - mil * 1000) / 100 die = (num - mil * 1000 - cien * 100) / 10 un = (num - mil * 1000 - cien * 100 - die * 10) try: # inicio self.serial_port.write('i') # time.sleep(0.25) self.serial_port.write(str(mil)) # 1 # time.sleep(0.25) self.serial_port.write(str(cien)) # 2 # time.sleep(0.25) self.serial_port.write(str(die)) # 3 # time.sleep(0.25) self.serial_port.write(str(un)) # 4 # time.sleep(0.25) self.serial_port.write(str(MatConv[self.NumDeCelda(celda)][0])) # time.sleep(0.25) self.serial_port.write(str(MatConv[self.NumDeCelda(celda)][1])) # time.sleep(0.25) self.serial_port.write('f') # time.sleep(0.25) self.serial_port.flushInput() except serial.SerialTimeoutException: print("[" + str(datetime.datetime.now()) + "][PORT|send] timeOut de envio Serie", file=log) else: print("[" + str(datetime.datetime.now()) + "][PORT|send] numero incorrecto", file=log) def RecibirPS(self): s = self.serial_port.readline() #print 'Limpio: "' + str(s) #+ '"' + "len es: " + str(len(s)) # print 's-1' + s[len(s)-1] # print 'Cortado: "' + s +'"' if len(s) == 13: s = s[:len(s) - 1] #print "["+str(datetime.datetime.now())+"][PORT] "+ str(s) return s elif len(s) <= 4: s = s[:len(s) - 1] return s else: return '$#$#$' def NumDeCelda(self, celda): for i in range(len(string.ascii_letters)): if celda == string.ascii_letters[i]: return i
class queue: def __init__(self, maxSize=10): self.maxSize = maxSize self._q = deque() self.mutex = QMutex() def urgentFrame(self, item): self.mutex.lock() self._q.clear() self._q.appendleft(item) self.mutex.unlock() def push(self, item): self.mutex.lock() self._q.appendleft(item) self.mutex.unlock() def pop(self): self.mutex.lock() item = self._q.pop() self.mutex.unlock() return item def size(self): return len(self._q) def isEmpty(self): return len(self._q) == 0