martes, 31 de diciembre de 2013

Acceso a la Raspberry Pi desde Android

Dos programitas (que funcionan a la primera) para acceder desde un dispositivo Android a la Raspberry, lo que resulta muy útil si no tienes conectado un monitor a la placa.  En primer lugar, con Server Auditor podemos iniciar una sesión SSH para acceder en modo terminal a la RPi.  Como en cualquier conexión SSH, sólo se necesita el usuario, su password y la dirección IP de red de la RPi (sé sincero:  seguro que no has creado un nuevo usuario y sigues con la misma contraseña de inicio).  Enseguida se hace uno con el manejo de la sesión con Server Auditor, que ofrece todo lo fundamental que se le puede exigir:

Consola Raspberry Pi en Android

No hace falta decir que en la configuración más básica el dispositivo Android debe estar conectado a la misma red que la Raspberry.  Para mayor comodidad en su acceso, en vez de utilizar DHCP puede resultar conveniente usar una dirección fija para la RPi (que hay que recordar, claro).  Esta dirección es la que pasaremos al Server Auditor para acceder, y que queda guardada para posteriores sesiones.  Aquí hay un buen tutorial para fijar la IP, que tendrás que modificar, en su caso, para adecuarla a la numeración de tu red.   

El segundo programa interesante es un cliente VNC, bVNC Free, que nos permitirá correr un escritorio remoto en el dispositivo Android.  Una vez que hemos conseguido acceso SSH con Server Auditor, desde la línea de comandos de la RPi podemos lanzar el VNC para iniciar otra sesión, pero esta vez en modo gráfico como escritorio remoto.  No recuerdo ahora si el servidor Tight VNC venía con el software de serie de la Raspberry (que creo que sí) pero en cualquier caso su instalación es muy sencilla siguiendo los pasos de esta dirección.  Por tanto, una vez instalado el VNC, podemos lanzar el servidor con el comando:

sudo vncserver :0 -geometry 1024x600 -depth 24 -dpi 96

Como utilizo una Galaxy tab de las primeras, que tienen una pantalla de 1024x600 píxeles, es la resolución que paso como parámetro al arrancar el VNC, pero puede ajustarse según el dispositivo en el que se vaya a visualizar el escritorio de la RPi.  Si bajas la profundidad de color de 24 a 16 bits, irá algo más rápido.  

Con bVNC es fácil establecer la conexión.  En su configuración más básica sólo tendremos que poner la dirección IP de la Raspberry y la password, y pulsar el botón de Connect.  Y ya está:  el resultado (una pantalla táctil para la RPi!) queda así de chulo (pero, eso sí, no pidas alta velocidad de refresco):

Escritorio remoto Raspberry Pi en Android

Para facilitar su uso, la imagen del escritorio puede ampliarse con los gestos habituales de la interfaz Android, aunque también puede hacerse uso del teclado del dispositivo, accesible mediante un icono que aparece cuando se toca la pantalla táctil.

Hay unos cuantos programas más para Android/RPi que tienen buena pinta pero que no he probado.  Con RasPi Check, de un vistazo se tiene un resumen del estado de la RPi.  Y con GPIO Tool se puede jugar con el conjunto de pins IO de la placa, aunque su instalación (que necesita software tanto en el Android como en la Raspberry) parece un tanto pintoresca.   

sábado, 28 de diciembre de 2013

La luna es una amante cruel

[Parece, en ocasiones, que el jazz nórdico está abonado al drama | Radka Toneff murió en 1982 con 30 años y tres discos de cálida voz | En su tercero, Fairytales (1982), bordó el superestándar de Jim Web The Moon is a Harsh Mistress | Steve Dobrogosz al piano]


[Per Jorgensen a la trompeta y el propio Dobrogosz al piano | Precisamente en un homenaje a Radka en 2009]


[Grazyna Auguscik, otra voz europea, interpreta el mismo tema con rúbrica de matices latinos | The River, 2001]


[Bonus: Ricardo Gallén toma prestados los arreglos de Pat Metheny y hace una interpretación clásica y sobria, que no desmerece con las anteriores | En directo, 2009]


