PyS60, problema con timer y recepción de datos por BT

[ferny]

Hola

Estoy haciendo un pequeño programa para PyS60 1.9.7 que corre en mi nokia 5800. Lo que hago es enviar una serie de datos por BT a través de un adaptador BT a RS232 (Bluesmirf) y muestro el resultado en el móvil. Los datos se envían en ráfagas de 16 bytes cada 2 segundos más o menos.

Tengo la siguiente función para leer datos por Bluetooth (nota: lo hago con un timer porque quiero usar la función principal para dibujar la pantalla, y traté de hacerlo con un thread pero en cuanto meto algo de BT dentro del thread se queda como sin hacer nada)

Código Python:

# Para leer datos por BT
def lee_bt():
    global BT
    if BT:
        appuifw.e32.reset_inactivity()
        try:
            data = bt_receive_data()
            data = data.encode("hex")
            print("Data = 0x%x" % int(data,16))
        except:
            pass
    my_timer.after(0.1,lee_bt)
 
my_timer = e32.Ao_timer()
my_timer.after(0.1,lee_bt)
 
bt_connect()
BT = True
 

La función bt_receive_data()

Código Python:

def bt_receive_data():
    ###########################################################################
    # Variables globales
    global sock
    buffer = []
    try:
        buffer = sock.recv(16)
    except:
        pass
    return buffer
    ###########################################################################
 

El problema: si en el buffer del adaptador BT a RS232 hay 16 o más bytes, los lee sin problemas y los va mostrando, el problema está cuando hay menos de 16 bytes. Por ejemplo, si hay 10 bytes, muestra los 10 bytes, pero ya no recibe nunca más, aunque sé que debería haber datos porque los estoy enviando.

Sin embargo, si cambio el tamaño del buffer a 1 en vez de 16, funciona bien, es decir, si no hay datos se queda en "espera", y cuando vuelve a haber datos los muestra. El problema es que me gustaría leer de 16 en 16 y no de 1 en 1.

Llevo programando en python sólo un par de semanas, así que puedo estar cometiendo cualquier burrada...

Gracias por la ayuda

[razpeitia]

¿Que tal con un buffer mas grande? y después dividir los datos en 16 bits.

Es mas o menos lo que recomienda la documentación.

[ferny]

Hola

Hay una erratilla en el anterior post, se envían ráfagas de 14 bytes y no de 16 como puse en un principio, sólo como corrección.

Da igual el tamaño del buffer, lo máximo que probé es 256 bytes (sé que pueden ser más, pero ahí ya lo dejé), siempre llega un momento que deja de recibir, y ese momento es cuando hay menos de 256 bytes para "descargar". Puedo saber la cantidad de datos que hay porque se envían 14 bytes cada 2 segundos, con lo cual conozco cómo de "cargado" está el adaptador BT a RS232 en función del tiempo que pasa.

Por ejemplo: si hay cargados 4 mensajes, o sea 4 * 14 = 56 bytes, y descargo a razón de 16 bytes por lectura, obtengo 3 lecturas de 16 bytes, una de 8 bytes, y deja de recibir para siempre. Si descargo a razón de 256 bytes por lectura, obtendo una única lectura de 56 bytes y ya no vuelve a recibir más. Sin embargo esto no pasa cuando el tamaño de buffer es de 1 byte: si no hay datos, se queda a la espera, y cuando los hay los descarga (lo veo porque llega un momento que hace pausas de 2 segundos entre que muestra unos datos y los siguientes)

Ahora mismo estoy tratando de hacerlo con un thread, pues ya conseguí hacer que iniciara el thread metiendo todas las funciones de BT dentro, pero me está dando otros problemas por otro lado...

Sigo investigando

Gracias y un saludo

[razpeitia]

La verdad es que no he trabajado con ese módulo. Pero encontré unos bueno tutoriales para trabajar con ese módulo.

Hay un apartado donde dice Bluetooth me imagino que es con lo que estas trabajando.

[ferny]

Efectivamente saqué mucho de ahí

Conseguí hacer funcionar los thread pero me ha dado otro problema. El BT es un recurso compartido que tiene que enviar y recibir datos, es decir recibo datos cada 2 segundos y envío datos varias veces por segundo.

El problema viene porque cuando llamo a la función de BT de recibir datos, se queda a la espera de que haya datos (cada 2 segundos, 14 bytes nuevos), lo que hace que durante ese tiempo no envíe nada. Al final lo que me está haciendo es que cada dos segundos envía y recibe un mensaje, o sea el envío se produce sólo cuando el BT queda libre que es justo después de que termine la función de recibir dato. Eso no me vale porque tengo que enviar datos con una frecuencia mucho mayor que con la que recibo.

Si trato de enviar un dato cuando está la función de recibir activa, la aplicación da error y se cierra o se cuelga. Implementé un lock y con acquire() y release() controlo que eso no suceda, pero probé a ver qué pasaba quitando el lock y evidentemente se quejaba...

He visto que existe un flag para la función sock.send que es MSG_DONTWAIT y que me vendría al pelo, pero pys60 no parece reconocerlo Ignoro si se podrá implementar algún timeout para la función de alguna manera, con eso creo que lo tendría solucionado...

Gracias