DOCUMENTACIÓN PARA LA INSTALACIÓN DE RASPBIAN

José León Barranco

INSTALACIÓN EN LA TARJETA SD

Utilizaremos un SO Ubuntu 14.04 para la instalación de Raspbian en la tarjeta SD.

1. Descargar Raspbian (Debian Wheezy) desde http://www.raspberrypi.org/downloads/

2. Extraer la imagen, por ejemplo desde nautilus, click derecho sobre el archivo y click en
Extract Here.
3. Ejecutar df -h para ver que dispositivos están montados.
4. Insertar la tarjeta SD en el equipo.
5. Ejecutar df -h de nuevo, el dispositivo que no estuviese la vez anterior es la SD.

Ya se conoce el nombre del sistema de archivos para la SD, en nuestro caso: mmcblk0p1.
La última parte (“p1”) es el número de partición, pero se quiere escribir en la tarjeta SD
entera, no solo una partición, por esto es preciso eliminar esa parte del nombre.

Se tendrá en cuenta que la SD puede mostrar más de una partición, de hecho será así si
previamente en dicha tarjeta estuviese grabada una imagen de Raspberry, porque las
imágenes de Raspberry Pi tienen más de una partición.

6. Ahora que hemos anotado el nombre del dispositivo, es necesario desmontarlo para que
esos archivos no puedan ser leídos o escritos de la tarjeta SD mientras se está copiando la
imagen.

Para ello, en el terminal tecleamos: umount /dev/mmcblk0p1

Nota: Si la SD muestra más de una debido a que tiene múltiples particiones en la SD, se
deberían desmontar todas esas particiones, siguiendo el proceso anterior.

Utilizando la herramienta dd procedemos a volcar el contenido de la imagen en la tarjeta

SD. Cabe aclarar que es necesario contar con una tarjeta SD o pendrive de al menos 4Gb de
capacidad.

Nota: este proceso provocará la perdida total de los datos que se encuentran almacenados
dentro de la tarjeta SD. Si no se utiliza adecuadamente, puede provocar la pérdida o
destrucción total o parcial de datos alojados en el sistema.

sudo dd if=2015-02-16-raspbian-wheezy.img of=/dev/mmcblk0 bs=2M

El if=argumento_origen corresponde con la ruta y el nombre de nuestro archivo de

imagen (.img), y el of=argumento_destino corresponde con la ruta y nombre del
dispositivo donde volcaremos la imagen.

El bs=argumento_tamañodebloque lo hemos fijado en 2M, aunque 4M funcionará

la mayor parte de las veces. Tamaños de bloque inferiores al elegido requerirán un tiempo
de volcado considerablemente mayor.

Se tendrá en cuenta que el comando dd no proporciona información acerca del progreso de

la operación y podría parecer que el sistema ha quedado congelado. Pues el proceso podría
llevar más de cinco minutos. Para ver el progreso de la operación de copia se puede correr
pkill -USR1 -n -x dd en otro terminal.

Una vez termina el proceso.

Una vez que finalizada copia, retiramos la tarjeta SD y la insertamos en la Raspberry Pi.

CONFIGURACIÓN DE LA RASPBERRY PI

Para finalizar la instalación encendemos la Raspberry Pi para configurar Raspbian.

Necesitamos un teclado y un monitor o televisor con entrada HDMI.

Conectamos la Raspberry al monitor utilizando un cable HDMI, luego encendemos el

monitor o televisor. Para encender la Raspberry debemos conectar la alimentación en el

puerto Micro USB.

Tras el proceso de inicio del sistema se abre la herramienta raspi-config

responsable de la configuración de Raspbian.

1. Expansión del sistema de archivos. La imagen está preparada para utilizar cualquier
dispositivo de al menos 4 GB. El primer paso es expandir el filesystem para que ocupe toda
la capacidad de la tarjeta SD.

Tras seleccionar Expand Filesystem el proceso de expansión se realizará en el siguiente

reinicio.

2. Cambio de contraseña. Desde el menú inicial de la herramienta raspi-config

