Cristian Vicente

Limelight es un proyecto que trata de aprovechar la tecnología de streaming de las tarjetas gráficas de Nvidia para permitir jugar desde cualquier dispositivo. Entre ese «cualquier dispositivo» también entran las Rasperry Pi y, en mi caso, con Raspbmc.

Lo primero de todo será instalar la última versión disponible de Java (la versión de Oracle) ya que Limelight es un bonito jar. Para ello modificaremos los fuentes de APT para agregar los de Debian:

sudo vi /etc/apt/sources.list

Agregaremos esta línea

deb http://archive.raspberrypi.org/debian/ wheezy main

Haremos la importación de la clave, actualizaremos e instalaremos la versión 8 de java.

wget «http://archive.raspberrypi.org/debian/raspberrypi.gpg.key»

sudo apt-key add raspberrypi.gpg.key

sudo apt-get update

sudo apt-get install oracle-java8-jdk libopus-dev

Tras esto sólo nos queda descargar la última versión de Limelight de su Github.

wget –no-check-certificate «https://github.com/irtimmer/limelight-pi/releases/download/v1.2.1/limelight.jar»

Teniendo en cuenta que necesitamos un equipo que ejecute GeForce Experience 2.2.2 o superior (a parte de necesitar una gráfica Nvidia compatible), realizaremos el emparejamiento entre ambos dispositivos con el siguiente comando.

sudo java -jar limelight.jar pair 192.168.x.x

Y ya podremos lanzar Limelight desde nuestra Raspberry. Habrá que tener en cuenta que necesitaremos cerrar Xmbc/Kobi y cargar el módulo de sonido.

service kobi stop

modprobe snd_bcm2835

sudo java -jar limelight-pi.jar  stream 192.168.x.x

Si además tenemos un mando con el que queramos jugar tendremos primero que realizar un mapeado del mismo. En primer lugar tendremos que identificar dónde está nuestro mando y si ha sido reconocido correctamente. Para tal fin podremos utilizar evtest:

sudo apt-get install evtest
sudo evtest

Una vez localizada la ruta, realizaremos el mapeado del mismo y lo almacenaremos en un fichero (en mi caso el mando estaba en /dev/input/event2 y el fichero quería que fuese ps2-1.map).

sudo java -jar limelight.jar map -input /dev/input/event2 ps2-1.map

Así que, finalmente, ejecutaremos lo siguiente:

sudo java -jar limelight.jar -mapping /home/pi/ps2-1.map stream 192.168.x.x

Una última consideración a tener en cuenta es que deberemos tener Steam cerrado antes de lanzar Limelight y que, a pesar de que el rendimiento de vídeo a través de cable de red es muy bueno, el sonido a mi me ha estado dando problemas.

Cuando ejecutamos una aplicación a través de Wine, ésta tiene normalmente acceso a nuestro home, con lo que nos podemos llevar un buen susto si dicha aplicación le da por hacer maldades. Para evitar esta problemática, podemos optar por diversas soluciones, ejecutar Wine con otro usuario distinto al nuestro o hacer uso de un sandbox (algo así como un entorno aislado).

Sólo necesitamos ejecutar una orden con winetricks para hacer que todo aquello que se ejecute después con Wine lo haga en un sandbox.

winetricks sandbox

De todos modos, si queréis más seguridad os recomiendo la lectura de Securing Wine.

Tras el brusco cambio de rumbo en el desarrollo del navegador web Opera, donde se adoptó el motor de Chrome debido a la dificultad de mantener el suyo propio, perdió todo su atractivo al perder con ello todas las características que lo hacían especial.

No obstante, el desarrollo no se ha parado y continúan integrando todo aquello que se quedó por el camino, algo que podemos consultar desde su blog. Desde éste podremos descargar la versión para la plataforma en la que estemos y, para aquellos que tengan distro basada en RPM, alguien tuvo el buen gusto de publicar un script (rpm4opera) que lo genera a partir del DEB.

Si queremos tener accesible nuestra Raspberry a través de una conexión a Internet que nos provee una IP dinámica, podemos hacer uso de la API de DigitalOcean para configurar un subdominio que vaya cambiando su IP a la par que la nuestra.