[Por cierto, hace más de cuatro años ya habíamos visitado la versión de Pat Metheny y Charlie Haden de su Beyond the Missouri Sky, 1997]

sábado, 30 de noviembre de 2013

Señoras y señores: Keith Jarrett

[Keith Jarrett Trio | Georgia On My Mind | Por si creías haber probado todos los sabores de este estándar, el heterodoxo Jarrett ofrece su lectura particular]

viernes, 29 de noviembre de 2013

Las tempranas imágenes del espacio: una odisea predigital [I]

En 1979, a las puertas de la revolución digital, el Voyager I tomaba unas increíbles fotografías de Io, el satélite de Júpiter más espectacular por su superficie de continua actividad volcánica.  Para la época y los avances del momento, el proyecto Voyager (hoy todavía vivo) supone un excepcional hito de la ingeniería y un desafío tecnológico comparable al viaje a la Luna que se había desarrollado entre una y dos décadas antes.

El University College London, de la Universidad de Londres, mantiene una pequeña pero significativa colección de imágenes históricas del espacio que incluyen algunos mosaicos analógicos (¡pegamento!) que se confeccionaron con las fotografías de algunos satélites, y en particular de Io, tomadas por la Voyager I (pulsar para alta resolución, 33 megapixels):


Pocos años después la tecnología digital haría parecer un trabajo escolar a este tipo de presentaciones, pero su relativa sencillez y poca sofisticación no debe hacer olvidar la  extraordinaria infraestructura tecnológica que subyace tras la imagen.

[Hace pocas semanas, y según la NASA, la posición de la nave ha sido declarada oficialmente como fuera del sistema solar | Se encuentra a más de 18 mil millones de kilómetros de la Tierra, dirigiéndose hacia el centro de la galaxia | Se espera funcional hasta bien entrada la década de los 2020]

sábado, 16 de noviembre de 2013

Wavelets: una primera aproximación

Un mapa conceptual (un resumen, vaya) de las ideas básicas de la Getting Started Guide del Wavelet Toolbox de Matlab:
 

[Hecho con la versión gratuita de MindNode | Más info sobre wavelets aquí, aunque la denominación ondícula no parece tener excesivo éxito]

miércoles, 18 de septiembre de 2013

Retrofuturismo aplicado

Un punto de inteligente cachondeo bajo la visión del retrofuturismo, jugando con imágenes de estilo pasado pero invocando productos actuales.  Así, o parecido, habríamos visto anunciadas hace 40 o 50 años algunas de las redes sociales de hoy:  

http://media-cache-ec0.pinimg.com/736x/79/4a/a8/794aa88bea949610ba8005f4453bd0eb.jpg

El cartel de Prometheus, por ejemplo, podría haberse visto así en los años 50 del pasado siglo XX:

http://media-cache-ak0.pinimg.com/736x/c1/0a/92/c10a925212a8f0fb4337c7752290b997.jpg
Bonus:  una llave USB de precisión suiza con ingeniería steampunk:

http://media-cache-ec0.pinimg.com/736x/e1/86/16/e18616bc99013220acf4e86f7b66428a.jpg 
[Créditos: en Pinterest, aquí, aquí y aquí]

martes, 17 de septiembre de 2013

¿Cómo se ensaya a Bach?

[Chick Corea | Hacia el inicio, tomando el pulso a la partitura |  Práctica, trabajo, disciplina, perfeccionismo...]


[Glenn Gould | Hacia el final, puliendo la ejecución | Práctica, trabajo, disciplina, perfeccionismo... (lo mismo, qué casualidad)]

miércoles, 28 de agosto de 2013

Los blues del rock: cuando los grandes grupos interpretaban blues (es que no lo podían remediar)

[Rainbow | On Stage - 1977 | Blues]