seleccionamos Change User Password para establecer la nueva contraseña del usuario
"pi". Introducimos una contraseña y se nos pedirá repetirla para confirmar.

3. Escritorio. Es posible habilitar el inicio automático al escritorio LXDE desde el menú

Enable Boot to Desktop. En mi caso no lo haré, selecciono “Console Text console”.
Siempre que se quiera acceder al modo gráfico desde consola es posible hacerlo con el
comando startx.

4. Opciones de internacionalización (Internationalisation options). Configuraramos el

lenguaje, zona horaria y teclado.

- Se selecciona Change Locale para instalar los conjuntos de caracteres necesarios:

“es_ES.UTF-8” y luego el conjunto de caracteres por defecto: “es_ES.UTF-8”.

- Se selecciona Change Time Zone para configurar la zona horaria. Zona

Geográfica: “Europe”. Time Zone: “Madrid”.

- Se selecciona Change Keyboard Layout para configurar el teclado. Utilizamos el

modelo de teclado genérico “Generic 105-Key PC”. Para el teclado en español se selecciona
la disposición (layout): “Other”. A continuación, se selecciona país de origen: “Spanish”, y
luego, la disposición de teclas: “Spanish”.

- Selección de la tecla para funcionar como Alt Gr: “Default”.

- Selección de la tecla para funcionar como Compose: “No Compose Keyboard”.

- Habilitar la configuración de teclas Ctrl+Alt+Backspace para el Servidor X: “Yes”

5. Si se dispone de cámara es posible habilitar el soporte desde el menú Enable Camera.

6. Habilitar el servidor SSH. Seleccionamos Advanced Options y A4. SSH. El sistema pide
confirmación “Would you like the SSH server enabled or disabled?” Seleccionamos
“Enabled”.

7. Reinicio. Tras finalizar la configuración se reinicia el sistema, lo cual se hace

automaticamente al presionar el botón Finish con la barra espaciadora o la tecla Enter.

8. Configuración de la red cableada (Ethernet). Se edita el archivo “interfaces” en la carpeta

/etc/network.
sudo nano /etc/network/interfaces
Para establecer una dirección IP fija (deseable si vamos a utilizar la Raspberry como servidor), se
modifica la línea:

iface eth0 inet dhcp

Es suficiente con sustituir “dhcp” por “static”.

A continuación se añaden las siguientes líneas para terminar de configurar la interfaz de red:
[tabulacion] address 192.168.1.200
[tabulacion] netmask 255.255.255.0
[tabulacion] gateway 192.168.1.1

Esto fija la dirección IP que deseamos asignar a la Raspberry, la máscara de red y el gateway

(dirección IP del enrutador o módem por cable). netstat -r | grep default

Para terminar se guarda el archivo y se vuelve al terminal. Para utilizar los nuevos ajustes es preciso
iniciar el servicio de red (networking):
sudo /etc/init.d/networking restart
A continuación, se especifica a Raspeberry Pi los servidores DNS a utilizar. La lista de servidores
DNS se almacena en /etc/resolv.conf. Generalmente será la dirección del enrutador tal y como
aparece en la línea gateway del archivo interfaces. Editamos por tanto el archivo
sudo nano /etc/resolv.conf
Se añade cada servidor en un línea aparte, precedido de nameserver y un espacio. Por ejemplo, para
una red que utiliza servidores DNS públicos de Google para resolver los nombres de dominio:
nameserver 8.8.8.8
nameserver 8.8.4.4
Guardar el archivo, volver al terminal y reiniciar la interfaz de red.
Para comprobar el correcto funcionamiento se puede utilizar el comando ping.
ping -c 1 www.raspberrypi.org

INSTALAR LAMP

Se instalarán los siguientes componentes: Apache, MySQL y PHP. En el terminal:

sudo apt-get update

sudo apt-get install apache2 php5 php5-mysql mysql-server

Estas instrucciones solicitan al administrador de paquetes apt que busque los componentes
necesarios para obtener una infraestructura LAMP.

En el proceso se requerirá una contraseña para la base de datos MySQL. Al terminar la

