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
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)
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 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 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
def __init__(self, maxSize=10):
self.maxSize = maxSize
self._q = deque()
self.mutex = QMutex()
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