[Led Zeppelin | Led Zeppelin III - 1970  | Sice I've Been Loving You]



[Pink Floyd | Meddle - 1971 | Seamus]

martes, 27 de agosto de 2013

Montaña Amarilla [Tenerife Sur]



El Monumento Natural de Montaña Amarilla es un cono volcánico integrado en un conjunto alineado de volcanes del sur de Tenerife. Cuenta con una extensión de unas 27 Ha, y casi alcanza los 75 metros en su parte más alta. Tuvo su origen en una erupción freatomagmática (erupción que entra inmediatamente en contacto con el agua), con posterior explosión estromboliana, allá por el cuaternario (edad de la que se mantiene una duna fósil puesta al descubierto por la erosiónd el mar), y el borde superior del cono presenta una altura desigual en su perímetro, con una apreciable hendidura en el lado este que casi deja el nivel del interior del cono a la misma altura que el terreno exterior.


El recorrido por el borde superior del cono es un agradable paseo. La moderada altura y los múltiples caminos que recorren el volcán permiten una tranquila caminata para, en una o dos horas, dar la vuelta al cono, haber entrado hasta su interior, y haber disfrutado de las vistas desde sus partes más elevadas.

Su cara sur está siendo continuamente erosionado por el mar. Esta parte, con la marea baja, es asombrosamente hermosa y merece un post aparte.  Pero nos ocupa ahora su zona norte, la mayor parte del año absolutamente árida al tratarse de una de las zonas de mayor insolación y más secas de toda la isla. Sólo los cardones (Euphorbia canariensis) y las tabaibas (Euphorbia balasamifera) se atreven a habitar en este lugar, expuesto al ardiente aire sahariano cuando el anticiclón de las Azores pierde su fuerza en los meses de mayores temperaturas.

Pero tras las lluvias del invierno (pocas pero intensas, si las hay) se abre paso una primavera efímera que llena de color el árido suelo y reverdece las tabaibas. Entonces, y a la luz del atardecer preferentemente, el paraje se convierte en un lugar mágico. No dura muchas semanas el espectáculo, pero merece la pena.





domingo, 25 de agosto de 2013

Compilación cruzada para Raspberry Pi desde Windows [y IV]: ejecución remota desde Windows

Hace unas semanas empezamos a ver cómo compilar para Raspberry Pi y desde Windows programas escritos en C o C++, a lo que añadimos un post sobre cómo incluir en el entorno de Windows la biblioteca BCM2835 (que permite acceder a los recursos IO de la RPi desde fuentes en C o C++).  En el último post sobre el tema vimos cómo habilitar Notepad++ mediante su plugin NppExec para poder trabajar de forma más comoda y visual los puntos anteriores.  En su último párrafo nos preguntábamos si podríamos ser más ambiciosos y llevar más allá esta filosofía de obtener resultados con tan sólo pulsar una tecla para, por ejemplo, descargar en la RPi el ejecutable y hacerlo correr tras haberlo compilado.  Ya avanzábamos que la respuesta era afirmativa, que podíamos hacer lo propuesto aunque con algo de trabajo.  

Si sólo quieres empezar a codificar y a ejecutar, ve al final del post y copia el código en un nuevo script de NppExec/Notepad++, e instala putty para Windows (utiliza el instalador putty-0.xx-installer.exe) e introduce sus ejecutables en la variable de entorno PATH.  Pero si quieres algo de diversión, sigue el proceso hasta llegar al script final.  Te aseguro que te servirá en adelante para personalizar tu entorno según tus necesidades o preferencias.

Vamos a hacer en primer lugar un poco de ingeniería de software definiendo los requisitos que necesitamos resolver tras haber terminado de codificar o modificar nuestras fuentes:
  1. Salvar el fichero de código C o C++ que estamos trabajando (ya conseguido en el post anterior)
  2. Compilar el código (también conseguido, como vimos)
  3. Transferir el ejecutable obtenido en el punto anterior a la Raspberry
  4. Otorgar permisos de ejecución al ejecutable, ahora residente en la RPi
  5. Ejecutar el programa bajo el SO de la RPi
Cumplidos los requisitos anteriores mediante los oportunos comandos o utilidades, y si somos capaces de reunir estos últimos en un único script, podremos conseguir todo lo anterior mediante una sóla tecla o entrada de menú.  No obstante, por propia experiencia avanzo que es conveniente añadir algunos matices adicionales:
  • Antes de transferir a la RPi el fichero ejecutable obtenido tras el paso 2, es conveniente matar un posible proceso en ejecución del mismo programa que hayamos lanzado, por ejemplo, antes de modificar su código.  Si no lo hacemos así, la ejecución paralela de dos procesos actuando sobre los mismos recursos nos dará problemas.  Eliminar el proceso es posible hacerlo manualmente, claro, pero será más eficiente si integramos esta acción en nuestra tubería.  Podríamos enumerar este requisito como 2.1.
  • Tras haber matado el proceso según el punto anterior, y aunque no es estrictamente necesario, borramos el ejecutable a sustituir por la nueva compilación.  Enumeramos este requisito como 2.2.  Sobra decir que si se trata de la primera compilación cualquiera de estos dos puntos sobra, pero su ejecución sólo conllevará los correspondientes mensajes de error por no existir ni el proceso a aniquilar ni el fichero a eliminar.
Una vez tenemos claro qué queremos hacer, podemos ponernos manos a la obra:  ya tenemos el código que nos resuelve los requisitos 1 (salvar el código) y 2 (compilación), así que empezamos por el requisito 2.1 (matar un posible proceso de un código anterior ya en ejecución).  Seguro que tenemos claro que el comando de Linux pkill nos sirve para eliminar un proceso dado su nombre.  Es decir, pkill holamundo, por ejemplo, acabaría con un posible proceso en ejecución correspondiente a un ejecutable denominado holamundo (ojo:  en realidad, acabaría con todos los procesos que incluyeran la expresión holamundo en su nombre, por lo que hay que tener cuidado y, desde luego, no ejecutarlo nunca como root).  Pero como estamos trabajando bajo un entorno Windows necesitamos ejecutarlo desde este último SO.  ¿Cómo?  Con putty, una implementación cliente SSH para Windows (entre otros SO) cuyo ejecutable putty.exe nos permitirá establecer una sesión remota con la Raspberry desde Windows.

Habrá que descargar, por tanto, el paquete necesario que se encuentra aquí (utiliza el instalador putty-0.xx-installer.exe).  Tras su instalación en Windows, es conveniente modificar la variable de entorno PATH para que recoja la ruta hasta los ejecutables (normalmente C:\Program Files\PuTTY), lo que evitará tener que teclear la ruta completa cada vez que se acceda a esta utilidades. 

El problema es que la línea de comandos de putty no está diseñada para transferir un único (¿?) comando Linux, sino que debe leerlos de un fichero.  Por lo tanto, nuestro trabajo se complica un tanto, pero nada grave.  Así que tendremos que crear al vuelo un fichero, introducirle el comando o comandos a transferir a la RPi, ejecutar putty para que lea y ejecute remotamente los comandos, y finalmente limpiar la basura para que no nos vayan quedando ficheros por ahí.  Para crear el fichero mediante un comando Windows, ejecutaremos

cmd /c echo sudo pkill nombre_proceso_a_matar >> fichero_de_comandos

La sentencia es sencilla:  utilizamos cmd /c, el comando de comandos de Windows, para emitir un echo que añadirá el comando Linux sudo pkill nombre_proceso_a_matar en el fichero fichero_de_comandos, que por cierto creará si no existe.  Más tarde, una vez cumplida su función, el fichero será eliminado mediante 

cmd /c del fichero_de_comandos

que tiene una construcción semejante, utilizando ahora el comando del, a la que acabamos de ver.

En términos prácticos, tenemos que incluir en nuestro script

cmd /c echo sudo pkill $(NAME_PART) >> $(CURRENT_DIRECTORY)\RPiKill

putty.exe –ssh –pw raspberry –m $(CURRENT_DIRECTORY)\RPiKill pi@192.168.1.118
cmd /c echo del $(CURRENT_DIRECTORY)\RPiKill

donde hemos utilizado las variables NAME_PART para el nombre del ejecutable y CURRENT_DIRECTORY para el directorio actual, mientras que hemos llamado arbitrariamente RPiKill al fichero instrumental que va a registrar este comando.  En la línea de comandos de putty se incluye la contraseña de acceso a la Raspberry, que puede omitirse en el raro caso (en este contexto) de que la seguridad sea importante, aunque con el precio de tener que introducirla manualmente, lo que relativiza la eficiencia de este mecanismo.  Para saber más sobre la ejecución de putty en línea de comandos, puedes visitar esta página.  La dirección de red de la RPi habrá que acomodarla a la realmente usada.  Los puntos suspensivos representan otro código adicional que veremos a continuación.

Avanzaremos ahora más deprisa con el requisito 2.2 (eliminación del ejecutable a sustituir), para lo que utilizaremos

cmd /c echo rm $(NAME_PART) >> $(CURRENT_DIRECTORY)\RPiDel
 
putty.exe –ssh –pw raspberry –m $(CURRENT_DIRECTORY)\RPiDel pi@192.168.1.118
 
El fichero RPiDel lo eliminaremos posteriormente de igual manera a la ya vista.

El siguiente requisito, el número 3, supone la transferencia del fichero ejecutable compilado en Windows para que se ejecute nativamente en el Linux de la RPi.  En los posts anteriores utilizábamos métodos de transferencia cómodos mediante un terminal (SmarTTY, en particular), pero ahora buscamos una utilidad que nos permita realizarlo desde la línea de comandos de Windows.  Esta utilidad es pscp, que se instala cuando instalamos el paquete de putty.  La sentencia genérica para su utilización es
pscp.exe –pw raspberry fichero_a_transferir destino

que para nuestros efectos podemos expandirla a

pscp.exe –pw raspberry $(CURRENT_DIRECTORY)\$(NAME_PART) pi@192.168.1.118

con parecidos comentarios sobre seguridad y expansión de las variables a los efectuados más arriba. 

Ya sólo nos queda tratar los dos últimos requisitos (dar permisos de ejecución y ejecutar el programa), que vamos a tratar simultáneamente.  Para ello, recordaremos que los permisos de ejecución los damos en Linux con (por ejemplo) el comando chmod a+x ejecutable, y que la ejecución de un programa situado en el directorio de trabajo se consigue con ./ejecutable puesto que normalmente, y por motivos de seguridad, no se incluye en la variable de entorno PATH de Linux el directorio actual.  Además, si hemos utilizado la librería BCM2835 (que accede al hardware de la RPi), tendremos que ejecutar como root.  En resumen, en un nuevo fichero instrumental que llamaremos RPiExe incluiremos los dos comandos a transferir a la RPi mediante putty:

cmd /c echo chmod a+x $(NAME_PART) >> $(CURRENT_DIRECTORY)\RPiExe

cmd /c echo sudo ./$(NAME_PART) >> $(CURRENT_DIRECTORY)\RPiExe

putty.exe –ssh –pw raspberry –m $(CURRENT_DIRECTORY)\RPiExe pi@192.168.1.118 

De la misma manera que en los casos anteriores, eliminaremos el fichero RPiExe una vez cumplida su función.

Y esto ha sido todo.  El código completo de nuestro script quedaría:

Pueden eliminarse o modificarse algunos de los pasos, incluyéndolos en otros scripts o ejecuciones externas ordenadas desde dentro del propio Notepad++.  Lo importante es comprender los mecanismos de actuación que nos permite el plugin NppExec, con lo que la flexibilidad de nuestro entorno la tendremos asegurada.


sábado, 24 de agosto de 2013

Portadas de magazines Sci-Fi de los años 40 y 50 del pasado siglo

[Aquellos maravillosos años | Algunas fantásticas portadas de magazines y carteles de películas de ciencia ficción de los años 40 y 50 del siglo XX]
 
Weird Fantasy trasn monster
















Captain Future 1942
Devil Girl from Mars  



























 
[Cortesía de los usuarios de Flickr x-ray_delta_one y Pat Gavin | En particular, x-ray_delta_one mantiene una magnífica colección genérica de imágenes, fotografías y anuncios de aquellos años (de los USA, fundamentalmente | Impresas (éstas u otras de las muchas que hay colgadas) desde sus  resoluciones más altas, y enmarcadas en un marco de Ikea con su passepartout y todo, no deben faltar en la habitación de todo buen friki]

jueves, 8 de agosto de 2013

Compilación cruzada para Raspberry Pi desde Windows [III]: un IDE ligero y funcional con Notepad++

En el primer post sobre compilación cruzada para Raspberry Pi desde Windows vimos los fundamentos de la toolchain que SysProgs ofreceEn el segundo, complementamos la instalación de la toolchain con la librería BCM2835, que permite el acceso cómodo a los pins IO de la RPi.  Lo que pretendemos ahora no es sólo disfrutar de una edición de código cómoda, sino complementarla con un proceso de compilación y gestión de los ejecutables productivo y eficiente. Elegimos para ello el software Notepad++, que es un conocido editor de ficheros de texto orientado a la programación, distribuido bajo GPL, y con unos cuantos años ya a sus espaldas. Su arquitectura abierta ha permitido diseñar un buen número de plugins que complementan las típicas (y no tan típicas) opciones de edición de código que este editor ya implementa de serie.

image

Es, precisamente, uno de sus plugins, NppExec, el que nos va a permitir habilitar opciones de ejecución de programas o comandos externos con los que conseguir, como vamos a ver, nuestros objetivos. 
Empezaremos por activar NppExec, para lo que iremos al menú Plugins de Notepad++, y allí elegiremos la opción Plugin Manager / Show Plugin Manager, lo que abrirá la ventana del gestor de plugins. En ésta, marcaremos el plugin y lo instalaremos pulsando el botón Install
 image

Inmediatamente después tendremos acceso a las opciones del plugin por medio del menú Plugins: 

image
 
Es a partir de este momento cuando podemos empezar a disfrutar de la potencia de la ejecución de programas externos. En primer lugar, recordemos del primer post sobre la compilación cruzada para la Raspberry Pi qué comando utilizábamos para compilar con gcc cualquier programa escrito en C (o C++): 

arm-linux-gnueabihf-gcc.exe nombre_programa.c –o nombre_programa_compilado 

que guarda alguna semejanza con el siguiente código que introduciremos en el cuadro que se abre cuando pulsamos la opción Execute del plugin (a la que podemos acceder directamente pulsando la tecla de función F6): 

image

Vamos por partes: en primer lugar, encontramos el comando NPP_SAVE, que es propio del plugin NppExec. Lo que hace este comando es salvar por nosotros el archivo fuente editado cada vez que llamemos a ejecución este código que estamos implementando, con lo que ya nos ahorramos una acción. 
La siguiente línea ejecuta el compilador, que es invocado por su nombre incluyendo su ruta completa. Sólo haría falta el nombre del programa si su ubicación estuviera registrada en la variable de entorno PATH. A continuación encontramos el término $(FULL_CURRENT_PATH), que se trata de la expansión de la variable predefinida del plugin FULL_CURRENT_PATH, y que hace referencia al nombre completo (incluyendo ruta) del fichero de código fuente. En el ejemplo que se ve en las pantallas, haría referencia al fichero holamundo.c que pretendemos compilar. 

Finalmente, encontramos la expresión –o $(CURRENT_DIRECTORY)\$(NAME_PART), que corresponde a la parte de la salida del comando de ejecución de GCC. La variable predefinida CURRENT_DIRECTORY referencia al directorio actual, que es el mismo en el que se mantiene el fichero fuente. Tras expandirla, le hacemos seguir a continuación el carácter “\” para, inmediatamente después, expandir la variable NAME_PART, que toma el valor del nombre del fichero sin su extensión (en nuestro ejemplo, esta variable toma como valor el nombre del fichero holamundo.c sin su extensión, por lo que la compilación nos dará como resultado un fichero ejecutable denominado holamundo). Podemos, por supuesto, consignar el directorio o el nombre del ejecutable que deseemos. Por ejemplo, $(CURRENT_DIRECTORY)\build\out situará el resultado final de la compilación (que se denominará out) en el directorio build, que será un subdirectorio del actual. 

Una vez introducidos estos comandos, pulsaremos Save…, llamaremos a nuestro script con el nombre que deseemos (por ejemplo, “RPi gcc”) en la ventana que se abre, y pulsaremos Save, con lo que ya tendremos salvado este procedimiento de compilación. 

En la misma ventana de Execute, activaremos el script pulsando OK, lo que provocará la compilación del programa. Los resultados los podremos revisar en la propia consola de Notepad++, que habremos activado con el icono Show Console Dialog (en nuestra versión de Notepad++, el tercer icono por la derecha). Como vemos en la pantalla, en el ejemplo tenemos un error en el código que es puesto de manifiesto por la salida de GCC, interceptada por la consola de Notepad++:

image  
Para mayor comodidad, podemos incluir una entrada directa a este procedimiento en el menú Macro, para lo que iremos al menú Plugins / NppExec / Advanced Options…, donde elegiremos nuestro script en Associated script y lo denominaremos como creamos conveniente, marcando la opción Place to the Macros submenu:


Una vez que rearranquemos Notepad++, tendremos acceso directo al script de compilación desde el menú Macro:


Finalmente, vamos a asignar una combinación de teclas para, todavía, mayor facilidad de acceso a la orden de compilación. Para ello vamos al menú Configuración, donde entramos en el Gestor de atajos de teclado… 


En la ventana que se abre, elegiremos la pestaña u opción Plugin commands, donde encontraremos nuestra entrada (RPi gcc), la seleccionaremos pulsando encima de ella, y pulsaremos después el botón Modify


En la ventana de Shortcut que se nos abre elegiremos la opción de teclas que queramos (ojo, las opciones de combinaciones libres no son tantas; si no funciona la combinación elegida quizá ya esté tomada por otro comando o script). Pulsaremos OK y en la ventana del Shortcut mapper pulsaremos Close, con lo que ya tendremos acceso a la compilación pulsando la combinación de teclas elegidas (en nuestro ejemplo, Ctrl+F10 desencadenará el compilado del programa fuente activo). 
Podremos añadir otros scripts. Por ejemplo, para incluir la librería BCM2835 el comando de compilación debería ser:

C:\SysGCC\Raspberry\bin\arm-linux-gnueabihf-gcc.exe $(FULL_CURRENT_PATH) -l bcm2835 -o $(CURRENT_DIRECTORY)\$(NAME_PART)

O añadiendo la opción –ggdb al comando de compilación, lo que aportará al ejecutable abundante información de compilación que podrá explotarse con GDB, el depurador GNU:


De la misma manera, es fácil incorporar otro script que ejecutara directamente GDB (arm-linux-gnueabihf-gdb.exe) en la consola de Notepad++. Como ya se comentó en el primer post sobre la compilación cruzada para la RPi, el tutorial de SysProgs sobre su toolchain incluye una introducción muy sencilla y básica a la depuración remota desde Windows de una ejecución bajo el Linux de la Raspberry Pi. 


Finalmente, podremos arrancar programas externos desde el propio Notepad++. Iremos al menú Ejecutar / Ejecutar, donde en la ventana correspondiente elegiremos el programa a ejecutar. Cuando pulsemos Guardar… se abrirá la venta de Shortcut que nos permitirá elegir una combinación de teclas para ejecutar el programa externo: 
 

Creo que puede atisbarse la potencia de los scripts del plugin de Notepad++, así que expandamos nuestra ambición:  ¿podríamos, entonces, complementar los comandos que hemos visto con algún otro que descargara el ejecutable directamente desde el entorno Windows a la Raspeberry Pi?  Y ya puestos, ¿podríamos marcar de forma remota este fichero como ejecutable?  ¿E iniciar su ejecución?  Las respuestas son sí, sí y sí.  Pero llevará su trabajo en el próximo post.  

viernes, 2 de agosto de 2013

Un mundo de covers [algo ligerito, que estamos en verano, hombre]

[Somebody That I Used To Know | Gotye | Cover por Jake Coco y Madilyn Bailey | Nos falta Kimbra, pero casi no se echa de menos]


[Adele | Someone Like You | Cover por Walk off the Earth | No me digas que no es mejor que el original]


[The Verve Pipe | The Freshmen | Cover por Boyce Avenue | ¿Que para qué sirve un bajo?]

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.