Para ello deberemos crear un nuevo token desde el panel de administración de DigitalOcean, algo parecido a una especie de hash.

Después crearemos un nuevo registro de tipo A en el gestor de DNS que podemos llamar «home», con lo que nuestro dominio dinámico será algo así como «home.midominio.com».

Después haremos un script en nuestra Raspberry que tenga el siguiente aspecto:

!/bin/bash
var_token=»nuestroToken»
var_domain=»midominio.com»
var_record_id=»elIDdeHome»
var_ip=$(curl -s icanhazip.com)

## Devuelve las últimas acciones realizadas ##
#curl -X GET «https://api.digitalocean.com/v2/actions» \
# -H «Authorization: Bearer $var_token»
## Devuelve la información sobre el dominio ##
#curl -X GET «https://api.digitalocean.com/v2/domains/$var_domain/records» \
# -H «Authorization: Bearer $var_token»

## Cambia la IP del dominio ##
curl -X PUT «https://api.digitalocean.com/v2/domains/$var_domain/records/$var_record_id» \
-d'{«data»:»‘$var_ip'»}’ \
-H «Authorization: Bearer $var_token» \
-H «Content-Type: application/json»

Los únicos valores que tendremos que cambiar serán var_token (el token que hemos generado en el paso anterior), var_domain (el dominio que nos interesa modificar) y el var_record_id (un valor que deberemos recuperar).

Entonces, nuestra IP external la obtendremos gracias al servicio de «icanhzip.com» que soporta IPv4 e IPv6. El siguiente valor que nos interesa recuperar será el identificador del registro A de «home», que se obtiene ejecutando el siguiente script:

!/bin/bash
var_token=»nuestroToken»
var_domain=»midominio.com»

curl -X GET «https://api.digitalocean.com/v2/domains/$var_domain/records» \

-H «Authorization: Bearer $var_token»

Una vez editado el script con toda ésta información sólo nos quedará programarlo en Cron. Para ello ejecutaremos como root el siguiente comando:

crontab -e

Añadiremos la ruta hasta nuestro script y la información para que se ejecute todos los días cada 5 horas:

# Actualiza la IP en DigitalOcean
* */5 * * * /opt/dynamicDNS/dns-digitalocean.sh > /dev/null 2>&1 | logger «Digital Ocean – Updating IP»

No olvidar instalar Curl en Raspbmc si no lo tenéis ya:

apt-get install curl

Direcciones de interés:

Información relativa a la API v2 de DigitalOcean

Manual Básico de Cron

Si somos poseedores de una Raspberry Pi con Raspbmc de S.O., posiblemente echemos de menos poder utilizar la última versión de MLDonkey que provee de soporte para enlaces magnet.

Para ello será tan fácil como descargar el código fuente de MLDonkey y compilarlo con mucha paciencia en nuestra Raspberry.

Primero actualizaremos todos los paquetes de nuestro sistema e instalaremos la versión de MLDonkey que hay en los repositorios con los siguientes comando:

# sudo apt-get update

# sudo apt-get upgrade

# sudo apt-get install mldonkey

Luego descargaremos las utilidades necesarias para la compilación:

# sudo apt-get -y install gcc make bc

Descargaremos el código fuente de MLDonkey (hay que buscar en las descargas el enlace al «Source»), los descomprimiremos e iniciaremos la compilación:

# wget http://downloads.sourceforge.net/project/mldonkey/mldonkey/3.1.3/mldonkey-3.1.3.tar.bz2

# tar xvjf mldonkey-3.1.3.tar.bz2

# ./configure –enable-batch

# make mlnet.static

La compilación puede haber tardado unas horas, pero al final tendremos un fichero llamado «mlnet.static» que deberemos copiar con el siguiente comando, pero no sin antes hacer una copia de seguridad de la versión anterior por precaución:

# sudo mv /usr/bin/mlnet /usr/bin/mlnet.backup

# sudo cp mlnet.static /usr/bin/mlnet

Para vuestra comodidad os dejo el tarball que contiene el ejecutable ya compilado para ARM:

mldonkey-3.1.3.static.arm-Linux_glibc-2.13.tar