instalación, los servidores MySQL y Apache se ejecutan en segundo plano.

Intentamos acceder a la Raspberry Pi desde otro equipo de red, mediante un navegador web
y la IP.

Para finalizar comprobamos el módulo PHP creando un archivo con código PHP para servir
una página de información.

sudo sh -c 'echo “<?php phpinfo(); ?>” > /var/www/phptest.php'

Visitar el archivo creado utilizando un navegador. La dirección de acceso desde otro equipo
será http://ip_raspberry/phptest.php

En este caso ip_raspberry será: 192.168.1.200

INSTALAR SERVIDOR PARA ESCRITORIO REMOTO VNC

Instalamos el VNC server con: sudo apt-get install tightvncserver

Ejecutar la aplicación: tightvncserver
Nos pedirá una contraseña para poder acceder desde nuestro ordenador a la Raspberry Pi. A
continuación se pregunta si queremos una contraseña para solo observar.
Ya tenemos el servidor VNC configurado y preparado para conectarnos.
En preciso reiniciar el sistema reboot
Tras el reinicio, se ejecuta el servidor VNC: vncserver :1
Y ahora ya nos podremos conectar desde otro equipo a través del puerto 5901. En mi caso,
utilizaré Ubuntu y el software SSL/SSH VNC Viewer. Se nos requerirá la contraseña
introducida en el paso de instalación de tightvncserver.

El siguiente paso será editar un script para el inicio automático del servidor VNC con el
arranque de la Raspberry. Para ello se crea un fichero tightvncserver en /etc/init.d/, es
preciso ser superusuario.

sudo nano /etc/init.d/tightvncserver

Y añadimos el siguiente código:

#! /bin/sh
# /etc/init.d/tightvncserver
#

# Carry out specific functions when asked to by the system

case "$1" in
start)
su pi -c '/usr/bin/vncserver'
echo "Starting VNC server "
;;
stop)
pkill vncserver
echo "VNC Server has been stopped (didn't double check
though)"
;;
*)
echo "Usage: /etc/init.d/blah {start|stop}"
exit 1
;;
esac

exit 0

Marcamos el script como ejecutable

sudo chmod +x tightvncserver

A continuación, eliminamos la instancia previa que comenzamos

con la configuración inicial

sudo pkill Xtightvnc

Comprobamos que el servidor VCN no está en funcionamiento:

ps aux | grep vnc

Ahora arrancamos vncserver mediante el script de inicio.

sudo /etc/init.d/tightvncserver start

Para estar seguro de que el script funcionará con reinicios e

inicios:

sudo update-rc.d tightvncserver defaults

CONFIGURAR RED WIFI

Incluir archivo interfaces y archivo wpa_config y archivo resolv.conf

INSTALACION DE LA LIBRERIA GPIO DE PYTHON

Llevaremos a cabo este proceso mediante un terminal.

Escribir sudo wget http://pypi.python.org/packages/source/R/Rpi.GPIO/Rpi.GPIO-0.5.11.tar.gz
para descargar la libreria en el directorio home.

A continuacion se extrae el contenido del archivo.

sudo tar zxf Rpi.GPIO-0.5.11.tar.gz

Para instalar la libreria en Python teclear

sudo python setup.py install

Si llevamos a cabo la instalacion sin haber instalado previamente el paquete python-dev, se

obtendra como resultado un error.

compilation terminated.
error: command 'gcc' failed with exit status 1

Probar con sudo apt-get update && sudo apt-get install python-dev
Where can I find Python.h file and how do I fix this problem under Debian or Ubuntu Linux sever
based system?

Python.h is nothing but a header file. It is used by gcc to build applications. You need to install a
package called python-dev. This package includes header files, a static library and development
tools for building Python modules, extending the Python interpreter or embedding Python in
applications. To install this package, enter:

sudo apt-get install python-dev

Una vez instalado el paquete python-dev, estamos preparados para instalar la libreria Rpi.GPIO

sudo python setup.py install

