Electrónica y Programación en Personal
«Si no se soluciona con un script en Python entonces no es viable»

por Yeison Cardona el 28 de enero de 2012 a las 15:27 UTC
Hace algún tiempo hice una aplicación que nos permitía leer nuestros tweets en un Display LCD, tambien está publicada en el blog, para está ocasión quisiera probar algo distinto, y eso es controlar nuestra tarjeta Pinguino mediante mensajes directos en Twitter, para ello he usado el paquete pynguino y tweepy.

Software necesario, instalación:
ejecutar:
sudo apt-get install python-setuptools
sudo apt-get instal python-serial
easy_install pynguino
easy_install tweepy
En Pinguino debe de estar montado pynguino.pde.
Cuentas necesarias: Se necesitarán dos cuentas, una asociada a la tarjeta Pinguino y otra (u otras) de las que se enviarán los comandos por medio de mensajes directos. La cuenta asociada Pinguino la llamé @Pinguino18F2550, esta será la cuenta a la cual enviraré los DM con los comandos desde mi cuenta personal. Código: La aplicación en un pequeño script en python:
#!/usr/bin/env python
#-*- coding: utf-8 -*-

from pynguino import PinguinoProcessing, PinguinoSockets
from time import sleep as delay
import tweepy
import pickle

CONSUMER_KEY = 'iodp34CbG8puC8hEafByNg'
CONSUMER_SECRET = 'JJU8iObrVxbMj3yBpRJJXJtez65BYqlsLSq38JAnxc'

auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth_url = auth.get_authorization_url()

########################################################################
class PinguinoTweetControl:
    #----------------------------------------------------------------------
    def __init__(self):
        try: datos_cuenta=pickle.load (open("datos_cuenta"))
        except:  
            print auth_url
            delay(0.5)
        
            print '\nPor favor autoriza y copia el código para continuar... '
            verifier = raw_input('PIN: ').strip()
            auth.get_access_token(verifier)
        
            ACCESS_KEY = auth.access_token.key
            ACCESS_SECRET = auth.access_token.secret
            
            datos_cuenta=[ACCESS_KEY,ACCESS_SECRET]
            pickle.dump(datos_cuenta, open("datos_cuenta", "w"))
         
        ACCESS_KEY = datos_cuenta[0]
        ACCESS_SECRET = datos_cuenta[1]
        
        auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
        self.api = tweepy.API(auth)

    #----------------------------------------------------------------------
    def Connect(self):
        self.pinguino=PinguinoProcessing()
        self.decode = PinguinoSockets()        
        while not self.pinguino.RecursiveConect():
            raw_input("Enter para reintentar la comunicación con Pinguino...")
        print "\n\nConexión con pinguino establecida.\n"
        raw_input("Enter para continuar...")
        
    #----------------------------------------------------------------------
    def Run(self):
        self.Connect()
        count = len(self.api.direct_messages())
        delay(5)
        self.decode = PinguinoSockets()
        self.decode.pinguino_psc = self.pinguino
        
        while True:
            DMs = self.api.direct_messages()
            if len(DMs) > count:
                command = DMs[0].text
                print command
                try: self.decode.process_method(command)
                except: print  "Orden no reconocida: ", command
                count = len(DMs)
                delay(5)

if __name__=='__main__':
    app=PinguinoTweetControl()
    app.Run()
