domingo, 28 de julio de 2013

Exconvento de S. Agustín [Tacoronte]

El Exconvento de S. Agustín forma parte de un conjunto de edificaciones declarado Bien de Interés Cultural situado en el municipio tinerfeño de Tacoronte.  El conjunto se completa con la Iglesia del Cristo de Tacoronte (Santísimo Cristo de los Dolores y Agonía de Tacoronte), cristo de curiosa historia (no dejes de leerla en el enlace anterior a Wikipedia) y de iconografía única en Canarias.

La construcción del conjunto arquitectónico se comenzó en el siglo XVII, y hace pocos años el exconvento fue renovado en su mayor parte y reconvertido en espacio para usos culturales. Parece que la reforma acercó la distribución y estética del edificio a sus primitivos orígenes, y son este tipo de actuaciones las que te reconcilian (aunque sea brevemente) con algunas administraciones públicas.


Dejo algunas fotografías del antiguo, austero y precioso claustro, que incluye unas curiosas gárgolas de madera.  A la derecha, la imagen está tomada en dirección sur-norte, hacia la fachada de la que se dejan entrever los campanarios de la vecina Iglesia del Cristo de Tacoronte.

Por último, un primer plano de una de las gárgolas.

 
[Made by Numbers | Fotografía]

sábado, 27 de julio de 2013

Señoras y señores: Esbjörn Svensson

[Hace poco acaban de cumplirse los cinco años desde su prematura muerte | Esbjörn Svensson Trio | Seven Days of Falling / Elevation of Love]

viernes, 26 de julio de 2013

Compilación cruzada para Raspberry Pi desde Windows [II]: la librería BCM2835