El siguiente paso logico seria comprobar que la libreria funciona correctamente. Para esto,
probaremos con un pequeño circuito electronico compuesto por un LED, una resistencia y un
transistor bipolar BC547B. Se utilizara una placa de prototipado sin soldadura para facilitar las
conexiones de los distintos elementos.

Aunque es posible conectar el LED directamente a uno de los pines de salida programables y
activar este pin para iluminar al LED, es bueno acostumbrarse a introducir medidas de proteccion.
Pues en futuros proyectos se controlaran elementos que requieren mucha mas corriente, por ejemplo
un motor.

Los pines de Raspberry solo pueden proporcionar alrededor de 16 mA de corriente y si alimentamos

algo que requiera mas corriente podria dañar irreversiblemente la placa. Al utilizar un transistor
podemos hacer circular una elevada corriente entre Colector y Emisor a la vez que podemos
interrumpir esta circulacion con una pequeña cantidad de corriente proporcionada por los pines de
la Raspberry.

El esquema de conexiones del circuito sera el siguiente:

- El pin de 3V conectado al Colector del transistor

- El pin GPIO 17 a la Base del transistor
- El emisor del transistor al anodo del LED
- El catodo del LED a la resistencia
- La resistencia a tierra

Editamos un script en python para hacer que el LED parpadee hasta 5 veces

sudo nano parpadeo.py

#!usr/bin/env/ python
#parpadea.py
#importamos la libreria GPIO
import RPi.GPIO as GPIO
#Importamos la libreria time
import time
#Definimos el modo BCM
GPIO.setmode(GPIO.BOARD)
#Ahora definimos el pin GPIO 17 como salida
GPIO.setup(11, GPIO.OUT)
#Queremos que lo que contenga el for i in range se repita 5 veces
for i in range(0,5):
#Asignamos valor logico alto para encenderlo
GPIO.output(11, True)
#Esperamos un segundo
time.sleep(2)
#Asignamos valor logico bajo para apagarlo
GPIO.output(11, False)
#Esperamos un segundo
time.sleep(2)
#liberamos el pin GPIO utilizado; en este caso el 17
GPIO.cleanup()

Con esta experiencia ha quedado probado el funcionamiento de la libreria Rpi.GPIO, del interprete
de Python y del pin utilizado.

INSTALACION DE TORNADO
Instalaremos una implementacion de servidor web con soporte para el protocolo Websocket.
Tornado es un servidor web asincrono para Python, que es capaz de manejar simultaneamente mas
de diez mil conexiones. Para instalar Tornado se recomienda usar un administrador de paquetes
como pip. Para ello, lo primero es instalar pip (en nuestro caso la version para Python 2):
sudo apt-get install python-pip

A continuacion instalamos Tornado mediante el administrador de paquetes pip:

sudo pip install tornado

Para comprobar que la instalacion de Tornado fue correcta se escribira un servidor web Tornado
muy simple.

sudo nano servidor.py

añadimos el siguiente codigo:

import tornado.httpserver
import tornado.websocket
import tornado.ioloop
import tornado.web

class WSHandler(tornado.websocket.WebSocketHandler):
def check_origin(self, origin):
return True

def open(self):
print 'user is connected.\n'

def on_message(self, message):

print 'received message: %s\n' %message
self.write_message(message + ' OK')

def on_close(self):
print 'connection closed\n'

application = tornado.web.Application([(r'/ws', WSHandler),])

if __name__ == "__main__":
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8888)
 tornado.ioloop.IOLoop.instance().start()

Escribiremos ahora una aplicacion cliente:

