Presentación Internet Of Things + Raspberry Pi decharlas.com Abril 2014

Presentación Internet Of Things + Raspberry Pi decharlas.com Abril 2014

Internet esta transformándose constantemente, durante los últimos años hemos sido testigos de una evolución hacia lo social, transaccional y móvil, ¿pero cual es el siguiente reto? la respuesta esta en los objetos, cosas cotidianas que paulatinamente están conectándose a la red.

A día de hoy existen mas objetos conectados que personas en el planeta y para el año 2020 existirán mas de 50.000 millones de ellos. ¿Frigoríficos inteligentes que te avisan de la caducidad de alimentos? ¿Cepillos de dientes que detectan caries? ¿Ciudades inteligentes, sostenibles? La aplicación del concepto es ilimitada.

Parece ciencia ficción, pero hoy ya existen personas, empresas e instituciones que están aplicando con éxito estos paradigmas, en parte gracias al abaratamiento de sensores y al hardware libre como Arduino o Raspberry Pi. Hoy día cualquier persona interesada puede adentrarse en el apasionante mundo de el “Internet de las Cosas”

Borrar colas en RabbitMQ con Pika (python) y rabbitmqctl

En ocasiones necesitamos borrar todas las colas de nuestro RabbitMQ, sobretodo en entornos de pruebas.

Este pequeño script en python utilizando la libreria Pika nos puede ayudar a esta tarea.

Para ello utilizaremos la libreria Pika:

pip install pika