El BCM2835 es un procesador orientado a aplicaciones multimedia, móviles y/o embebidas, y que resultó ser el de elección en el diseño de los sistemas Raspberry Pi. Mike McCauley ha elaborado una librería (http://www.airspayce.com/mikem/bcm2835/) para exponer fácil y elegantemente al programador los mecanismos de entrada y salida (IO) hardware de este procesador, y del que un subconjunto importante de ellos son físicamente accesibles de forma directa en el conector P1 de la RPi (para mayor información sobre este tema, ver http://elinux.org/RPi_Low-level_peripherals).

La instalación de la librería es muy sencilla bajo Linux. Copiando el procedimiento que se aporta en la página web de la librería, tenemos: 

# download the latest version of the library, say bcm2835-1.xx.tar.gz, then: 
tar zxvf bcm2835-1.xx.tar.gz 
cd bcm2835-1.xx 
./configure 
make 
sudo make check 
sudo make install 

Pero este es el procedimiento para su instalación en Linux-Raspbian, mientras que nuestro objetivo es atacar esta librería bajo Windows. La solución no es complicada. 

Para lograr lo anterior nos interesan dos ficheros en particular de la librería: 

 • bcm2835.h: este header acompaña a las fuentes de la librería. Como toda cabecera C, declara variables y funciones que serán utilizadas para lograr los objetivos que se proponen en la librería. En los programas que diseñemos que deban acceder a los GPIOs de la RPi haciendo uso de esta librería, deberemos incluir obligatoriamente este header mediante #include &#60bcm2835.h&#62.

libbcm2835.a: la librería propiamente dicha, y que se trata del fichero obtenido una vez compilada. Por su extensión (.a) ya sabemos que no es compartida (estática, por tanto), en contraposición a las librerías compartidas (o dinámicamente enlazadas) con extensión .so. Las variables y funciones de la librería, declaradas en bcm2835.h según ya hemos visto, serán accesibles en nuestros programas tras la inclusión de la cabecera comentada en el punto anterior. 

Mientras que el primero, bcm2835.h, ya lo podemos obtener del código fuente de la librería, el segundo lo obtendremos tras su compilación. Así que procederemos a descargar en nuestra Raspberry Pi, y por el procedimiento que entendamos conveniente, la última versión de la librería, sobre la que aplicaremos el procedimiento visto más arriba. Si estamos trabajando en el entorno Windows, manteniendo la RPi conectada a la misma red local que nuestro PC, podremos usar las opciones de transferencia de ficheros de SmarTTY. En particular, y tras descargar la librería a un directorio temporal de Windows, elegimos o creamos en el terminal conectado a nuestra RPi el directorio de descarga, nos situamos en él, y arrastramos a la pantalla del terminal el fichero en cuestión. Una vez en Raspbian, aplicamos el procedimiento de instalación, que en nuestro caso resultó completamente transparente y eficaz. 

Tras la instalación, el proceso habrá creado el directorio /bcm2835-1.xx/src, donde encontraremos, entre otros objetos, la librería creada libbcm2835.a, además de una copia de bcm2835.h. Por un mecanismo de transferencia recíproco al ya visto, copiaremos estos ficheros a Windows, para lo que podemos utilizar la utilidad Upload a file del menú SCP de SmarTTY. Estos ficheros, una vez en Windows, los añadiremos a los directorios de la toolchain GNU. Por ejemplo, y asumiendo que a la instalación de la toolchain hemos respetado los directorios de destino propuestos, podemos copiarlos en: 

 • bcm2835.h -> C:\SysGCC\Raspberry\lib\gcc\arm-linux-gnueabihf\4.6\include 

libbcm2835.a -> C:\SysGCC\Raspberry\lib\gcc\arm-linux-gnueabihf\4.6 

Existen otras combinaciones de archivado, pero esta propuesta funciona. 

Y ya está: hemos incluido en nuestro entorno el acceso a la librería bcm2835, que nos permitirá gestionar el conjunto de pins IO del procesador BCM2835, habilitando funciones extra propias de sistemas embebidos y cuya descripción ocuparía otro post. 

Pedimos prestado el código de ejemplo de la librería para encender y apagar un led, el blink que en todo sistema embebido constituye el "hola, mundo", y lo transcribimos para analizarlo someramente: 

// blink.c 
// 
// Example program for bcm2835 library 
// Blinks a pin on an off every 0.5 secs 
// 
// Author: Mike McCauley 
// Copyright (C) 2011 Mike McCauley 
// $Id: RF22.h,v 1.21 2012/05/30 01:51:25 mikem Exp $ 

#include &#60bcm2835.h&#62
// Blinks on RPi Plug P1 pin 11 (which is GPIO pin 17) 
#define PIN RPI_GPIO_P1_11 

int main(int argc, char **argv) 
{ 
    // If you call this, it will not actually access the GPIO 
    // Use for testing 
    // bcm2835_set_debug(1); 
    if (!bcm2835_init()) 
    return 1
    // Set the pin to be an output 
    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_OUTP); 
    // Blink 
    while (1) 
    { 
        // Turn it on 
        bcm2835_gpio_write(PIN, HIGH)
        // wait a bit 
        bcm2835_delay(500)
        // turn it off 
        bcm2835_gpio_write(PIN, LOW)
        // wait a bit 
        bcm2835_delay(500)
    } 
    bcm2835_close()
    return 0
} 

En primer lugar, a destacar la inclusión del header que nos permitirá acceder a la librería. Inmediatamente después, y por comodidad, definimos PIN como sinónimo de la declaración del pin 11 del conector P1 de la RPi, que en realidad corresponde al GPIO número 17 del procesador. 

Ya en main() hacemos varias cosas: 

1 - Activamos la librería mediante bcm2835_init(), sentencia obligatoria en todo código que quiera hacer uso de la misma. En general, el nombre de las funciones y variables de la librería utilizan el prefijo bcm2835_ como indicador de su espacio de nombres. 

2 - Configuramos el pin que hemos denominado PIN como de salida mediante la función bcm2835_gpio_fsel(), cuyos parámetros son autoexplicativos. 

3 - Y entramos, finalmente, en un bucle sin fin que pone a alto el pin en cuestión (por lo que se activará en el mismo una tensión de 3,3 voltios que puede encender un led conectado entre el pin y masa; ojo a la polaridad); espera medio segundo (aproximadamente: no estamos ante un sistema operativo de tiempo real); cancela la tensión en el pin poniéndolo a bajo; y espera otro medio segundo antes de volver a comenzar el bucle. 

Al final del código vemos una sentencia que proporciona un cierre ordenado de las funciones de la librería, bcm2835_close(), que es conveniente aplicar en la salida de todo código que la gestione, pero que en este ejemplo en particular no se llega a ejecutar nunca dado el ámbito temporal sin fin del bucle. 

Para la compilación del código podemos ejecutar en la consola de Windows, y dentro de la toolchain instalada, el siguiente comando: 

