示例#1
0
 def on_push_about_pressed(self):
     if not hasattr(self, 'about_dlg'):
         self.about_dlg = AboutDialog()
     self.about_dlg.exec_()
示例#2
0
文件: mainwin.py 项目: D3f0/txscada
 def on_push_about_pressed(self):
     if not hasattr(self, 'about_dlg'):
         self.about_dlg = AboutDialog()
     self.about_dlg.exec_()
示例#3
0
class MainWin(Ui_Form, QtGui.QWidget):
    '''
    Ventana principal del programa
    '''
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.setupUi(self)
        self.validador_hex = QtGui.QRegExpValidator(
            QtCore.QRegExp("([abcdefABCDEF\\d]{1,2}\\s)*"), self)
        # Inicializamos la entrada como entrada HEXA
        self.entrada_hexa()
        self.cfgsocket_dlg = SocketCfgDialog()
        # Hilo para atencion del socket
        self.socket_thread = SocketThread(self)
        self.connect(self.socket_thread, QtCore.SIGNAL('socket_error'),
                     self.handle_socket_error)
        self.connect(self.socket_thread, QtCore.SIGNAL('socket_connected'),
                     self.handle_socket_connected)
        self.connect(self.socket_thread, QtCore.SIGNAL('socket_received'),
                     self.handle_received)
        # Estado privado
        self.__socket_conectado = False
        self.__serial_conectado = False

        # self.socket_conectado = True

        # Configuración del puerto serie
        self.cfgserial_dlg = CfgSerialDialog()
        self.serial_thread = SerialThread(self)
        self.connect(self.serial_thread, QtCore.SIGNAL('serial_error'),
                     self.handle_serial_error)
        self.connect(self.serial_thread, QtCore.SIGNAL('serial_connect'),
                     self.handle_serial_connect)
        self.connect(self.serial_thread, QtCore.SIGNAL('serial_received'),
                     self.handle_received)
        # String de aplicacion
        self.lineAppString.setValidator(self.validador_hex)
        self.lineMemoryData.setValidator(self.validador_hex)

        # Rango de microcontroladores
        self.lineDirRange.setValidator(
            QtGui.QRegExpValidator(
                QtCore.QRegExp(r'^[(\d{1,3})(\d{1,3}\-\d{1,3})\s]*$'), self))

        self.connect(self, QtCore.SIGNAL('send'), self.handle_send)

    def set_socket_conectado(self, estado):
        ''' Setter '''
        self.__socket_conectado = estado
        if estado:
            self.check_envio_socket.setEnabled(True)
            self.pushConnect_socket.setText('Desconectar')
            self.label_status_socket.setText('Conectado')
        else:
            self.check_envio_socket.setEnabled(False)
            self.pushConnect_socket.setText('Conectar')
            self.label_status_socket.setText('Desconectado')

    def get_socket_conectado(self):
        ''' Getter '''
        return self.__socket_conectado

    def set_serial_conectado(self, estado):
        ''' Setter '''
        self.__serial_conectado = estado
        if estado:
            self.check_envio_serial.setEnabled(True)
            self.pushConnect_serial.setText('Desconectar')
            self.labelConexionSerial.setText('Conectado')
        else:
            self.check_envio_serial.setEnabled(False)
            self.pushConnect_serial.setText('Conectar')
            self.labelConexionSerial.setText('Desconectado')

    def get_serial_conectado(self):
        ''' Getter '''
        return self.__serial_conectado

    socket_conectado = property(get_socket_conectado, set_socket_conectado)
    serial_conectado = property(get_serial_conectado, set_serial_conectado)

    @QtCore.pyqtSignature('QString')
    def on_combo_modo_currentIndexChanged(self, modo):
        ''' Cambio del modo en el que se interpreta la lina de entrada '''
        modo = str(modo).lower()  # De QString a str de python
        texto = str(self.line_envio.text())

        if modo == 'hexadecimal':
            self.entrada_hexa()
            # Pasamos el contenido a hexa
            self.line_envio.setText(str2hexa(texto))

        elif modo == 'ascii':
            self.entrada_ascii()
            # Pasamos el contenido a Hexa
            self.line_envio.setText(hexa2str(texto))

        self.line_envio.setFocus()

    def entrada_hexa(self):
        ''' Establece la entrada como HEXADECIMAL'''
        self.line_envio.setValidator(self.validador_hex)
        self.line_envio.setToolTip('Aceptando solo entrada Hexadecimal')

    def entrada_ascii(self):
        ''' Establece la entrada como ASCII'''
        self.line_envio.setValidator(None)
        self.line_envio.setToolTip('Aceptando entrada ASCII')

    def on_push_about_pressed(self):
        if not hasattr(self, 'about_dlg'):
            self.about_dlg = AboutDialog()
        self.about_dlg.exec_()

    def on_pushConf_socket_pressed(self):
        val = self.cfgsocket_dlg.exec_()

    def on_pushConnect_socket_pressed(self):
        if not self.socket_conectado:
            self.emit(QtCore.SIGNAL('do_connect'),
                      self.cfgsocket_dlg.get_addr(),
                      self.cfgsocket_dlg.get_timeout())
            self.pushConnect_socket.setText('Conectando...')
        else:
            self.emit(QtCore.SIGNAL('do_disconnect'))
            self.socket_conectado = False

    def handle_socket_error(self, e):
        print "Error de socket:", e
        self.socket_conectado = False

    def handle_socket_connected(self):
        self.socket_conectado = True

    def handle_received(self, data):
        ''' Recibir datos '''
        if self.check_del_slashn.isChecked():
            data = data.rstrip('\n')
        if self.check_recv_hexa.isChecked():
            data = str2hexa(data)
        self.textReceived.appendPlainText(data)

    def on_pushConf_serial_pressed(self):
        val = self.cfgserial_dlg.exec_()
        print self.cfgserial_dlg.get_config()

    def on_pushConnect_serial_pressed(self):
        if not self.serial_conectado:
            self.emit(QtCore.SIGNAL("do_connect_serial"),
                      self.cfgserial_dlg.get_config())
        else:
            self.emit(QtCore.SIGNAL("do_disconnect_serial"))
            self.serial_conectado = False

    def handle_serial_connect(self):
        self.serial_conectado = True
        print "Serial conectado"

    def handle_serial_error(self, error):
        pass

    def on_pushEnviar_pressed(self):
        '''
        Envio de la cadena
        '''
        cadena = str(self.line_envio.text())
        if not cadena:
            return
        print "Serial, Socket:", self.serial_conectado, self.socket_conectado
        if not self.serial_conectado and not self.socket_conectado:
            QtGui.QMessageBox.information(
                self, 'No se puede enviar', '''
                Para poder enviar conectese mediante un socket o por RS232
            ''')
            return
        if not self.check_envio_socket.isChecked() and not \
            self.check_envio_serial.isChecked():
            QtGui.QMessageBox.information(
                self, 'No se puede enviar', '''
                Habilite al menos una forma de envio
            ''')
            return

        if str(self.combo_modo.currentText()).lower().count('hexa'):
            cadena = hexa2str(cadena)
        print "Envio"
        self.emit(QtCore.SIGNAL('send'), cadena)

    def on_check_envio_serial_stateChanged(self, state):
        ''' Envio sobre serial '''
        if state == QtCore.Qt.Checked:
            self.connect(self, QtCore.SIGNAL('send'), self.serial_thread.send)
        else:
            self.disconnect(self, QtCore.SIGNAL('send'),
                            self.serial_thread.send)

    def on_check_envio_socket_stateChanged(self, state):
        ''' Envio sobre socket '''
        if state == QtCore.Qt.Checked:
            self.connect(self, QtCore.SIGNAL('send'), self.socket_thread.send)
        else:
            self.disconnect(self, QtCore.SIGNAL('send'),
                            self.socket_thread.send)

    def handle_send(self, data):
        if self.check_send_hexa.isChecked():
            data = str2hexa(data)
        self.textEnvio.appendPlainText(data)

    # Getters y setters para secuencia

    def get_secuencia(self):
        ''' Maneja el numero de secuencia '''
        prev = val = self.spinSecuencia.value()
        val += 1
        if val > self.spinSecuencia.maximum():
            val = self.spinSecuencia.minimum()
        self.spinSecuencia.setValue(val)
        return prev

    def set_secuencia(self, valor):
        self.spinSecuencia.setValue(valor)

    # Propiedad para la secuencia
    secuencia = property(get_secuencia, set_secuencia)

    def get_orgien(self):
        return self.spinOrigen.value()

    def set_origen(self, valor):
        self.spinOrigen.setValue(valor)

    origen = property(get_orgien, set_origen)

    def get_destino(self):
        return self.spinDestino.value()

    def set_destino(self, valor):
        self.spinDestino.setValue(valor)

    destino = property(get_destino, set_destino)

    # Manejo de los botones de enviar comando
    def on_pushSendReqEv_pressed(self):
        pkg = Paquete.crear_estados_y_eventos(self.origen, self.destino,
                                              self.secuencia)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())

    def on_pushSendReqMorEv_pressed(self):
        pkg = Paquete.crear_mas_eventos(self.origen, self.destino,
                                        self.secuencia)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())

    def on_pushControl_pressed(self):
        puerto = self.spinPuerto.value()
        bit = self.spinBit.value()
        estado = self.radioBitUno.isChecked() and 1 or 0
        indirecto = self.checkIndirecto.isChecked()
        pkg = Paquete.crear_control(self.origen,
                                    self.destino,
                                    self.secuencia,
                                    puerto,
                                    bit,
                                    estado,
                                    es_comando_indirecto=indirecto)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())

    def on_pushLeerRam_pressed(self):
        pagina = self.spinPagina.value()
        direccion = self.spinDireccion.value()
        cantidad = self.spinCantidad.value()
        pkg = Paquete.crear_lectura_ram(self.origen, self.destino,
                                        self.secuencia, pagina, direccion,
                                        cantidad)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())

    def on_pushLeerEE_pressed(self):
        pagina = self.spinPagina.value()
        direccion = self.spinDireccion.value()
        cantidad = self.spinCantidad.value()
        pkg = Paquete.crear_lectura_eeprom(self.origen, self.destino,
                                           self.secuencia, pagina, direccion,
                                           cantidad)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())

    def on_pushPuestaEnHora_pressed(self):
        #QtGui.QMessageBox.information(self, 'hola', 'Hola')
        pkg = Paquete.crear_puesta_en_hora(self.origen, self.destino,
                                           self.secuencia)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())

    def on_pushEnviarAppString_pressed(self):
        lista = [
            int(x, 16) for x in str(self.lineAppString.text()).split()
            if len(x)
        ]
        pkg = Paquete.crear_paquete_custom(self.origen, self.destino,
                                           self.secuencia, lista)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())

    #@QtCore.pyqtSignature('int')
    def on_checkRequerirEstados_stateChanged(self, state):
        if state == QtCore.Qt.Checked:
            print "Requerir estados"
        else:
            print "No requerir mas eventos"

    def on_checkRequerirEventos_stateChanged(self, state):
        if state == QtCore.Qt.Checked:
            print "Requerir eventos"
        else:
            print "No requerir mas eventos"

    #TODO: Implementar esto
    def on_pushHex2Bin_pressed(self):
        valor, ok = QtGui.QInputDialog.getText(self, "Ingrese un entero",
                                               "Entro a convertir")
        try:
            pass
        except:
            pass
