El pasado Halloween, noche de brujas o día de muertos, según el país donde nos lean :), teníamos pensado construir algún animatronic alusivo a la celebración, basado en algunos ejemplos de Makers que ya habían echo algo similar, desafortunadamente nos quedamos sin tiempo y no pudimos dar a luz el proyecto.
Aun así queremos compartir la idea y una de las muchas maneras que existen para realizarla. Básicamente consiste en leer nuestra linea de tiempo en Twitter y pasar cada uno de nuestros tweets a voz, al mismo tiempo que activamos algún juguete animado (bailarín, parlanchín, etc.), veamoslo paso a paso:
1. Antes de empezar debemos crear una “Twitter App”, el proceso es muy sencillo, solo vamos a https://dev.twitter.com/ nos logueamos con nuestra cuenta de Twitter y creamos una aplicación.
el proceso es simple e intuitivo así que no deberíamos tener problema con esto.
2. El circuito, también es sencillo y prácticamente podríamos acoplar cualquier cosa, mediante un transistor o un relevador, en esta ocasión empezaremos con el ya clásico encendido del LED conectado al pin 14 de la GPIO (conector físico numero 8).
3. Una ves creada nuestra aplicación y armado el circuito, tendremos que instalar algunos módulos para poder enlazar nuestra Timeline con Python.
Desde consola actualizaremos e instalaremos el core de git, para poder descargar proyectos de github.
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install git-core
después clonaremos el modulo que nos permitirá autentificarnos con Twitter desde Python.
git clone https://github.com/leah/python-oauth.git
accedemos a la carpeta que se creo para continuar instalando el modulo
cd python-oauth
sudo python setup.py install
en caso de que nos aparezca el siguiente error:
será necesario instalar un complemento adicional (python setup tools component distribute) para poder continuar. Esto lo hacemos dentro de la misma carpeta creada (python-oauth):
mkdir python-distribute
cd python-distribute
curl -O http://python-distribute.org/distribute_setup.py
sudo python distribute_setup.py
al terminar solo tenemos que regresar un nivel en el directorio e intentar nuevamente la instalación:
cd ..
sudo python setup.py install
y esta ves tendría que haber instalado sin mensajes de error.
3. El siguiente modulo nos permitirá conectar con el stream de twitter:
sudo apt-get install python-pycurl
4. Y al final el “mplayer” una aplicación que nos permitira reproducir el audio de nuestros tweets:
sudo apt-get install mplayer
Bien hasta aquí tenemos instalado todos los módulos y aplicaciones que nos harán la magia, solo nos resta el script que ejecutaremos para estar monitoreando nuestra cuenta. Desde cualquier editor o desde la misma consola, creamos un archivo con el nombre que nos agrade pero con extensión .py, esto ultimo es importante, y lo guardamos en el directorio que queramos.
sudo nano TalkingTweet.py
y pegamos el siguiente código, reemplazando la información con las llaves que Twitter asigno a nuestra aplicación:
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # http://hardware-hackingmx.com/ | |
| from oauth.oauth import OAuthRequest, OAuthSignatureMethod_HMAC_SHA1 | |
| from hashlib import md5 | |
| import json, time, random, math, urllib, urllib2, pycurl, subprocess, sys, re | |
| import RPi.GPIO as io | |
| io.setmode(io.BCM) | |
| # Usaremos el pin 14 de la GPIO para activar nuestro juguete | |
| pinLed = 14 | |
| io.setup(pinLed, io.OUT) | |
| io.output(pinLed,io.LOW) | |
| # twitter oauth keys, dentro de las ' ' agregamos las llaves de nuestra App | |
| CONSUMER_KEY = 'consumer_key' | |
| CONSUMER_SECRET = 'consumer_secret' | |
| ACCESS_TOKEN = 'access_token' | |
| ACCESS_TOKEN_SECRET = 'access_token_secret' | |
| # Retorna la URL adecuada para generar el audio de nuestro tweet a traves del servicio de Google. | |
| def getGoogleSpeechURL(phrase): | |
| phrase = (phrase[:99]) | |
| phrase = re.sub(r".http?:\/\/[a-z'.'\/A-Z0-9]*", '', phrase) | |
| phrase = unicode(phrase) | |
| googleTranslateURL = "http://translate.google.com/translate_tts?tl=es&" | |
| phrase = urllib2.quote(phrase.encode('utf8')) | |
| parameters = {'q': phrase} | |
| data = parameters | |
| googleTranslateURL = "%s%s" % (googleTranslateURL,data) | |
| return googleTranslateURL | |
| # Reproduce a traves de mplayer. | |
| def speakSpeechFromText(phrase): | |
| googleSpeechURL = getGoogleSpeechURL(phrase) | |
| io.output(pinLed,io.HIGH) | |
| subprocess.call(["mplayer",googleSpeechURL], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE) | |
| io.output(pinLed,io.LOW) | |
| # Clase para gestionar las llaves. | |
| class Token(object): | |
| def __init__(self,key,secret): | |
| self.key = key | |
| self.secret = secret | |
| def _generate_nonce(self): | |
| random_number = ''.join(str(random.randint(0, 9)) for i in range(40)) | |
| m = md5(str(time.time()) + str(random_number)) | |
| return m.hexdigest() | |
| ########################################## | |
| ### Clase principal ### | |
| ########################################## | |
| class TalkingTwitterStreamClient: | |
| def __init__(self, streamURL): | |
| self.streamURL = streamURL | |
| self.buffer = "" | |
| self.conn = pycurl.Curl() | |
| self.conn.setopt(pycurl.URL, self.streamURL) | |
| self.conn.setopt(pycurl.WRITEFUNCTION, self.on_receive) | |
| self.conn.perform() | |
| def on_receive(self, data): | |
| sys.stdout.write(".") | |
| self.buffer += data | |
| if data.endswith("\n") and self.buffer.strip(): | |
| content = json.loads(self.buffer) | |
| self.buffer = "" | |
| if "friends" in content: | |
| self.friends = content["friends"] | |
| if "text" in content: | |
| print u"{0[user][name]}: {0[text]}".format(content).encode('utf-8') | |
| speakSpeechFromText(u"Tuit de {0[user][name]}".format(content)) | |
| speakSpeechFromText(u"{0[text]}".format(content)) | |
| # obtenemos la URL necesaria para abrir nuestra linea de tiempo en Twitter | |
| def getTwitterUserStreamURL(): | |
| STREAM_URL = "https://userstream.twitter.com/2/user.json" | |
| access_token = Token(ACCESS_TOKEN,ACCESS_TOKEN_SECRET) | |
| consumer = Token(CONSUMER_KEY,CONSUMER_SECRET) | |
| parameters = { | |
| 'oauth_consumer_key': CONSUMER_KEY, | |
| 'oauth_token': access_token.key, | |
| 'oauth_signature_method': 'HMAC-SHA1', | |
| 'oauth_timestamp': str(int(time.time())), | |
| 'oauth_nonce': access_token._generate_nonce(), | |
| 'oauth_version': '1.0', | |
| } | |
| oauth_request = OAuthRequest.from_token_and_callback(access_token, | |
| http_url=STREAM_URL, | |
| parameters=parameters) | |
| signature_method = OAuthSignatureMethod_HMAC_SHA1() | |
| signature = signature_method.build_signature(oauth_request, consumer, access_token) | |
| parameters['oauth_signature'] = signature | |
| data = urllib.urlencode(parameters) | |
| return "%s?%s" % (STREAM_URL,data) | |
| # Ejecutamos nuestro script (Cliente) | |
| client = TalkingTwitterStreamClient(getTwitterUserStreamURL()) | |
Espero sea de lo mas entendible, el método “speakSpeechFromText” nos recibe como parámetro el texto a reproducir, y el método “getGoogleSpeechURL” arma la URL adecuada para generar el audio, en la ejecución algunas veces las palabras con “acentos” no las lee como debe ser, esto es un problema al armar la URL, pero es algo que esperamos pronto resolver.
Y bueno para terminar solo tenemos que ejecutar nuestro script:
sudo python TalkingTweet.py
Es una aplicación sencilla que prácticamente nos lee un Tweet y lo pasa por el traductor de google para generar la voz, mientras se reproduce el audio nos activa el pin 14 de la GPIO para activar lo que sea que tengamos conectado a el, algunos de los inconvenientes, pues es la voz que no podemos cambiar o distorsionar, al menos no directamente del servicio de Google, y que solo nos acepta 100 caracteres, es por eso que en el script hemos cortado la cadena, aun así es bastante funcional y se pueden hacer algunas cosas interesantes, esperamos pronto nos compartan sus Hacks!
Nota: si quisiéramos cambiar el idioma del servicio de Google solo hay que cambiar el parámetro “tl=es” a “tl=en” para el ingles por ejemplo, aproximadamente en la linea 18.
Referencia:
http://www.stuffaboutcode.com/2012/10/raspberry-pi-python-talking-twitter.html
Hardware Hacking Mx 