Subversion Repositories phr

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import wx
import guiparent
 
import os           # se usa para el dialogo de abrir fichero
import subprocess   # para interactuar con el shell
import thread       # to prevent gui blocking
from sys import platform as _platform  # para detectar el sistema operativo
 
 
class phrgui (guiparent.guiParent):
    def __init__(self, *args, **kwds):
        guiparent.guiParent.__init__(self, *args, **kwds)
        self.__set_extra_properties()
 
 
    def __set_extra_properties(self):
        # Definicion de la fuente monospace
        font1 = self.text_ctrl_console.GetFont()
        font1 = wx.Font(font1.GetPointSize(), wx.TELETYPE,
                   font1.GetStyle(),
                   font1.GetWeight(), font1.GetUnderlined())
 
        # Propiedades de la consola
        self.text_ctrl_console.SetFont(font1)
        self.text_ctrl_console.SetValue("PHR>>> ")
 
        # Propiedades de la la lista de dispositivos detectados
        self.list_box_dispositivos_conectados.SetFont(font1)
 
 
    def menu_item_ayuda_acerca_de_handler(self, event):  # wxGlade: wg_parent_class.<event_handler>
        description = u"""
PHR GUI es una interfaz gráfica que permite interactuar con 
la Plataforma de Hardware Reconfigurable (CUDAR) a través 
del software xc3sprog.
 
$Rev: 337 $
$Date: 2014-06-13 04:58:39 +0200 (Fri, 13 Jun 2014) $
"""
        licence = """
PHR GUI is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
PHR GUI is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
See the GNU General Public License for more details. You should have 
received a copy of the GNU General Public License along with
PHR GUI; if not, write to the Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
"""
        info = wx.AboutDialogInfo()
 
        info.SetIcon(wx.Icon('grafica/phr-gui-96.png', wx.BITMAP_TYPE_PNG))
        info.SetName('PHR GUI')
        info.SetVersion('0.1.1')
        info.SetDescription(description)
        #info.SetCopyright('(C) 2014 CUDAR (UTN-FRC)')
        info.SetCopyright('2014, CUDAR (UTN-FRC)')
        info.SetWebSite('http://opencores.org/project,phr')
        #info.SetLicence(licence)
        info.AddDeveloper('Luis Guanuco, Maximiliano Quinteros.')
 
        wx.AboutBox(info)
        event.Skip()
 
 
    def menu_item_ayuda_hint_handler(self, event):  # wxGlade: guiParent.<event_handler>
        mensaje = u"""
Procedimiento general para utilizar este programa:
 
1. Conecte el programador y presione en el botón \"Detectar\". 
Se listaran los dispositivos encontrados en la cadena JTAG.
2. Seleccione el dispositivo que desea programar o configurar.
3. Elija un fichero de configuración/programación.
      *.BIT para FPGA
      *.JED para CPLD
4. Presione el botón \"Transferir\".
 
Considere las recomendaciones de la placa específica que esté
utilizando. 
"""
        wx.MessageBox(mensaje, 'Info', wx.OK | wx.ICON_INFORMATION)
        event.Skip()
 
 
    def boton_elegir_fichero_handler(self, event):  # wxGlade: wg_parent_class.<event_handler>
        wildcard = "Archivo BIT de Xilinx (*.bit)|*.bit|" \
                   "Archivo JEDEC para CPLD (*.jed)|*.jed|" \
                   "Todos los archivos (*.*)|*.*"
        dialog = wx.FileDialog(None, "Elija un archivo", os.getcwd(), "", wildcard, wx.OPEN)
        if dialog.ShowModal() == wx.ID_OK:
            self.text_ctrl_fichero.SetValue(dialog.GetPath())
            print "New file to transfer: " + dialog.GetPath()
 
        dialog.Destroy()
        event.Skip()
 
 
    def boton_borrar_salida_handler(self, event):  # wxGlade: wg_parent_class.<event_handler>
        self.text_ctrl_console.SetValue("PHR>>> ") # borra el contenido de la consola
        print "Console cleared"
        event.Skip()
 
 
    def before_run (self):
        # preparar entorno para los eventos de transferencia y deteccion de dispositivos
        self.boton_transferir.Disable()
        self.boton_elegir_fichero.Disable()
        self.boton_detectar.Disable()
        self.boton_borrar_salida.Disable()
        self.statusbar.SetFields(["Espere ..."])
 
 
    def after_run (self):
        # restaurar entorno 
        self.boton_transferir.Enable()
        self.boton_elegir_fichero.Enable()
        self.boton_detectar.Enable()
        self.boton_borrar_salida.Enable()
        self.statusbar.SetFields(["Listo"])
 
 
    def boton_transferir_thread(self, position):
        ## preparar entorno
        wx.CallAfter(self.before_run)
 
        position = str (position)        
 
        if _platform == "linux" or _platform == "linux2":
            # linux
            command = "./xc3sprog/lin/xc3sprog -v -c ftdi -p " + position + " \""+ self.text_ctrl_fichero.GetValue() + "\""  
        else:
            # windows
            subprocess.call ("copy \"" + self.text_ctrl_fichero.GetValue() + "\" fpgaFile", shell=True)
            command = "xc3sprog\\win\\xc3sprog -v -L -c ftdi -p " + position + " fpgaFile:w:0:BIT"
 
        wx.CallAfter(self.text_ctrl_console.AppendText, command + "\n")
 
        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
 
 
        if _platform == "linux" or _platform == "linux2":
            # linux
            for line in iter(process.stdout.readline, ''):
                wx.CallAfter(self.text_ctrl_console.AppendText, line)
            process.stdout.close()
        else:
            # Windows
            line = ''
            while True:
                out = process.stdout.read(1)
                if out == '' and process.poll() != None:
                    break
                if out != '' and out != '\x0a':
                    line = line + out
                    if out == '\x0d':
                        wx.CallAfter(self.text_ctrl_console.AppendText, line)
                        line = ''
 
        wx.CallAfter(self.text_ctrl_console.AppendText, "\nPHR>>> ")
 
        ## restaurar entorno 
        wx.CallAfter(self.after_run)
 
 
    def boton_transferir_handler(self, event):  # wxGlade: wg_parent_class.<event_handler>
 
        device_list_selection = self.list_box_dispositivos_conectados.GetSelections()
 
        if len (device_list_selection) > 0:
            position = device_list_selection[0]
        else:
            position = 0
 
        thread.start_new_thread(self.boton_transferir_thread, (position,))
        event.Skip()
 
 
    def boton_detectar_thread (self):
        ## preparar entorno
        wx.CallAfter(self.before_run, )
        wx.CallAfter(self.list_box_dispositivos_conectados.Clear)
 
        ## accion
 
        if _platform == "linux" or _platform == "linux2":
            # linux
	        command = "./xc3sprog/lin/xc3sprog -c ftdi"
        else:
            # windows
            command = "xc3sprog\\win\\xc3sprog -c ftdi -L -j -v"
 
        wx.CallAfter(self.text_ctrl_console.AppendText, command + "\n")
 
        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
 
        for line in iter(process.stdout.readline, ''):
            # Append output to console
            wx.CallAfter(self.text_ctrl_console.AppendText, line)
 
            # If it is a JTAG device append it in list box as well
            if line.lower()[0:10] == "jtag loc.:":
                deviceStr = line.split ()
                appendStr = deviceStr[0] + " " + deviceStr[2] + ": "
 
                if deviceStr[5] == "Desc:":
                    appendStr += deviceStr[6] + " (ID:" + deviceStr[4] + ")"
                else:
                    appendStr += "Unknown" + " (ID:" + deviceStr[4] + ")"
 
                wx.CallAfter(self.list_box_dispositivos_conectados.Append, appendStr)
 
        process.stdout.close()
 
        if self.list_box_dispositivos_conectados.GetCount() >= 1:
            wx.CallAfter(self.list_box_dispositivos_conectados.SetSelection, 0)
 
        wx.CallAfter(self.text_ctrl_console.AppendText, "\nPHR>>> ")
 
        ## restaurar entorno 
        wx.CallAfter(self.after_run, )
 
 
    def boton_detectar_handler(self, event):  # wxGlade: wg_parent_class.<event_handler>
        thread.start_new_thread(self.boton_detectar_thread, ())
        event.Skip()
 
# end of class phrgui
 
if __name__ == "__main__":
    app = wx.App(False)
    frame = phrgui(None, -1, "")
    app.SetTopWindow(frame)
    frame.Show()
    app.MainLoop()