示例#4
0
文件: mainwin.py 项目: D3f0/txscada
class MainWin(Ui_Form, QtGui.QWidget):
    '''
    Ventana principal del programa
    '''
    def __init__(self, parent = None):
        QtGui.QWidget.__init__(self, parent)
        self.setupUi(self)
        self.validador_hex = QtGui.QRegExpValidator(QtCore.QRegExp("([abcdefABCDEF\\d]{1,2}\\s)*"), self)
        # Inicializamos la entrada como entrada HEXA
        self.entrada_hexa()
        self.cfgsocket_dlg = SocketCfgDialog()
        # Hilo para atencion del socket
        self.socket_thread = SocketThread(self)
        self.connect(self.socket_thread, QtCore.SIGNAL('socket_error'), self.handle_socket_error)
        self.connect(self.socket_thread, QtCore.SIGNAL('socket_connected'), self.handle_socket_connected)
        self.connect(self.socket_thread, QtCore.SIGNAL('socket_received'), self.handle_received)
        # Estado privado
        self.__socket_conectado = False
        self.__serial_conectado = False
        
        # self.socket_conectado = True
        
        # Configuración del puerto serie
        self.cfgserial_dlg = CfgSerialDialog()
        self.serial_thread = SerialThread(self)
        self.connect(self.serial_thread, QtCore.SIGNAL('serial_error'), self.handle_serial_error)
        self.connect(self.serial_thread, QtCore.SIGNAL('serial_connect'), self.handle_serial_connect)
        self.connect(self.serial_thread, QtCore.SIGNAL('serial_received'), self.handle_received)
        # String de aplicacion
        self.lineAppString.setValidator(self.validador_hex)
        self.lineMemoryData.setValidator(self.validador_hex)
        
        # Rango de microcontroladores
        self.lineDirRange.setValidator(QtGui.QRegExpValidator(QtCore.QRegExp(r'^[(\d{1,3})(\d{1,3}\-\d{1,3})\s]*$'),self))
        
        self.connect(self, QtCore.SIGNAL('send'), self.handle_send)
        
        
    def set_socket_conectado(self, estado):
        ''' Setter '''
        self.__socket_conectado = estado
        if estado:
            self.check_envio_socket.setEnabled(True)
            self.pushConnect_socket.setText('Desconectar')
            self.label_status_socket.setText('Conectado')
        else:
            self.check_envio_socket.setEnabled(False)
            self.pushConnect_socket.setText('Conectar')
            self.label_status_socket.setText('Desconectado')
    
    def get_socket_conectado(self):
        ''' Getter '''
        return self.__socket_conectado
        
    def set_serial_conectado(self, estado):
        ''' Setter '''
        self.__serial_conectado = estado
        if estado:
            self.check_envio_serial.setEnabled(True)
            self.pushConnect_serial.setText('Desconectar')
            self.labelConexionSerial.setText('Conectado')
        else:
            self.check_envio_serial.setEnabled(False)
            self.pushConnect_serial.setText('Conectar')
            self.labelConexionSerial.setText('Desconectado')
    
    def get_serial_conectado(self):
        ''' Getter '''
        return self.__serial_conectado
    
    socket_conectado = property(get_socket_conectado, set_socket_conectado)
    serial_conectado = property(get_serial_conectado, set_serial_conectado)
        
    @QtCore.pyqtSignature('QString')
    def on_combo_modo_currentIndexChanged(self, modo):
        ''' Cambio del modo en el que se interpreta la lina de entrada '''
        modo = str(modo).lower() # De QString a str de python
        texto = str(self.line_envio.text())
        
        if modo == 'hexadecimal':
            self.entrada_hexa()
            # Pasamos el contenido a hexa
            self.line_envio.setText(str2hexa(texto))
            
        elif modo == 'ascii':
            self.entrada_ascii()
            # Pasamos el contenido a Hexa
            self.line_envio.setText(hexa2str(texto))
            
        self.line_envio.setFocus()
            
    def entrada_hexa(self):
        ''' Establece la entrada como HEXADECIMAL'''
        self.line_envio.setValidator(self.validador_hex)
        self.line_envio.setToolTip('Aceptando solo entrada Hexadecimal')
        
    def entrada_ascii(self):
        ''' Establece la entrada como ASCII'''
        self.line_envio.setValidator(None)
        self.line_envio.setToolTip('Aceptando entrada ASCII')
    
    def on_push_about_pressed(self):
        if not hasattr(self, 'about_dlg'):
            self.about_dlg = AboutDialog()
        self.about_dlg.exec_()
        
    def on_pushConf_socket_pressed(self):
        val = self.cfgsocket_dlg.exec_()
        
    def on_pushConnect_socket_pressed(self):
        if not self.socket_conectado:
            self.emit(QtCore.SIGNAL('do_connect'), self.cfgsocket_dlg.get_addr(), 
                        self.cfgsocket_dlg.get_timeout())
            self.pushConnect_socket.setText('Conectando...')
        else:
            self.emit(QtCore.SIGNAL('do_disconnect'))
            self.socket_conectado = False
        
    def handle_socket_error(self, e):
        print "Error de socket:", e
        self.socket_conectado = False
    
    def handle_socket_connected(self):
        self.socket_conectado = True
        
    def handle_received(self, data):
        ''' Recibir datos '''
        if self.check_del_slashn.isChecked():
            data = data.rstrip('\n')
        if self.check_recv_hexa.isChecked():
            data = str2hexa(data)
        self.textReceived.appendPlainText(data)
    
    def on_pushConf_serial_pressed(self):
        val = self.cfgserial_dlg.exec_()
        print self.cfgserial_dlg.get_config()
        
    def on_pushConnect_serial_pressed(self):
        if not self.serial_conectado:
            self.emit(QtCore.SIGNAL("do_connect_serial"), self.cfgserial_dlg.get_config())
        else:
            self.emit(QtCore.SIGNAL("do_disconnect_serial"))
            self.serial_conectado = False
            
    def handle_serial_connect(self):
        self.serial_conectado = True
        print "Serial conectado"
        
    def handle_serial_error(self, error):
        pass
    
    def on_pushEnviar_pressed(self):
        '''
        Envio de la cadena
        '''
        cadena = str(self.line_envio.text())
        if not cadena:
            return
        print "Serial, Socket:", self.serial_conectado, self.socket_conectado
        if not self.serial_conectado and not self.socket_conectado:
            QtGui.QMessageBox.information(self, 'No se puede enviar', '''
                Para poder enviar conectese mediante un socket o por RS232
            ''')
            return
        if not self.check_envio_socket.isChecked() and not \
            self.check_envio_serial.isChecked():
            QtGui.QMessageBox.information(self, 'No se puede enviar', '''
                Habilite al menos una forma de envio
            ''')
            return
        
        if str(self.combo_modo.currentText()).lower().count('hexa'):
            cadena = hexa2str(cadena)
        print "Envio"
        self.emit(QtCore.SIGNAL('send'), cadena)
            
    def on_check_envio_serial_stateChanged(self, state):
        ''' Envio sobre serial '''
        if state == QtCore.Qt.Checked:
            self.connect(self, QtCore.SIGNAL('send'), self.serial_thread.send)
        else:
            self.disconnect(self, QtCore.SIGNAL('send'), self.serial_thread.send)
    
    def on_check_envio_socket_stateChanged(self, state):
        ''' Envio sobre socket '''
        if state == QtCore.Qt.Checked:
            self.connect(self, QtCore.SIGNAL('send'), self.socket_thread.send)
        else:
            self.disconnect(self, QtCore.SIGNAL('send'), self.socket_thread.send)
    
    def handle_send(self, data):
        if self.check_send_hexa.isChecked():
            data = str2hexa(data)
        self.textEnvio.appendPlainText(data)
    
    # Getters y setters para secuencia
    
    def get_secuencia(self):
        ''' Maneja el numero de secuencia '''
        prev = val = self.spinSecuencia.value()
        val += 1
        if val > self.spinSecuencia.maximum():
            val = self.spinSecuencia.minimum()
        self.spinSecuencia.setValue(val)
        return prev
        
    def set_secuencia(self, valor):
        self.spinSecuencia.setValue(valor)
    
    # Propiedad para la secuencia
    secuencia = property(get_secuencia, set_secuencia)
    
    def get_orgien(self):
        return self.spinOrigen.value()
    
    def set_origen(self, valor):
        self.spinOrigen.setValue(valor)
    
    origen = property(get_orgien, set_origen)
    
    def get_destino(self):
        return self.spinDestino.value()
    
    def set_destino(self, valor):
        self.spinDestino.setValue(valor)
    
    destino = property(get_destino, set_destino)
    
    # Manejo de los botones de enviar comando
    def on_pushSendReqEv_pressed(self):
        pkg = Paquete.crear_estados_y_eventos(self.origen, self.destino, 
                                                self.secuencia)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())
    
    def on_pushSendReqMorEv_pressed(self):
        pkg = Paquete.crear_mas_eventos(self.origen, self.destino, 
                                            self.secuencia)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())
        
    def on_pushControl_pressed(self):
        puerto = self.spinPuerto.value()
        bit = self.spinBit.value()
        estado = self.radioBitUno.isChecked() and 1 or 0
        indirecto = self.checkIndirecto.isChecked()
        pkg = Paquete.crear_control(self.origen, self.destino, self.secuencia, 
                                    puerto, bit, estado, 
                                    es_comando_indirecto = indirecto)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())
    
    def on_pushLeerRam_pressed(self):
        pagina = self.spinPagina.value()
        direccion = self.spinDireccion.value()
        cantidad = self.spinCantidad.value()
        pkg = Paquete.crear_lectura_ram(self.origen, self.destino, self.secuencia, 
                                        pagina, direccion, cantidad)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())
        
    def on_pushLeerEE_pressed(self):
        pagina = self.spinPagina.value()
        direccion = self.spinDireccion.value()
        cantidad = self.spinCantidad.value()
        pkg = Paquete.crear_lectura_eeprom(self.origen, self.destino, self.secuencia, 
                                        pagina, direccion, cantidad)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())
    
    def on_pushPuestaEnHora_pressed(self):
        #QtGui.QMessageBox.information(self, 'hola', 'Hola')
        pkg = Paquete.crear_puesta_en_hora(self.origen, self.destino, 
                                           self.secuencia)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())
    
    def on_pushEnviarAppString_pressed(self):
        lista = [ int(x, 16) for x in str(self.lineAppString.text()).split() if len(x)]
        pkg = Paquete.crear_paquete_custom(self.origen, self.destino, 
                                           self.secuencia, lista)
        self.entrada_hexa()
        self.line_envio.setText(pkg.hex_dump())
    
    #@QtCore.pyqtSignature('int')
    def on_checkRequerirEstados_stateChanged(self, state):
        if state == QtCore.Qt.Checked:
            print "Requerir estados"
        else:
            print "No requerir mas eventos"
    
    def on_checkRequerirEventos_stateChanged(self, state):
        if state == QtCore.Qt.Checked:
            print "Requerir eventos"
        else:
            print "No requerir mas eventos"
        
    #TODO: Implementar esto    
    def on_pushHex2Bin_pressed(self):
        valor, ok = QtGui.QInputDialog.getText(self, "Ingrese un entero", "Entro a convertir")
        try:
            pass
        except:
            pass