(Esta solución esta sacada de http://stackoverflow.com/questions/6742938/deleting-queues-in-rabbitmq/22576477#22576477)

#!/usr/bin/env python
from sys import stdin
from pika import BlockingConnection, ConnectionParameters

connection = BlockingConnection(ConnectionParameters('localhost'))
channel = connection.channel()

queues = stdin.readlines()[1:-1]
for x in queues:
    q = x.split()[0]
    print 'Deleting %s...' %(q)
    channel.queue_delete(queue=q)

connection.close()

Para utilizarlo solo tenemos que hacer esta llamada desde la linea de comandos:

sudo rabbitmqctl list_queues | delete_queues.py

Gracias a este pequeño script nuestra tarea de eliminar todas las colas en RabbitMQ estará solucionada.

Mini-tutorial Silex: Añadiendo dependencias, Twig (II)

En la anterior entrega (http://blog.deancos.com/2013/12/27/mini-tutorial-silex-instalacion-i/) aprendimos como instalar Silex para comenzar un proyecto y escribimos nuestro primer controlador, dicho controlador simplemente lanzaba una cadena como respuesta, pero para poder realizar el proyecto que tenemos entre-manos necesitamos mas potencia a la hora de crear vistas, he aquí la solución: utilizaremos Twig el sistema de plantillas de PHP de moda.

Lo primero que vamos hacer es actualizar las dependencias de nuestro proyecto, como ya vimos en el capitulo anterior utilizaremos el fichero composer.json, añadiendo la dependencia que necesitamos, en este caso Twig:

{
    "require": {
        "silex/silex": "~1.1",
        "twig/twig": ">=1.8,<2.0-dev",
        "symfony/twig-bridge": "~2.3"
    }
}

Una vez guardado el fichero podemos actualizar nuestro proyecto:

$ php composer.phar update

Esto instalara en nuestro proyecto todo lo necesario para poder empezar a utilizar Twig como sistema de plantillas en nuestro proyecto Silex.

Una vez lo tenemos lo siguiente que necesitamos es registrar los servicios necesarios para que Twig este operativo, y cambiar la respuesta de nuestro controlador para que utilice una vista:

<?php
require_once __DIR__.'/../vendor/autoload.php';

$app = new Silex\Application();
$app->register(new Silex\Provider\TwigServiceProvider(), array('twig.path' => __DIR__.'/views',));

$app->get('/', function () use ($app) {
    return $app['twig']->render('index.html', array('nombre' => 'Samuel'));
});

$app->run();

Pasemos a explicar un poco las nuevas lineas del código:

En primer lugar registramos TwigServiceProvider y le decimos el path de nuestras vistas, en nuestro caso sera views, con esto ya podemos empezar a escribir el código de nuestras plantillas, en dicha carpeta que previamente deberíamos haber creado dentro de web:

$ mkdir views

Por ultimo la respuesta; como vemos en el código ahora utilizamos el servicio twig y su método render para responder pasando como parámetro la plantilla y un array con las posibles variables que queremos pasar a la vista, en este caso la variable nombre.

Ahora podemos crear nuestra primera plantilla Twig, index.html, dentro de la carpeta views:

<h1>Bienvenido {{ nombre }} a nuestro primer proyecto Silex con Twig!</h1>

Es un pagina sencilla para nuestro primer ejemplo, en capítulos posteriores veremos como aprovechar la potencia de Twig en nuestros proyectos Silex.

Ya lo tenemos, podemos ver el resultado en nuestro navegador preferido.

Mini-tutorial Silex: Instalación (I)

En este mini-tutorial vamos a explicar desde la instalación hasta la creación de un pequeño proyecto final como funciona el micro-framework basado en Symfony Silex, la idea es crear un mini-cms totalmente operativo.

Lo primero que haremos sera instalar composer el manejador de dependencias de facto de PHP en los últimos tiempos, composer es una herramienta que permite instalar las librerías de las que depende un proyecto PHP, en nuestro caso Silex.

Este mini-tutorial esta orientado a sistemas Linux así que daré por sentado que tenemos las herramientas necesarias.

Para instalar composer simplemente debemos ejecutar la siguiente sentencia en cualquier terminal dentro de la carpeta de nuestro proyecto:

$ curl -sS https://getcomposer.org/installer | php

Ahora ya tenemos composer en nuestra carpeta, lo siguiente que necesitamos es decirle a composer que queremos instalar Silex.

Para ello creamos dentro de la carpeta un fichero llamado composer.json, este es el fichero que composer leera para saber que paquetes queremos instalar, su formato es JSON.

Si necesitas mas información sobre composer escribí hace tiempo sobre ello http://blog.deancos.com/2012/09/22/dependencias-en-php-composer/

{
    "require": {
        "silex/silex": "~1.1"
    }
}

Una vez hemos creado el fichero podemos decirle a composer que instale el paquete y todas sus dependencias:

$ php composer.phar install

Cuando termine su trabajo ya tendremos en nuestra carpeta el microframework Silex preparado para empezar a trabajar con el.

Lo siguiente que haremos sera crear nuestro controlador frontal, para ello creamos una carpeta llamado web dentro de la principal de nuestro proyecto, y dentro un fichero llamado index.php:

$ mkdir web
$ touch index.php

Luego abrimos el fichero con nuestro editor de código favorito y escribimos nuestro primer controlador frontal:

<?php
require_once __DIR__.'/../vendor/autoload.php';

$app = new Silex\Application();

$app->get('/', function () use ($app) {
    return "Bienvenido a nuestro primer proyecto Silex!";
});

$app->run();

Vamos a explicar un poco el funcionamiento del código anterior:

Lo primero que vemos es que importa el fichero autoload.php, este fichero es creado por composer, basicamente carga las clases necesarias para que los paquetes funcionen, es lo que se denomina un ClassLoader.

La siguiente linea carga la clase principal de Silex: Application, esta clase hereda de Pimple, el contenedor de dependencias que utiliza Silex e implementa HttpKernelInterface. Esta clase es la base de Silex y nos permite crear nuestro controlador frontal asi como construir nuestra aplicación en base a ella.

Lo siguiente que vemos es un controlador, en este caso controlar las peticiones GET para el patron /, esto es raíz, y ejecuta el código de la función anónima, en este caso devuelve una cadena.

Finalmente llamamos al método run de nuestra aplicación, a grandes rasgos este método es el que controla el flujo petición-respuesta (request-response) en la aplicación.

Esta primera aplicación es muy sencilla, ya iremos desgranando el funcionamiento mas detalladamente según vaya creciendo nuestra aplicación en los siguientes capítulos.

Una vez todo este preparado necesitamos que un Servidor Web sirva nuestro proyecto, en nuestro caso vamos a utilizar Apache2, sin meternos mucho en este tema pues no es la finalidad de este tutorial, simplemente creamos un VirtualHost parecido a esto:

<VirtualHost *:8080>
	DocumentRoot /MI_PATH/MI_PROJECTO/web/index.php

	<Directory /MI_PATH/MI_PROJECTO/web/>
		Options Indexes FollowSymLinks MultiViews
		AllowOverride All
		Order allow,deny
		Allow from all
	</Directory>

	ErrorLog /var/log/apache2/error_mi_proyecto.log
	LogLevel warn

	CustomLog /var/log/apache2/access_mi_proyecto.log combined
	ServerSignature On
</VirtualHost>

Una vez reiniciado el servidor web, ya tendremos funcionando nuestro primero proyecto Silex.

Ahora ya podemos ver el resultado en nuestro navegador preferido: localhost:8080.

En próximas entregas veremos como añadir dependencias a nuestro proyecto y como crear un mini cms con Silex.

Ir a segunda parte del tutorial: Mini-tutorial Silex: Añadiendo dependencias, Twig (II)

Internet of Things + RaspberryPi + Python con carriots

Código de ejemplo de la Charla-Taller: Internet de las Cosas, RaspberryPi y Python en MediaLab-Prado (http://medialab-prado.es/article/iotraspberrypipython)

Toda la información sobre este proyecto puedes encontrarla en https://www.carriots.com/tutorials/arduino_carriots/alert_system

#-*-coding:utf8-*-
import RPi.GPIO as GPIO, time
import urllib2
import time, datetime
import json

class Client(object):
    api_url = "http://api.carriots.com/streams"

    def __init__ (self, api_key = None, client_type = 'json'):
        self.client_type = client_type
        self.api_key = api_key
        self.content_type = "application/vnd.carriots.api.v2+%s" % (self.client_type)
        self.headers = {'User-Agent': 'Raspberry-Carriots',
                        'Content-Type': self.content_type,
                        'Accept': self.content_type,
                        'Carriots.apikey': self.api_key}

    def send (self, data):
        self.data = json.dumps(data)
        request = urllib2.Request(Client.api_url, self.data, self.headers)
        self.response = urllib2.urlopen(request)
        return self.response

def RCtime(PiPin):
    measurement = 0
    GPIO.setup(PiPin, GPIO.OUT)
    GPIO.output(PiPin, GPIO.LOW)
    time.sleep(0.1)

    GPIO.setup(PiPin, GPIO.IN)

    while (GPIO.input(PiPin) == GPIO.LOW):
        measurement += 1

    return measurement


def main():
    GPIO.setmode(GPIO.BCM)
    ON = 1
    OFF = 2
    DEVICE = "YOUR_DEVICE@YOUR_USERNAME"
    APIKEY = "YOUR_APIKEY"
    lights=OFF

    client_carriots = Client (APIKEY)

    while True:
        timestamp = int (time.mktime(datetime.datetime.utcnow().timetuple()))
        if RCtime(4) > 600:
            new_lights = OFF
        else:
            new_lights = ON

        if lights is not new_lights
            lights = new_lights
            data = {"protocol":"v2","device":DEVICE,"at":timestamp,"data":{"light":("ON" if new_lights is ON else "OFF")}}
            carriots_response=client_carriots.send(data)

if __name__ == '__main__':
    main()

Conexion entrantes + whois en Python

Hace varias semanas que no publico nada por aquí, y aprovechando que escribí un pequeño script en python para hacer un whois a todas las conexiones entrantes en una maquina con Linux, voy a publicarlo aquí por si a alguien le resulta útil.

Es un script muy sencillo así que no tiene mucha explicación tampoco.

#!/usr/bin/python
import socket
import sys

class Netstat(object):

    def __init__ (self):
        with open("/proc/net/tcp",'r') as f:
            self.content = f.readlines()
            self.content.pop(0)

    def _whois(self, address):
        try:
            data = socket.gethostbyaddr(address[0])[0]
        except Exception, ex:
            data = ex

        return data

    def _get_address(self):
        result = []
        sys.stdout.write( '\r' + ( '#' * 0 ) + ' get address')
        sys.stdout.flush()
        for line in self.content:
            line_array = [x for x in line.split(' ') if x !='']
            if line_array[2] != '00000000:0000':
                host,port = line_array[2].split(':')
                r_host = '.'.join([(str(int(host[6:8],16))),
                                   (str(int(host[4:6],16))),
                                   (str(int(host[2:4],16))),
                                   (str(int(host[0:2],16)))])
                result.append(r_host)

        return result

    def execute(self, interactive=False):
        self.final = []
        list_address = self._get_address()
        if interactive:
            self.interactive(list_address)
        else:
            self.non_interactive(list_address)

    def non_interactive(self, list_address):
        final = []
        count = 0
        for address in list_address:
            count = count + 1
            sys.stdout.write( '\r' + ( '#' * count ) + ' Scan Address:'\
             + address)
            final.append((self._whois(address), address))
            sys.stdout.flush()

        return final

    def interactive(self, list_address):
        for address in list_address:
            print address, self._whois(address)


if __name__ == '__main__':
    nestat = Netstat()
    nestat.execute(interactive=False)
    # ó para modo interactivo, esto es, te va mostrando por pantalla
    # el resultado del whois.
    nestat.execute(interactive=True)

Para cualquier duda, y/o explicación puedes escribirme un comentario :D

Espero sea de utilidad!

Peticiones PUT y DELETE con urllib2

Os presento un sencilla receta para implementar peticiones PUT y DELETE con la libreria urllib2 de python:

import urllib2

opener = urllib2.build_opener(urllib2.HTTPHandler)
request = urllib2.Request('localhost')

# Metodo Put
request.get_method = lambda: 'PUT'

# Metodo Delete
request.get_method = lambda: 'DELETE'

response = opener.open(request)

Nueva versión de Clicarriots – Cliente sencillo en python para la plataforma Carriots.com

Hace unos días he libera una nueva versión de Clicarriots, un sencillo cliente escrito en python para utilizar la plataforma de IoT carriots.com

Por ahora es bastante sencillo y solamente permite trabajar con Streams y Devices, espero poder ir actualizándolo mas a menudo para conseguir un completo cliente para carriots.com

Instalar la libreria es sencillo, utilizaremos la conocida herramiento pip apuntando al repositorio de github:

pip install git+https://github.com/sdeancos/clicarriots.git#egg=clicarriots

Utilizarlo es aun mas sencillo, he aquí un ejemplo sencillo para mandar un trama de carriots.com

from clicarriots import api
from datetime import datetime

client_stream = api.Stream("YOUR APIKEY")
my_at = datetime.utcnow()
data = {"KEY":"VALUE"}
code, response = client_stream.send('ID_DEVELOPER_DEVICE', data, my_at, 'stream')

Puede encontrar mas información en el repositorio de github: https://github.com/sdeancos/clicarriots

Espero que sea de ayuda a todo aquellos que se quieran adentrar en mundo del IoT.

Arreglar desaparición de Paneles de Unity en Ubuntu 13.04

Muchos usuarios al actualizar su distribución Ubuntu hacia la versión 13.04 han visto como los panales de Unity desaparecieron como por arte de magia, yo lamentablemente fui uno de ellos. Cuando actualice mi distribución quise instalar los drivers de mi tarjeta gráfica y esto provoco lo anteriormente comentado. Rápidamente busque alguna solución y después de un par de hora de búsquedas en launchpad descubrí que no era al único que le había pasado algo parecido y que probablemente se debía a un bug.

Lo mejor de todo esto es que tiene solución, he aquí:

El primer paso es borrar la configuración antigua de compiz:

$ rm -rf ~/.config/compiz-1

Acto seguido deberemos reiniciar la configuración por defecto:

$ dconf reset -f /org/compiz/

Ya solo nos queda reiniciar y todo debería estar ya es su sitio.

Para mas información sobre este bug os hago referencia al lugar del bug en launchpad: https://bugs.launchpad.net/ubuntu/+source/unity/+bug/1128348

Nota: Para los que no puedan abrir un terminal pueden probar a lanzarlo mediante shortcuts, Control + Alt + t

Instalar MongoDB en Ubuntu

En este breve articulo explicare como instalar y configurar rápidamente MongoDB en un entorno Ubuntu 12.10 desde los repositorios oficiales de 10gen la empresa desarrolladora de MongoDB.

Lo primero que debemos hacer es conseguir las llaves publicas del repositorio oficial de 10gen:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10

Cuando termina el proceso anterior debemos crear el fichero /etc/apt/sources.list.d/10gen.list y añadir la siguiente linea deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen.

Para a continuación actualizar nuestra lista de repositorios:

$ sudo apt-get update

Ahora solo queda instalar el paquete de MongoDB:

$ sudo apt-get install mongodb-10gen

Una vez termine el proceso de instalación de la ultima versión estable de MongoDB podemos probarla para constatar que todo ha ido correctamente. Para ello basta con lanzar el cliente de mongodb.

$ mongo
MongoDB shell version: 2.2.2
connecting to: test
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see

http://docs.mongodb.org/

Questions? Try the support group

http://groups.google.com/group/mongodb-user

> use test
switched to db test
> db.coleccion.save({"nombre":"Samuel de Ancos", "url":"http://www.deancos.com"})
> db.coleccion.find()
{ "_id" : ObjectId("5103cc7cd36f372a94dfe038"), "nombre" : "Samuel de Ancos", "url" : "http://www.deancos.com" }
> exit
bye

Cuando MongoDB se instala por este procedimiento automáticamente podrás controlarlo como cualquier proceso del sistema:

$ sudo service mongodb start
$ sudo service mongodb stop
$ sudo service mongodb restart

Si necesitas cambiar alguna configuración podrás encontrar el fichero de configuración en /etc/mongodb.conf, en el podrás comprobar por ejemplo donde se encuentra el store de base de datos o la ruta de los logs:

dbpath=/var/lib/mongodb

#where to log
logpath=/var/log/mongodb/mongodb.log