<!doctype html>
<html>
<head>
<title>Websocket</title>
<script src="jquery-2.1.3.js"></script>
</head>
<body>
<h1>Websocket</h1>
<label id="conn_text"></label><br />
<input type="text" id="input_text"/>
<input type="submit" id="button" value="Send" /><br />
<div id="messages_txt" />
<script>
$(document).ready(function () {
//change example.com with your IP or your host
var ws = new WebSocket("ws://example.com:8888/ws");
ws.onopen = function(evt) {
var conn_status = document.getElementById('conn_text');
conn_status.innerHTML = "Connection status: Connected!"
};
ws.onmessage = function(evt) {
var newMessage = document.createElement('p');
newMessage.textContent = "Server: " + evt.data;
document.getElementById('messages_txt').appendChild(newMessage);
};
ws.onclose = function(evt) {
alert ("Connection closed");
};
$("#button").click(function(evt) {
evt.preventDefault();
var message = $("#input_text").val();
ws.send(message);
var newMessage = document.createElement('p');
newMessage.textContent = "Client: " + message;
document.getElementById('messages_txt').appendChild(newMessage);
});
});
</script>
</body></html>

Una vez guardado el fichero, procedemos a abrirlo en nuestro navegador

preferido. Pero antes es preciso ejecutar “de fondo (demonio)” en la Raspberry
el servidor servidor.py

python servidor.py &

Una vez que el servidor esta corriendo en la Raspberry Pi, escribimos un mensaje
en el navegador y si todo esta correcto el servidor nos devolvera el mismo
mensaje a forma de eco.
INSTALACION DE NODE.JS

Para instalar Node.js, lo primero que se hara es actualizar el sistema de la Raspberry Pi.

sudo apt-get update -y && sudo apt-get upgrade -y

A continuacion descargaremos la ultima version de Node-ARM

sudo wget http://node-arm.herokuapp.com/node_latest_armhf.deb

Y procederemos con la instalacion propiamente dicha.

sudo dpkg -i node_latest_armhf.deb

Si el proceso a transcurrido correctamente, podemos teclear

node -v

y veremos la version de Node.

Pongamos a prueba Node.js programando un simple servidor web

sudo nano saludos.js

en este fichero alojamos el siguiente codigo:

var http = require('http');
http.createServer(function (request,response) {
response.writeHead(200, {'Content-Type': 'text/plain'});
response.end('Hello World!\n');
}).listen(8000)
console.log("Web Server running at http://127.0.0.1:8000")

una vez editado y guardado el fichero. Ejecutamos el servidor tecleando lo siguiente:

node saludos.js

El funcionamiento es muy sencillo, desde el navegador web de cualquier dispositivo accedemos a la

Raspberry en el puerto 8000. Mostrandonos el mensaje “Hello World!”.

APENDICE I: Node.js y regulacion del brillo de un LED por PWM simulado por
software
Para este experimento partimos de un circuito configurado como en el apartado “INSTALACION
DE LA LIBRERIA GPIO DE PYTHON”. Es decir, con un LED, una resistencia y un transistor;
dispuestos como en ese apartado.

A continuacion se instalan dos aplicaciones en la Raspberry. En este apartado vamos a precisar de

una cuenta en Github y una llave SSH. Esta llave sera añadida a la cuenta de Github.

Primero vamos a instalar Git y XClip, para eso abrimos la consola y tecleamos:
sudo apt-get install git

En nuestro caso nos informa de que ya esta instalado en su version mas reciente. Para comprobar la
version

git --version

y nos devuelve: git version 1.7.10.4

Para instalar XClip:

sudo apt-get install xclip

A continuacion configuramos nuestros datos:

git config --global user.name "joseleo"

git config --global user.email "micorreo@gmail.com"

El siguiente paso a seguir es la obtención de la clave ssh, pues Github usa una clave ssh para
establecer conexión entre nuestro ordenador y el servidor de Git. Podremos generar la clave .ssh
con el siguiente comando:

ssh-keygen
Debemos configurar el lugar donde se guardará y nos da opcion de introducir una contraseña -
passphrase- aunque esto es opcional. Se debe dejar en blanco si no se desea tener que teclearla cada
vez que se use la clave.

Para leer la clave ssh tendremos que teclear en la ruta adecuada:

cat .ssh/id_rsa.pub

Copiamos el contenido y lo pegaremos en SSH Keys en nuestra cuenta de Github (menu Settings).
Una vez añadida la llave tecleamos:

ssh -T git@github.com

Se recibira un mensaje personalizado que debe incluir “You've successfully authenticated”.

