Hasta ahora hemos conseguido mostrar las canciones de la radio en el display del LCDKeypad y controlar la reproducción con uno de los botones. Sin embargo, el código actual es bastante chapucero, por lo que se producen algunos “fallos” un poco extraños. Hoy nos centraremos en corregir algunos de ellos:
Conexión serie sin necesidad de configuración
Un problema que tenía hasta ahora es que para que funcionase bien la conexión serie entre el Arduino y el RPi, tenía que ejecutar primero el programa minicom (del que hablamos en una entrada anterior), el RPi se conectaba correctamente y, al cerrar el programa y conectar mediante el programa en Python no había problemas.
Sin embargo, si no usaba minicom, la conexión se bloqueaba. Después de leerme la documentación de PySerial e ir probando con los distintos parámetros de conexión, comprobé que si habilitaba el flag “rtscts”, que activa el control de flujo por hardware, la conexión se establecía correctamente. El problema es que con esta opción activada, el RPi no se podía comunicar con el Arduino (al contrario no había problema), por lo que aunque podía utilizar los botones, no se mostraba nada en la pantalla.
Mi solución, al menos por ahora, ha sido crear y abrir una conexión serie con el rtscts activado, cerrarla y volverla a abrir con los parámetros por defecto. Creo que es algo parecido a lo que hacía con el minicom antes, donde dejaba que minicom hiciese una primera configuración y luego me permitía abrir sin problemas la conexión en Python. De todas formas, si alguien sabe más del tema, le agradecería que me comentase la forma más correcta de hacerlo, porque en este tema estoy un poco perdido. El código final de la conexión es el siguiente:
1: # Sets the serial connection
2: print "Opening serial port..."
3: portOpened = False
4:
5: while(not portOpened):
6: if(sys.platform == 'win32'):
7: try:
8: ser = serial.Serial('COM4', 9600, rtscts=1)
9: ser.close()
10: ser = serial.Serial('COM4', 9600)
11: except:
12: print "Could not open port"
13: else:
14: try:
15: ser = serial.Serial('/dev/ttyUSB0', 9600, rtscts=1)
16: ser.close()
17: ser = serial.Serial('/dev/ttyUSB0', 9600)
18: except:
19: print "Could not open port"
20:
21: if(ser.name != ""):
22: print "Port opened!",ser
23: portOpened = True
24: else:
25: print "Port can't be opened, retrying..."
26: portOpened = False
27:
28: # Trying with infinite timeout
29: ser.timeout = None
Ahora esperamos hasta que el Arduino y el RPi están conectados correctamente entre sí antes de iniciar la radio, evitando posibles envíos perdidos.
Exclusión mutua con variable isPlaying
Recordemos que la variable isPlaying controla cuándo se está reproduciendo o no un stream en la radio. Esta variable es global y compartida entre varios hilos, que pueden leer y escribir en ella. Por tanto, si no controlamos el acceso exclusivo a la misma, podemos tener problemas. En mi caso, lo que ocurría es que a veces pulsaba el botón SELECT para parar la reproducción y la radio se volvía loca, ya que se creía que estaba en pausa cuando no lo estaba y viceversa. La solución es utilizar cerrojos para leer y escribir la variable, y evitar así condiciones de carrera y problemas de sincronización. Python tiene varios tipos de directivas de sincronización. Yo he usado la clase Lock.
1: # Globals
2: isPlaying = False
3: # Locks
4: isPlayingLock = threading.Lock()
5:
6: '''This function receives button interaction from Arduino and respond to them'''
7: def button_receiver():
8: print "Receiver started"
9: global isPlaying
10: while(True):
11: serial_in = ser.readline();
12: serial_out = ""
13:
14: if(serial_in == 'BTNSEL\r\n'):
15: if(not isPlaying):
16: print "[A->R] Received SEL: Playing..."
17: # Put mpc to play
18: args = shlex.split("mpc play")
19: subprocess.check_output(args)
20: # Send the info to Arduino
21: serial_out = "DW Play"
22: serial_out += '\n'
23: ser.write(serial_out)
24: serial_out = ""
25: # Sets isPlaying to True
26: time.sleep(1)
27: isPlayingLock.acquire()
28: try:
29: isPlaying = True
30: finally:
31: isPlayingLock.release()
32: else:
33: print "[A->R] Received SEL: Stopping..."
34: # Sets isPlaying to False
35: isPlayingLock.acquire()
36: try:
37: isPlaying = False
38: finally:
39: isPlayingLock.release()
40: # Stop mpc
41: args = shlex.split("mpc stop")
42: subprocess.check_output(args)
43: # Send the info to Arduino
44: serial_out = "DW Stop"
45:
46: elif(serial_in == 'BTNLFT\r\n'):
47: serial_out = "DW BTNLFT OK"
48: elif(serial_in == 'BTNRGT\r\n'):
49: serial_out = "DW BTNRGT OK"
50: elif(serial_in == 'BTNUP\r\n'):
51: serial_out = "DW BTNUP OK"
52: elif(serial_in == 'BTNDWN\r\n'):
53: serial_out = "DW BTNDWN OK"
54:
55: if(serial_out != ""):
56: print "[R->A]",serial_out
57: serial_out += '\n'
58: ser.write(serial_out)
59: else:
60: pass
En la línea 4 creamos un lock, este objeto se puede adquirir, bloqueando el acceso al las variables a las que se acceda hasta que se libere. Podemos ver su funcionamiento en las líneas 27 a 31. Básicamente, activamos el lock con el método acquire, intentamos poner la variable isPlaying a False, y lo consigamos o no liberamos el lock con el método release. Liberar un lock después de utilizarlo es muy importante, ya que en caso contrario podría quedarse bloqueado y no permitir el acceso a isPlaying.
Una vez liberado el lock, el resto de hilos pueden acceder libremente a la variable isPlaying. El caso es que no termino de acordarme (estudié estos mecanismos hace bastante tiempo), pero creo que el lock habría que utilizarlo en cada acceso a isPlaying, y no sólo en accesos de escritura, que es como está ahora mismo. Miraré mis apuntes y lo corregiré si es el caso. De hecho, estoy pensando en hacer una pequeña clase que se encargue de manejar las lecturas y escrituras mediante candados.
Para más detalles, en Wikipedia se explica mucho mejor esta directiva y su uso.
Cambio de play/pause por play/stop
Hasta ahora, al pulsar el botón SELECT mientras se estaba reproduciendo un stream de audio, la radio pausaba el stream, y al volverlo al pulsar reanudaba la reproducción. Esto tiene un pequeño inconveniente: como estamos en una radio online y no con archivos de audio locales, aunque nosotros pausemos la reproducción, ésta continúa en el servidor remoto. Si pausamos unos pocos segundos no pasa nada, pero si la pausa es algo más larga, el búfer del reproductor se llena y al reanudar la canción que estaba sonando se corta al poco tiempo.
Por ello, he decidido que, cuando se pulse el botón SELECT, lo que hará la radio es parar la reproducción, y al volverlo a pulsar, seguirá por lo que esté retransmitiendo la radio en ese momento. Este comportamiento es mucho más lógico que el anterior, ya que al fin y al cabo estamos escuchando una radio, la cual por definición emite independientemente de si la estamos escuchando o no.
Los cambios se pueden ver en las líneas 21 y41 del código anterior, donde en lugar de utilizar mpc toggle, utilizamos mpc play y mpc stop.
Comprobación de la conexión a Internet
Para escuchar la radio por Internet lo primero que necesitamos es, obviamente, una conexión a Internet activa. Hasta ahora no comprobábamos esto, lo que podría dar lugar a errores o a que simplemente no se reproduzca nada. Para evitarlo, haremos un chequeo de la conexión antes de iniciar la radio en sí. La función la he encontrado y adaptado de un post de StackOverflow:
1: ''' This functon tests the Internet connection '''
2: def connectedToInternet():
3: try:
4: urllib2.urlopen("http://www.google.com", timeout=3)
5: except urllib2.URLError:
6: return False
7: return True
Como se puede ver, lo único que hacemos es intentar abrir la página de Google (lo que suelo hacer yo para comprobar si hay Internet en mi casa), y devolver True o False según pueda cargar la página o no. Si Google desapareciese o se cayese, la radio no funcionaría aunque hubiese Internet, pero estoy dispuesto a asumir este riesgo.
Para hacer la comprobación se ha utilizado la librería urllib2 de Python. Esta librería viene incluida en la distribución estándar de Python, por lo que lo único que hay que hacer es importarla al programa.
Comprobando conexiones antes de iniciar el programa
La última modificación que he hecho es comprobar que haya conexión tanto a Internet como al Arduino antes de iniciar los hilos del programa:
1: if __name__ == "__main__":
2: arduinoReady = False
3: while(not arduinoReady):
4: serial = ser.readline()
5: if(serial == "INITOK\r\n"):
6: arduinoReady = True
7: print "Arduino connected!"
8: ser.write("UP RPi Connected!\n")
9: else:
10: print "Waiting Arduino connection..."
11: time.sleep(1)
12:
13: while(not connectedToInternet()):
14: print "Testing internet connection..."
15: ser.write("DW Waiting Inet...\n")
16: time.sleep(1)
17:
18: ser.write("DW Inet. Connected!\n")
19:
20: rec = threading.Thread(target=button_receiver,name='ButtonReceiverTh')
21: sen = threading.Thread(target=display_sender,name='DisplaySenderTh')
22: rec.start()
23: sen.start()
En el código se comprueba que se haya recibido el INITOK del Arduino para confirmar que esté conectado, y que haya Internet. Cuando todo está correcto, se mostrará un mensaje por el display del LCDKeypad y ya se podrá utilizar la radio.
Corrigiendo sketch de Arduino
Hay veces que al pulsar un botón del Arduino, se me han enviado dos pulsaciones de ese botón. Esto es especialmente molesto en el botón SELECT, ya que si queremos detener la reproducción, al enviarse dos pulsaciones, el stream se detendrá y se volverá a activar.
El “fallo” parece ser de hardware: creo que lo que ocurre es que, después de dejar de pulsar el botón, durante un pequeño intervalo de tiempo, lcd.button vuelve a detectar que el botón se ha pulsado (aunque no se haya hecho). Para solucionarlo, lo único que he hecho es añadir un pequeño retardo de 30ms para evitar esto. No estoy del todo seguro de que ésta sea la causa, pero no se me ocurre otra cosa, ya que lcd.button tiene que detectar que se ha dejado de pulsar el botón antes de enviar la pulsación. Si a alguien tiene otra explicación, le agradecería que la comentase.
1: // Returns the pressed button
2: int buttonPressed(){ 3: int aux = lcd.button();
4: if(aux != KEYPAD_NONE){ 5: while(lcd.button() != KEYPAD_NONE){ 6: }
7: delay(30);
8: return aux;
9: }
10: return KEYPAD_NONE;
11: }
12:
Con estas correcciones la radio comprueba que haya conexión a Internet, se conecta automáticamente al Arduino y funciona sin problemas aparentes. El código ahora es un poco más largo (aunque no llega a 200 líneas), pero todo funciona mejor.
PD: Como indiqué en la entrada anterior, he creado un repositorio con el código del proyecto, por lo que cualquiera que quiera ver el código completo, descargarlo y utilizarlo o modificarlo, puede hacerlo sin problemas.
