Jueves, 8. Mayo 2014

Beaglebone configuración WiFi

Pequeña receta para configurar el acceso a internet mediante WiFi con la placa libre Beaglebone.

Yo solo he conseguido hacer funcionar con una tarjeta wifi Belkin Wireless G USB Network Adapter (F5D7050)

Lo que debemos hacer es enchufar nuestra tarjeta wifi a la placa y después crear el siguiente fichero en /var/lib/connman/wifi.config

$ vim /var/lib/connman/wifi.config

[service_home]
Type = wifi
Name = NombrePuntoAcceso
Security = wpa2-psk
Passphrase = PasswordPuntoAcceso

$ :wq!

Lo guardamos y reiniciamos la beagle. Si todo ha ido correctamente ya tendremos acceso a internet mediante WiFi en nuestra placa.

(Si alguien consigue hacerlo funcionar con otras tarjetas WiFi de otros fabricantes y/o otros chipsets podría comentarlo en los comentarios de este post)

Miercoles, 7. Mayo 2014

Actualizar firmware Beaglebone desde Ubuntu

Estoy trasteando estos días con la placa Beaglebone, una placa libre muy parecida a RapsberryPi.

Lo primero que he intentado hacer es actualizar el firmware pues el que venia pre-instalado estaba un poco atrasado.

Para ello voy a intentar explicar el sencillo proceso que se debería realizar para ello desde un sistema operativo Ubuntu.

beagle.jpg

Lo primero que tenemos que hacer es descargarnos la ultima versión del firmware desde la pagina oficial: http://beagleboard.org/latest-images

Una vez la la tengamos en nuestra maquina, en nuestro caso:

Angstrom-Cloud9-IDE-GNOME-eglibc-ipk-v2012.12-beaglebone-2013.06.20.img.x_z

deberemos descomprimir el fichero, en Ubuntu es sencillo: nautilus > botón derecho > extraer aquí.

Ya tenemos nuestra imagen: Angstrom-Cloud9-IDE-GNOME-eglibc-ipk-v2012.12-beaglebone-2013.06.20.img

Ahora solo tenemos que grabarla en la tarjeta minisd, para ello utilizaremos la consola.

Lo primero es saber que devicenode ha asignado el sistema a nuestra tarjeta:

$ sudo dmesg | tail -20

...
[ 5047.076459] sd 10:0:0:0: [sdc] Attached SCSI removable disk
...

Solo nos interesa sdc, que es el nodo de la tarjeta.

Ahora solo nos queda copiar la imagen utilizando el comando dd:

$ sudo dd if=/home/path_donde_este/Angstrom-Cloud9-IDE-GNOME-eglibc-ipk-v2012.12-beaglebone-2013.06.20.img of=/dev/sdc bs=1M

Este proceso tardara un rato, una vez finalice ya tendremos la tarjeta programada y lista para insertarla en nuestra Beaglebone y probar el nuevo firmware.

Un vez arrancada podríamos actualizar los paquetes de la distribución a sus ultimas versiones:

$ opkg update
$ opkg upgrade

Con esto ya tendríamos nuestra beagle con la última versión funcionando!

Lunes, 7. Abril 2014

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

Presentación Internet Of Things + Raspberry Pi decharlas14

Jueves, 27. Marzo 2014

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.

Viernes, 27. Diciembre 2013

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

En la anterior entrega (http://deancos.com/articles/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.

Ir a tercera parte del tutorial: mini-tutorial-silex-autenticacion-iii

Viernes, 27. Diciembre 2013

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)

Jueves, 12. Diciembre 2013

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) &amp;gt; 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()

iot.jpg

Sabado, 9. Noviembre 2013

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!

Jueves, 22. Agosto 2013

(snippet) 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)

Jueves, 4. Julio 2013

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

(puedes utilizar ahora pip install 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.