c:\ruta_de_acceso_a_toolchain\arm-linux-gnueabihf-g++.exe c:\ruta_de_acceso_a_fuentes\blink.c -o c:\ruta_de_acceso_a_compilaciones\blink 

tras el cual obtendremos el fichero ejecutable blink en el mismo directorio donde reside el código fuente. Obviamente tendremos que modificar las rutas de acceso a cada uno de los ficheros de acuerdo al esquema de nuestro propio sistema, u omitirlas siempre que cumplamos las reglas de acceso a los ficheros del sistema operativo o estén registradas en la variable de entorno de Windows PATH

El producto obtenido lo transferimos a nuestra Raspberry Pi. Seguramente nos resultará más cómodo utilizar las utilidades correspondientes del menú SCP de SmarTTY, o simplemente arrastrar el icono del archivo compilado a la ventana del terminal conectado a la RPi. 

Una vez en Linux/Raspbian, hay que dotarlo de los permisos necesarios para su ejecución mediante chmod a+x blink, para ejecutarlo a continuación mediante sudo ./blink.  Nótese la necesidad de ejecutar bajo root (si no es el usuario activo) con sudo, ya que se exigen sus privilegios para acceder a este hardware. 

Para los que se sientan cómodos con el trabajo mediante la consola de Windows (y, probablemente, con proyectos de muy pequeña envergadura), el trabajo termina aquí. Tenemos la toolchain funcionando, incluyendo la librería de ataque al hardware IO de la RPi, y un terminal muy útil como es SmarTTY apoyándonos en todo el trabajo de comunicación con (y de la gestión de) la placa. Para los que prefieran un entorno más amigable y productivo de programación, aún tendremos algunos ajustes adicionales. Merecerán la pena.

martes, 23 de julio de 2013

On air