Una vez hecho esto, el primer codigo que se instalara es quick2wire GPIO Admin. Permite usar los
pines GPIO mediante nuestra aplicación NodeJS si tener que ejecutar la aplicación con privilegios
de superusuario.

Los pasos para instalar GPIO Admin, dentro de la conexión SSH con Github, son los siguientes:
mkdir tools && cd tools
git clone git@github.com:quick2wire/quick2wire-gpio-admin.git
cd quick2wire-gpio-admin
make
sudo make install
sudo adduser pi gpio

Con esto, se crea un directorio tools, hacemos pull al codigo fuente de GPIO Admin desde Github,
compilamos e instalamos el software. Ademas añadimos el usuario pi al grupo gpio, que tiene
permisos para acceder a los pines GPIO.

A continuacion, interrumpimos la sesion SSH y conectamos de nuevo para estar seguros de que se
han aplicado correctamente los permisos.

Probamos a encender el LED tecleando los siguientes comandos:

gpio-admin export 17
echo "out" > /sys/class/gpio/gpio17/direction
echo 1 > /sys/class/gpio/gpio17/value
Para apagar el LED:
echo 0 > /sys/class/gpio/gpio17/value

Algunos de los paquetes NodeJS que se usaran a continuacion tendran modulos addons nativos que
para ser capaces de compilarlos necesitaremos instalar la herramienta node-gyp.
sudo npm install -g node-gyp

A continuacion, instalaremos el paquete onoff. Este nos permite fijar los pines GPIO como activos
(on) o apagados (off) desde codigo en NodeJS.
Para esto, en el mismo directorio, tecleamos:
sudo npm install onoff -save

Lo siguiente que necesitamos es añadir el directorio node_modules al fichero .gitignore, esto

permite compilar en la Raspberry algunos de los modulos nativos para que sean compatibles.
Simplemente editaremos el archivo .gitignore en el directorio raiz del proyecto (de no existir se
creara) añadiendo la siguiente linea:
node_modules/

Pasamos finalmente a editar el fichero LED.js que contendra nuestro codigo NodeJS

var http = require('http');

var url = require('url');
var Gpio = require('onoff').Gpio;

var led = new Gpio(17, 'out');

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});

var command = url.parse(req.url).pathname.slice(1);
switch(command) {
case "on":
led.writeSync(1);
res.end("It's ON");
break;
case "off":
led.writeSync(0);
res.end("It's OFF");
break;
default:
res.end('Hello? yes, this is pi!');
}
}).listen(1337);

Este creara nuestro servidor HTTP a la escucha del puerto 1337 y determina una funcion callback
que sera llamada cuando el servidor reciba una peticion. Esta funcion escribe el codigo de estado
200 (OK) a la respuesta y establece la cabecera Content-Type en text/html informando al cliente
conectado que espera una respuesta HTML.

Utiliza el modulo URL de NodeJS para dividir en sus componentes la url solicitada, tomaremos el
fragmento que esta despues del host y el puerto. Veamos un ejemplo:
La peticion: http://192.168.1.200:1337/on tras el particionado quedara como variable command
"on", si por el contrario la peticion es: http://192.168.1.200:1337/off la variable command sera
"off".
A continacion se utiliza una estructura de control switch, para ejecutar la orden de apagado o
encendido del LED.
Para continuar programaremos un ejemplo en el que se permita utilizar PWM (simulado por
software) para establecer el brillo del LED. Para esto utilizaremos la herramenta pi-blaster, que
permitira utilizar de forma facil PWM en la Raspberry. Para instalarla abriremos una conexion SSH
con la Raspberry y tecleamos:
sudo apt-get install autoconf
cd ~/tools
git clone git@github.com:sarfata/pi-blaster.git
cd pi-blaster
./autogen.sh
./configure
make
sudo make install
npm install pi-blaster.js --save

Editamos nuestro fichero LEDPWM.js en consecuencia para utilizar la nueva herramienta.

sudo nano LEDPWM.js

Tecleamos el siguiente codigo:

var http = require('http');

