Consola USB PyGTK + Pinguino

Posteo esto antes de que se me olvide, je.

Siguiendo con pruebas con Pinguino y PyGTK he realizado una pequeña consola o terminal para enviar información a Pinguino y también leer lo que envía Pinguino a través de comunicación USB.

La interfaz en la computadora una vez más está hecha con PyGTK, pero esta vez hago uso de un hilo (un thread) para leer continuamente lo recibido de Pinguino.

Para probarla en Pinguino he programado un echo (eco) para que regrese todo lo que se le envía.

Del lado de Pinguino:

Código:


// File: USBecho.pde
//
// February 2012
// aztk <aztecaymaya@gmail.com>
//
// USB echo

void setup()
{
    TRISB = 0x00;
    PORTB = 0x00;
}
 
void loop()
{
    if (USB.available())
    {
        u8 letra[1];
        letra[0] = USB.read();
        USB.send(letra, 1);
        PORTB = letra[0];
        delay(10);
    }
}


Y del lado de python:

Código:


#! /usr/bin/python
# -*- coding: utf-8 -*-
#
# console.py
#
# Es una pequeña consola para enviar y recibir
#  información hacia y desde Pinguino.
#
# aztk <aztecaymaya@gmail.com>
# Febrero 2012
 
import usb        # requires pyusb available at https://sourceforge.net/projects/pyusb/files/

import threading # Usada para hilos
import gobject  #  Se requiere un hilo para monitorear
                #  constantemente lo que se recibe de
                #  Pinguino.

import pygtk
pygtk.require('2.0')
import gtk

gobject.threads_init() # Inicializar hilos

# Hilo para monitorear info recibida de Pinguino
class ReadThread(threading.Thread):
    # Parametros:
    #  - pingu: Interfaz Pinguino
    #  - buffertext: Buffer de texto a depositar información recibida
    def __init__(self, pingu, buffertext):
        super(ReadThread, self).__init__()
        self.pingu = pingu
        self.buffertext = buffertext
        self.quit = False
   
    def read_data(self):
        stringRX = ''
        try:
            stringRX = self.pingu.read(250, 100)
        except usb.USBError as err:
            pass
        if len(stringRX) > 0:
            #print stringRX
            for i in stringRX:
                self.buffertext.insert(self.buffertext.get_end_iter(), str(hex(i)) + ' ')
        return False
       
    def run(self):
        while not self.quit:
            self.read_data()
           
#-------------------------------------------------------------------------------
# Pinguino Class by Marin Purgar (marin.purgar@gmail.com)
#-------------------------------------------------------------------------------
class Pinguino():
 
    VENDOR = 0x04D8
    PRODUCT = 0xFEAA
    CONFIGURATION = 3
    INTERFACE = 0
    ENDPOINT_IN = 0x82
    ENDPOINT_OUT = 0x01
 
    device = None
    handle = None
 
    def __init__(self,):
        for bus in usb.busses():
            for dev in bus.devices:
                if dev.idVendor == self.VENDOR and dev.idProduct == self.PRODUCT:
                    self.device = dev
        return None
 
    def open(self):
        if not self.device:
            print "Unable to find device!"
            return None
        try:
            self.handle = self.device.open()
            self.handle.setConfiguration(self.CONFIGURATION)
            self.handle.claimInterface(self.INTERFACE)
        except usb.USBError, err:
            print err
            self.handle = None
        return self.handle
 
    def close(self):
        try:
            self.handle.releaseInterface()
        except Exception, err:
            print err
        self.handle, self.device = None, None
 
    def read(self, length, timeout = 0):
        return self.handle.bulkRead(self.ENDPOINT_IN, length, timeout)
 
    def write(self, buffer, timeout = 0):
        return self.handle.bulkWrite(self.ENDPOINT_OUT, buffer, timeout)

# Ventana principal
class Ventana:
    def __init__(self):
        # Create a new window
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_title("PinguinoUSBConsole")
        self.window.connect('destroy', self.destroy)
       
        self.vbox1 = gtk.VBox(False, 10)
        self.hbox1 = gtk.HBox(False, 10)
       
        self.edata = gtk.Entry()
        self.benviar = gtk.Button('Enviar')
        self.swindow1 = gtk.ScrolledWindow()
        self.swindow1.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.tvdata = gtk.TextView(buffer = None)
        self.buffertext = self.tvdata.get_buffer()
        self.tvdata.set_wrap_mode(gtk.WRAP_WORD)#(gtk.WRAP_CHAR)
        self.tvdata.set_editable(False)
        self.tvdata.set_cursor_visible(False)
       
        self.hbox1.pack_start(self.edata, True, True, 3) #self.hbox1.add(self.edata)
        self.hbox1.pack_start(self.benviar, False, False, 3) #self.hbox1.add(self.benviar)
        self.vbox1.pack_start(self.hbox1, False, False, 3) #self.vbox1.add(self.hbox1)
        self.swindow1.add_with_viewport(self.tvdata)
        self.vbox1.pack_start(self.swindow1, True, True, 3) #self.vbox1.add(self.swindow1)
        self.window.add(self.vbox1)
     
        self.window.show_all()
       
        self.benviar.connect('clicked', self.enviarcmd)
        self.edata.connect('activate', self.enviarcmd)
     
        print "Wellcome"
       
    def enviarcmd(self, widget):
        stringtosend = self.edata.get_text()
        if len(stringtosend):
            #print 'Enviado: ', stringtosend
            pinguino.write(stringtosend, 100)
            self.edata.set_text('')
       
    def destroy(self, widget, data = None):
        print "Goodbye"
#        pinguino.close()
#        r.quit = True
        gtk.main_quit()
       
    def main(self):
        gtk.main()

if __name__ == '__main__':
    ventana = Ventana()
    pinguino = Pinguino()
    if pinguino.open() == None:
        print "Unable to open Pinguino device!"
        exit(1)
    r = ReadThread(pinguino, ventana.buffertext)
    r.start()
    ventana.main()
    r.quit = True
    pinguino.close()



Saludos!