Cada vez los discos SSD son más populares debido a su velocidad de lectura/escritura y su tiempo de acceso frente a los discos magnéticos convencionales. Pero como con todo, estos discos tienen un debilidad que preocupa a sus dueños y es la vida útil.

Sin entrar en detalles diré que se hace uso de algoritmos especiales para intentar alargar la vida útil del disco SSD lo máximo posible tratando de no sobrescribir siempre los mismos sectores y evitando realizar usos que conlleven muchas escrituras sin sacarles provecho (como logs o temporales del navegador web.

Existe un hilo en los foros de OpenSuse en los que se dan consejos y pautas muy útiles para este propósito, como cargar el temporal en RAM, alojar ciertos directorios en un disco duro magnético, etc.

Debido a lo poco fiable que resultaba la indicación en tiempo de la vida energética de las baterías en portátiles, ésta fue retirada del widget Battery Monitor de KDE a partir de la versión 4.3, manteniendo únicamente el porcentaje.

Aunque dicha medición fuese poco fiable a mi siempre me ha resultado muy práctica y, siendo consciente de las necesidades del procesador y la pantalla, te puedes hacer una idea temporal de autonomía de tu portátil.

Para recuperar la indicación en tiempo hay que seguir estos sencillos pasos:

1. Botón derecho sobre el widget e ir a las preferencias.
2. Habilitar «Mostrar información de carga».
3. Quitar el escritorio plasma con el comando «kquitapp plasma-desktop».
4. Abrir el fichero «~/.kde4/share/config/plasma-desktop-appletsr», buscar la línea que ponga «showBatteryString=true» y justo debajo añadir otra línea que sea «showRemainingTime=true».
5. Iniciar el escritorio plasma con el comando «plasma-desktop».

Como comentaba anteriormente la convivencia con Windows puede ser difícil, especialmente cuando después de que éste actualice veas que a desaparecido Grub.

Para recuperarlo sólo habrá que seguir unos sencillos pasos en cuanto arranquemos un livecd de Gnu/Linux. Suponiendo que nuestro raíz o boot está en la partición sda3, estos son los pasos:

mount /dev/sda3 /mnt

mount –bind /dev /mnt/dev

chroot /mnt

mount /proc

mount /sys

grub2-mkconfig -o /boot/grub2/grub.cfg

grub2-install /dev/sda

Y con esto ya habremos regenerado nuestro Grub para desgracia de Windows 😛 .

Es posible que nos veamos ante la situación de tener que hacer convivir alguna versión de Windows con nuestra distro de Gnu/Linux en el mismo disco duro (con las pegas que ello conlleva), algo que es casi obligatorio en portátiles. Para ello tendremos que modificar la configuración de Grub 2 que difiere bastante de la versión anterior.

Suponiendo que estemos en Ubuntu, el primer paso será agregar el siguiente texto al fichero «/etc/grub.d/40_custom»:

menuentry ‘Windows′ {
set root=’(hd0,msdos2)’
chainloader +1
}

Esto suponiendo que nuestro Windows se encuentre en el primer disco (hd0), concretamente la segunda partición (msdos2).

Finalmente tendremos que actualizar los datos con el siguiente comando:

sudo update-grub2

Por cuestiones atípicas de la vida, me encontré ante la situación de tener que extraer ciertas páginas de un PDF. Encontré un tutorial en Internet que daba una buena solución, rápida y efectiva para el trabajo en lotes de ficheros desde un terminal.

Básicamente hay que tener instalado ghostscript y pegar lo siguiente en el fichero .bashrc:

function pdfpextr()
{
# this function uses 3 arguments:
# $1 is the first page of the range to extract
# $2 is the last page of the range to extract
# $3 is the input file
# output file will be named «inputfile_pXX-pYY.pdf»
gs -sDEVICE=pdfwrite -dNOPAUSE -dBATCH -dSAFER \
-dFirstPage=${1} \
-dLastPage=${2} \
-sOutputFile=${3%.pdf}_p${1}-p${2}.pdf \
${3}
}

A partir de ese momento tendremos un nuevo comando en nuestro terminal que funcionará de esta forma «pdfpextr paginaInicio paginaFin pdfacortar.pdf».