[Dream Theater | The Spirit Carries On | Metropolis Pt2: Scenes from a Memory | while(1){for(min=2:50; min<4:24 min="" play="" span="">
<4:24 min="" play="" span=""> Una rapidita para acompañarte unos minutos. Si quieres.
<4:24 min="" play="" span=""><4:24 min="" play="" span="">
<4:24 min="" play="" span=""><4:24 min="" play="" span="">

lunes, 22 de julio de 2013

Compilación cruzada para Raspberry Pi desde Windows (fácilmente)

Aunque no excesivamente complicado, nunca ha sido del todo trivial la compilación bajo Windows de ejecutables Linux. Si además añadimos la complejidad de hacerlo para un sistema embebido y relativamente reciente como el de la Raspberry Pi (que abreviaremos en ocasiones como RPi), que supone gestionar funcionalidades hardware adicionales (GPIOs, I2C, SPI, PWM...), necesitamos un marco eficiente y claro que no resulta extremadamente sencillo de obtener en las primeras revisiones de todo lo que se nos ofrece. 

He elaborado un entorno de trabajo con herramientas gratuitas que, para proyectos moderados, proporciona facilidad de instalación, de gestión y de funcionamiento. Seguro que hay mecanismos más eficientes, pero este es el que he elegido (por encima del pesado Eclipse) y me funciona. El SO ha sido Windows Vista 64 bits, y no encuentro razones para que no se ejecute en otros sabores de la familia Windows. 

Como resumen previo, lo que vamos a hacer es lo siguiente: 
  1. Instalaremos una toolchain GNU en Windows particularmente sencilla de trabajar. La gente de SysProgs han generado una distribución de GCC y sus utilidades paralelas que acompañan con aplicaciones adicionales a las que daremos buen uso (particularmente a SmarTTY, un cliente SSH asombrosamente útil y fácil de utilizar).
  2. Como la toolchain no proporciona librerías para un acceso cómodo al hardware IO de la Raspberry Pi (aunque sí puede accederse de forma nativa según podemos ver en http://elinux.org/RPi_Low-level_peripherals#C_2), habilitaremos la librería BCM2835, de Mike McCauley (licencia GPL), en nuestro compilador cruzado de Windows. Una vez instalada tendremos un acceso útil y con poco código a los GPIOs (entradas y salidas de propósito general) de la RPi. El procedimiento que utilizaremos quizá puede resultar extensible a otras librerías, como WiringPi.
  3. Una vez hecho lo anterior, ya estamos en disposición de compilar programas C/C++ para RPi desde la línea de comandos de Windows. Pero le daremos una vuelta adicional a la situación para habilitar un IDE con Notepad++ que, además de editar el código, nos permitirá ejecutar cómodamente con teclas programables (o entradas de menú) el compilador GCC o el depurador GDB, así como transferir el programa compilado directamente a nuestra RPi con la ayuda de la utilidad pscp y de su hermano mayor, putty. El editor Notepad++, que también cuenta con licencia GNU/GPL, es una potente herramienta con enormes posibilidades de configuración que veremos cómo nos pueden ayudar para nuestros fines. 
Para quien esté leyendo este artículo, debo asumir que ya conoce como mínimo temas básicos de programación, de C, sobre qué es un compilador y la toolchain GNU, de la Raspberry Pi, del uso de los comandos Windows y del bash de Linux, de terminales, de GPIOs, y de algunos otros temas de relevancia sobre el asunto que nos ocupa. También asumo que, caso de necesitar alguna aclaración sobre los temas anteriores, el lector es capaz de hacer búsquedas de información con discriminación de los diferentes niveles de profundidad que sean necesarios. 


GNU Toolchain para Windows 

SysProgs ofrece precompilaciones para Windows de la toolchain GNU para distintas plataformas embedidas, y en particular para Raspberry Pi (aunque cualquiera puede también aventurarse en compilar las fuentes). El ejecutable de instalación puede obtenerse de http://gnutoolchains.com/raspberry/, y con un simple click del ratón tendremos lista la toolchain y un par de utilidades adicionales (un grabador de imágenes para tarjetas SD y el cliente SSH SmarTTY). Aunque no es crítico, conviene respetar el árbol de directorios de destino propuesto en la instalación, lo que permitirá compartir más fácilmente posibles acciones sobre los ficheros o directorios (como algunas de las propuestas en este documento). En cualquier caso, es aconsejable recordar que la instalación de este tipo de librerías y utilidades es conveniente realizarla en directorios y rutas que no contengan espacios, lo que evita errores posteriores en determinados casos.

En los parámetros de instalación, es útil dejar marcada la opción "Add binary directory to %PATH%", lo que nos permitirá invocar los ejecutables de la toolchain sin tener que teclear toda su ruta.  Lo agradeceremos cuando utilicemos la línea de comandos.  

En la web de SysProgs se proporciona también un completo tutorial, http://gnutoolchains.com/raspberry/tutorial/, en el que se incluye la descarga y grabación en una tarjeta SD de la imagen del sistema operativo Wheezy-Raspbian que ejecutará la RPi, y que en adelante asumiremos que es el instalado. Si ya tenemos la tarjeta grabada y en uso, tras la sencilla instalación de la toolchain ya podemos empezar a programar para la RPi en C/C++ bajo Windows con el siguiente esquema de trabajo: 



  1. Editar el código en cualquier editor de texto plano para Windows. 
  2. Una vez guardado el correspondiente archivo lo compilaremos con, por ejemplo, el comando arm-linux-gnueabihf-gcc.exe nombre_programa.c -o nombre_programa_compilado 
  3. El fichero compilado resultante lo trasladaremos desde Windows a la Raspberry Pi (con pscp o SmarTTY, por ejemplo), donde habrá que otorgarle los correspondientes permisos de ejecución mediante el comando chmod a+x nombre_programa_compilado 
  4. Tras lo anterior, podremos ejecutarlo en la Raspberry Pi mediante ./nombre_programa_compilado
En el tutorial ya comentado se incluye un ejemplo muy sencillo que hace uso del terminal SmartTTY para la comunicación con la RPi, incluyendo la transferencia del fichero compilado.

Por cierto, las transferencias de ficheros entre Windows y la placa no pueden ser más sencillas: arrastramos el icono del fichero a la ventana de texto del terminal, y nos guardará el ejecutable en el directorio de la RPi en el que estemos situados según el prompt de la línea de comandos de Linux, o bien utilizaremos las opciones del menú SCP. También se nos inicia en el uso del depurador cruzado: ejecutamos GDB bajo Windows depurando la ejecución bajo Raspbian del fichero compilado.

En cualquier caso, más adelante veremos un ejemplo completo con su guión de trabajo. Ahora es tiempo de complementar nuestra toolchain con una librería (libbcm2835) que nos permita acceder fácilmente al hardware de la RPi, lo que veremos en el siguiente post sobre este tema.