Sólo se usan dos métodos, Connect: para establecer la comunicación con Pinguino, y Run: el que lee y retorna cada nuevo mensaje directo, y si el mensaje puede ser interpretado como un comando, lo ejecuta. La forma en que se interpretan los comando es mediante la utilización del módulo PignuinoSockets, (también incluido en pynguino), aunque la comunicación por sockets no se está efectuando, si recurro a un método incluido en este, es por eso que lo importo al inicio, este método es process_method el cual recibe un comando como cadena y lo ejecuta como orden. Para mas información acerca de la interacción de Twitter con Python mediante Tweepy pueden visitar este enlace. Iniciando la Aplicación: Suponiendo que ha copiado el código anterior en un archivo llamado PinguinoTweetControl.py y lo ha dejado en el escritorio, podemos proceder de la siguiente manera:
$ python PinguinoTweetControl.py
En la primera ejecución nos pedirá autenticarnos con la API de Twitter, la he llamado PinguinoTweetControl y la dejaré permanentemente, por si alguien desea hacer pruebas. IMPORTANTE: en este paso debemos identificarnos con la cuenta asociada a la tarjeta Pinguino.
Cuando el proceso de registro haya terminado y la conexión se haya establecido sólo bastará con enviar los mensajes directos desde cualquier cuenta.
Comandos: Los comandos siguen las mismas reglas de los usados en Pynguino. Por ejemplo, si queremos definir el pin 0 como entrada: pinMode(0,"input") si queremos poner en alto el pin 0, entonces digitalWrite(0,"high") Esta es la lista completa de comandos:
pinMode(pin,mode): Define el comportamiento de un determinado pin.
    ejemplo: pinguino.pinMode(1,'output')

digitalWrite(pin,estado): Establece el valor de un pin.
    ejemplo: pinguino.digitalWrite(6,'high')

digitalRead(pin): Retorna un 'high' o un 'low' dependiendo el estado del pin leído.
    ejemplo: pinguino.digitalRead(5)

analogWrite(pin,valor): Fija el pin análogo en el valor indicado
    ejemplo: pinguino.analogWrite(12,524)

analogRead(pin): Retorna un valor entero según el estado del pin.
    ejemplo: pinguino.analogRead(11)

allInput(): Define todos lo pines como entrada.
    ejemplo: pinguino.allInput()

allOutput(): Define todos los pines como salida.
    ejemplo: pinguino.allOutput()

allHigh(): Manda todas los pines a un estado alto.
    ejemplo: pinguino.allHigh()

allLow(): Manda todas los pines a un estado bajo.
    ejemplo: pinguino.allLow()

reset(): Resetea el pinguino.
    ejemplo: pinguino.allOutput()

setProcessingTimeout(valor): Permite cambiar el timeout del interprete.
    ejemplo: pinguino.setProcessingTimeout(1)

setProcessingWriteTimeout(valor): Permite cambiar el writeTimeout del interprete.
    ejemplo: pinguino.setProcessingWriteTimeout(2)

ProcessingClose(): Cierra el puerto para el interprete.
    ejemplo: pinguino.ProcessingClose()

GetPinState(): Retorna el estado de un pin basado en la última orden enviada al pinguino.
    ejemplo: pinguino.GetPinState(4)

GetPinMode(): Retorna el modo de un pin basado en la última orden enviada al pinguino.
    ejemplo: pinguino.GetPinMode(11)

Nota:
Como siempre dejo el código base con las posibilidades de extender la aplicación a usos que vayan mas allá de la simple diversión, aunque este no es mejor método de comunicación a través de internet, en cierto modo es mas simple que la implementación de sockets ya que no hay un aplicación cliente, y habilitar cuentas que puedan enviar comandos es tan simple como seguirlas desde la cuenta asociada a Pinguino.

También podría interesarte:

Comentarios:
Eder dijo:
ene. 6, 2014, 10:14 p.m.
Buenas tardes yeison trate de hacer la conexion pero al momento de compilar el archivo pynguino.pde me da los siguientes errores , cabe destacar que copie y pegue tal cual el archivo que dejaste : error line 103 this is the location of the previous definition error line 14 No such file or directory error line 68 No such file or directory error line 69 No such file or directory error line 84 token -> 'else' ; column 6 error line 90 token -> 'else' ; column 4 error line 66 too many parameters error line 83 too many parameters error line 88 too many parameters error line 100 token -> 'else' ; column 4 Si me puedes ayudar estare agradecido muchas gracias (y)
Responder a Eder
Añadir un nuevo comentario:
Si desean una respuesta para su comentario sólo deben agregarme en G+ y hacer una mención a Yeison Cardona, así les podré responder lo antes posible.