var url = require('url');
var piblaster = require('pi-blaster.js');

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});
var brightness = url.parse(req.url).pathname.slice(1);

if (brightness.length === 0 || isNaN(brightness)) {

res.end('Hola?? esto es una pi');
} else {
piblaster.setPwm(17, brightness / 100);
res.end('Brillo en el: ' + brightness + '%');
}
}).listen(1337);

El funcionamiento es parecido al caso anterior, con la diferencia de que a continuacion del host y
del puerto añadiremos la variable de intensidad del brillo del LED en tanto por ciento. Por ejemplo:
http://192.168.1.200:1337/50
En el caso anterior se establecera el brillo del LED en el 50 por ciento.
NOTA IMPORTANTE: Es preciso copiar el contenido de: /home/pi/tools/node_modules/pi-
blaster.js/ en la ruta: /node_modules/pi-blaster.js/
APENDICE II: CONTROL DE 3 LEDs DE DIFERENTES COLORES CON
SERVIDOR TORNADO
Empezaremos editando un fichero servidor.py, que alojara el codigo necesario para hacer funcionar
un servidor web a la escucha del puerto 8888.

Es un codigo de prueba que pretende controlar de forma simultanea, mediante un cliente

programado en Javascript, el encendido o apagado de 3 LEDs de diferente color.

#!/usr/bin/python
#-*-coding:utf-8-*-

### Aplicacion Servidor Web Tornado ###

# Importar los módulos necesarios #

import tornado.httpserver
import tornado.websocket
import tornado.ioloop
import tornado.web
import RPi.GPIO as GPIO
import time

# Clase Manejador de Websocket #

class WSManejador(tornado.websocket.WebSocketHandler):

# manejador de evento open, para establecimiento de conexion

def check_origin(self, origin):
return True

def open(self):
print '\nusuario está conectado.\n'
self.write_message("Bienvenido")

# manejador de evento on_mensaje, para mensajes de entrada

def on_message(self, message):
print 'recibido mensaje: %s\n' %message
self.write_message(u"Tu dices: " + message)
a = message.split(",", 2)

b = int(a[0])
if b <= 128:
R=0
else:
R=1

c = int(a[1])
if c <= 128:
G=0
else:
G=1
 d = int(a[2])
if d <= 128:
B=0
else:
B=1

GPIO.setmode(GPIO.BOARD)
GPIO.setup(11, GPIO.OUT)
GPIO.setup(12, GPIO.OUT)
GPIO.setup(13, GPIO.OUT)

if R == 0:
GPIO.output(11, GPIO.LOW)
else:
GPIO.output(11, GPIO.HIGH)

if G == 0:
GPIO.output(12, GPIO.LOW)
else:
GPIO.output(12, GPIO.HIGH)

if B == 0:
GPIO.output(13, GPIO.LOW)
else:
GPIO.output(13, GPIO.HIGH)

# disparado por el evento cierre de conexión

def on_close(self):
print "\nconexión cerrada\n"

# Inicializar la aplicacion Tornado #

# asocia el manejador de evento apropiado, WSManejador con la URI
application = tornado.web.Application([(r'/ws', WSManejador),])

# Programa principal #
if __name__ == "__main__":
# configuracion del servidor
http_server = tornado.httpserver.HTTPServer(application)
# definicion del puerto
http_server.listen(8888)
# inicializacion del servicio
tornado.ioloop.IOLoop.instance().start()

El codigo HTML5:
El codigo de Javascript:

Bibliografia consultada

Raspberry Pi. Guia de usuario

Guia de bolsillo Linux

Enlaces de referencia
http://portallinux.es/rpi-escritorio-remoto-vnc/
http://www.raspberrypi.org/forums/viewtopic.php?t=7395
http://iot-projects.com/index.php?id=websocket-a-simple-example
http://www.raspberrypi.org/documentation/linux/software/python.md
http://thejackalofjavascript.com/getting-started-raspberry-pi-node-js/
http://blog.fxndev.com/raspberry-pi-and-led-fun/
Direcciones de sockets