Documentos de Académico
Documentos de Profesional
Documentos de Cultura
RaspberryPi Tutorial PDF
RaspberryPi Tutorial PDF
PRIMEROS PASOS
CON RASPBERRY PI
A lo largo de este tutorial aprenderemos a desenvolvernos con las placas Raspberry Pi.
Comenzaremos con una breve descripción de estas placas y de las características de los
diferentes tipos que podemos encontrar en el mercado. El siguiente paso será el de configurar
la placa, desde la descarga del sistema operativo hasta el manejo de sus entradas y salidas.
Finalmente realizaremos el ejercicio de conectar diferentes sensores a la placa y ver en el
ordenador los valores que éstos arrojan.
¡Comenzamos!
En esencia, Raspberry Pi (RP) es un ordenador de bajo costo integrado en una placa del tamaño
de una tarjeta de crédito. Más formalmente, podemos definirla como una plataforma abierta
que permite diferentes sistemas operativos (SO) y distribuciones ligeras para desarrollo. Las
distribuciones más comunes son Linux, y la más utilizada Raspbian.
- Raspberry Pi 1 A+: es la placa Raspberry más barata (Figura 1), y en 2014 reemplazó al
antiguo modelo A. Sus características más interesantes son:
o 256MB de memoria RAM
o 1 puerto USB
o No tiene puerto Ethernet
o GPIO con 40 pines (el esquema de pines se mantiene igual en
los 26 pines del modelo A antiguo)
o Micro SD (antes era SD)
o CPU Broadcom BCM2835 @ 700MHz
o GPU: Co-procesador multimedia Dual Core VideoCore IV
o Salida de audio y vídeo compuesto de 4 polos
o Salida de vídeo y audio por HDMI
o Puerto CSi para un módulo de cámara
o Puerto DSI para pantallas TFT táctiles Figura 1. Raspberry Pi 1 A+
o Consumo bajo
- Raspberry Pi 1 B+: Este modelo (Figura 2) reemplazó al anterior modelo B en Julio de 2014
y fue mejorada por la RP 2 B+ en Febrero de 2015.
o 542MB de memoria RAM
o Puerto Ethernet 100Mb
o GPIO con 40 pines (el esquema de pines se mantiene igual
en los 26 pines del modelo B antiguo)
o 4 puertos USB (el modelo B anterior tenía sólo 2 puertos
USB)
o Full HDMI port
o Combined 3.5mm audio jack and composite video
o Camera interface (CSI)
Figura 2. Raspberry Pi 1 B+
o VideoCore IV 3D graphics core
o Micro SD (antes era SD)
o Menos consumo que su predecesor
- Raspberry Pi 2 B: segunda generación de RP, recién llegada en Feb 2015. Mismas
características que el modelo B+ pero con la añadidura:
o 900MHz quad-core ARM Cortex-A7 CPU
o 1GB RAM
- Configuración de la Raspberry Pi
El primer paso que tenemos que llevar a cabo es descargar el sistema operativo que
queramos que opere nuestra RP. En nuestro caso usaremos la distribución Raspbian [2],
ya que si estamos acostumbrados a Ubuntu no encontraremos mucha diferencia. En [2]
podréis encontrar todas las distribuciones. Una vez nos hayamos descargado la imagen
(archivo .img), el siguiente paso será el de montar (grabar) el SO en la tarjeta SD. Para
ello necesitaremos un programa que realice esta función, en nuestro caso utilizaremos
el “win32DiskImager” que os podréis descargar en este enlace [3]. Para montar la
imagen abrimos el programa (Figura 3) y seleccionamos la imagen del SO que nos hemos
descargado. Introducimos en el ordenador la tarjeta SD y seleccionamos en el programa
dónde queremos que nos lo copie. En este paso deberéis ser muy cuidadosos ya que si
escogéis otra unidad de escritura (por ejemplo vuestro disco duro) os borrará todo. Por
último le damos a write y una vez finalizado el proceso ya tendremos el SO en nuestra
tarjeta SD.
Figura 3. Captura Win32 Disk Imager
Para conectarnos con nuestra placa de forma remota primero tendremos que
conectarla a la red y asignarle una dirección IP para saber a quién dirigirnos y poder
enviar/recibir información hacia/desde ella.
Por defecto, una vez conectada a la red, nuestra RP tomará una dirección IP distinta
cada vez que la desconectemos y la volvamos a conectar. Esto puede ser incómodo ya
que tendremos que averiguar qué dirección ha tomado cada vez que queramos trabajar
con ella. Por ello, en el siguiente paso os explicaremos cómo asignarle una dirección IP
fija, que mantendrá aunque la desconectemos en algún momento.
El primer paso será el de conectar el cable de red desde nuestro router a la placa. Para
saber inicialmente cuál es la dirección que el router ha asignado a la RP tendremos que
verlo en el panel de control de nuestro router (este paso dependerá de la marca/modelo
del router que tengáis). Si no estáis familiarizados con él, buscando el modelo del router
en cualquier buscador de Internet seguro que encontráis información.
Para conectarnos con la placa lo haremos mediante SSH [4]. Si estamos trabajando con
una máquina LINUX lo haremos a través de la consola. Si en nuestro caso estamos
trabajando con Windows, necesitaremos algún programa que nos permita realizar
conexiones SSH. Existen diferentes programas para Windows que realizan esta función
(XShell, Virtual Box, PuTTY, etc.), en nuestro caso utilizaremos XShell [20].
La primera vez que nos conectemos nos aparecerá un mensaje que nos habla de las
claves publica/privada, podemos contestar “yes”. A continuación nos pedirá la
contraseña que por defecto es raspberry. La contraseña la podremos cambiar (y es
recomendable) durante la configuración de la RP. Si por seguridad quisierais cambiar las
claves pública/privadas SSH para no tener las mismas que todo el mundo, podéis seguir
las instrucciones en este link [5].
El siguiente mensaje nos informará de que la placa no está configurada, así que ese será
el siguiente paso a realizar.
El mensaje que nos aparecerá será una ventana como esta (Figura 4):
Con las flechas del teclado nos iremos moviendo por el menú y configurando los puntos
que sean necesarios:
Expand Filesystem: esta opción nos permitirá indicar que queremos utilizar toda
la capacidad de la SD, ya que por defecto al grabar la imagen la capacidad queda
limitada a 2GB.
Change User Password: por defecto el usuario y el password son “pi” y
“raspberry” respectivamente. Esta opción nos permitirá cambiar el password y
fijar el que nosotros queramos.
Enable Boot to Desktop/Scratch: esta opción permite a la RP iniciarse en modo
gráfico cuando se inicia. Sin embargo, quizás no sea lo más conveniente, ya que
este paso lo podremos hacer en cualquier momento y no trabajaremos mucho
con el entorno gráfico.
Internationalisation Options: a través de esta opción podremos escoger el
idioma, la zona horaria y el layout del teclado (si quiere utilizarse).
Enable Camera: permitirá utilizar la Pi Camera
Add to Rastrack: esta opción permite añadir nuestra Raspberry Pi a la web
creada por Ryan Walmsley [6]. En esta web se puede ver dónde están las RP que
está usando la gente alrededor del mundo. Si nuestra RP está conectada a
Internet podríamos seleccionar esta opción y ver aparecer nuestra RP (sólo un
logo) en el mapa de la web.
Overclock: configura el “overclocking” de nuestra RP, esto es, aumentar la
frecuencia del procesador. Por defecto está configurada a 700MHz pero puede
ponerse hasta 1000MHz. No es recomendable modificar esta opción ya que
puede llevar a inestabilidades o incluso a freír el procesador, por lo tanto, si no
sabes muy bien lo que estás haciendo será mejor que no toques nada de esta
opción.
Advanced Options: en este apartado se pueden modificar diferentes
parámetros relativos a nuestra RP, en este link podrás ver una descripción de
los mismos [7] (inglés). No entraremos en mayor detalle ya que no
necesitaremos modificar nada en estos apartados por el momento.
De todas las opciones que hemos mostrado anteriormente, sólo vamos a modificar tres de
ellas: “Expland FileSystem”, “User Password” (en el caso de que queramos cambiar la
contraseña), y las opciones de “Internationalisation Options”.
Una vez hemos terminado de configurar nuestra RP, pinchamos en Finish. En ese momento
la RP se reiniciará y ya tendremos nuestra placa configurada.
Como explicamos anteriormente, puede ser interesante que nuestra RP tenga una IP fija
(estática). Tendremos dos formas de asignarle la IP fija: la primera es utilizando las funciones
que nos ofrezca nuestro router (dependerá de la marca/modelo, podréis buscarlo por
Internet), y la segunda modificando un archivo en la RP. Este segundo paso será el que
explicaremos a continuación.
El archivo que tendremos que modificar para asignar la dirección estática es “intefaces”, que
se encuentra dentro de la carpeta /etc/network. Para modificarlo necesitaremos
información previa: la dirección de máscara de red (netmask), la del Gateway (que será la
de nuestro router), y la nueva dirección fija que queramos asignarle. Para obtener esta
información tecleamos lo siguiente:
ifconfig
Este comando nos devolverá la máscara de red (será algo así como 255.255.255.0). La
dirección que queramos poner a nuestra RP compartirá las tres primeras partes de la
dirección del router (192.168.X) y para la última parte asignaremos un número (de 0 a 255)
que no tenga asignado ningún dispositivo más en el router. Si no estamos seguros de las
direcciones que están ya asignadas podemos asignar como fija la dirección IP que nos ha
dado el router, de esta forma estaremos seguros que ningún otro dispositivo tiene esa IP.
sudo nano interfaces (abrimos el fichero con el editor “nano”, también podréis
usar el editor al que estéis acostumbrados)
Buscamos la línea donde pone: iface eth0 inet manual y la cambiamos por las
siguientes:
Para finalizar, guardamos el archivo tecleando Ctrl+X, nos preguntará si queremos guardar
los cambios, le diremos que “yes”.
En Raspberry Pi 2, a diferencia de las anteriores versiones, hay que modificar otros ficheros
ya que aunque se le asigne la ip fija sigue pidiendo una ip por DHCP, y se llega al caso de que
la RP tenga dos IPs. Si es tu caso, puedes encontrar más información en estos links [22] y
[23].
Aunque no nos será necesario acceder al escritorio gráfico para trabajar con nuestra RP, a
continuación os explicaremos cuáles son los pasos para poder hacerlo.
Como estamos conectados por ssh a nuestra RP no podemos lanzar el entorno gráfico con
el comando “startx” que funciona en otras ocasiones. Por ello, lo haremos a través del
programa VNC Server/Client. Para ello, estando conectados a nuestra RP tecleamos los
siguientes comandos:
El número “1” del último comando se refiere al display (que tendrá que ser el mismo que el
del cliente de los siguientes pasos).
En este momento, si no hemos obtenido ningún error, VNC server estará corriendo en
nuestra RP.
- Linux:
xtightvncviewer (añadiremos & si queremos que trabaje en background, además nos pedirá una
contraseña, la misma que pusimos en el servidor de la RP)
Se abrirá una pequeña ventana del VNC Viewer y escribiremos RPI_IP:1 (tendréis que poner
la IP de la RP en la parte marcada en negrita, el número 1 indica que el display será el 1)
- Windows:
En este caso accederemos al link [8] y nos descargaremos la versión que corresponda a
nuestra versión de Windows. Nos instalamos el programa y accedemos a su ventana
principal (Figura 7). Ahí introduciremos la dirección IP de nuestra RP seguida de “:” y el
display que hayamos puesto en el server.
Figura 7. Captura TightVNC
Para cerrar la sesión, cerramos la ventana del entorno gráfico en el cliente, y para el servidor
tecleamos lo siguiente:
Una vez tenemos configurada nuestra placa llega el momento de ponernos manos a la obra y
empezar a trabajar con ella. Sin embargo, antes de comenzar deberemos conocer algunos
conceptos básicos como son el lenguaje en el que programaremos o la GPIO.
o ¿Qué lenguaje usaremos para escribir nuestros programas en la RP?
Aunque se pueden utilizar distintos lenguajes para programar (C, Javascript, PHP, etc.) en este
caso utilizaremos Python ya que tiene excelentes librerías que nos harán las cosas más fáciles.
Además, cuenta la leyenda que el apellido de nuestra Raspberry (Pi) viene de Python, aunque
no sabemos en qué momento la “y”griega se convirtío en “i” latina… En Internet podréis
encontrar multitud de tutoriales en python, como por ejemplo [9] [10].
o ¿Qué es la GPIO?
Muy sencillo, es la interfaz con dispositivos externos. Gracias a ella podremos conectar sensores,
pequeñas pantallas LCD, u otros gadgets. Las siglas GPIO se corresponden a “General Purpose
Input Output” y es la forma que nos ofrece la RP para controlar sus puertos.
En primer lugar, nos aseguraremos de que nuestra GPIO está actualizada. Para ello, nos
conectaremos por ssh (como hicimos en ocasiones anteriores) y teclearemos el siguiente
comando:
Con este comando se nos actualizarán todos los paquetes. Esto lo podremos hacer de tarde en
tarde, por si hay alguna actualización. Eso sí, hay que tener en cuenta que si hace mucho que no
lo hemos actualizado puede tardar un rato. Más info en [15]
Figura 9. Esquema de pines Raspberry Pi 2 model B Figura 10. Interfaces Rasbperry Pi 2 model B
A continuación explicaremos los diferentes tipos de pines/puertos que presenta nuestra placa,
para ello seguiremos el código de colores de la Figura 9:
- Puertos rojos: ofrecen 3V ó 5V según corresponda.
- Puertos negros: tierra.
- Puertos amarillos: son puertos que pueden funcionar como entradas o salidas. El resto
(salvo rojos y negros) podrían funcionar también como entrada y salida, pero si no es
necesario (si tenemos suficiente con los amarillos) es mejor utilizarlos para sus funciones
especiales que detallamos a continuación.
- Puertos naranjas: Serial Peripherical Interface
- Puertos verde claro: interfaz i2c
- Puertos azul claro: UART (puerto serie)
Antes de aprender a trabajar con las entradas y salidas de nuestra placa, debemos saber que
hay dos formas de denominarlas: BOARD y BCM. No importará cual utilicemos mientras en un
mismo programa utilicemos siempre la misma. En la Figura 9 se muestra en las columnas
interiores (en blanco) los números de los pines que se utilizarán en el modo BOARD. En las
columnas laterales (y en colores) se muestra la numeración de puertos GPIO, que se utilizarán
en el modo BCM. En nuestros programas deberemos indicar qué tipo de nomenclatura vamos a
utilizar, para ello utilizaremos el comando GPIO.setmode(modo)
# Modo BOARD -> número de los pines
GPIO.setmode(GPIO.BOARD)
Antes de leer un puerto debemos establecerlo como entrada, para ello utilizaremos el
siguiente comando:
GPIO.setup(Puerto/Pin, GPIO.IN)
Antes de utilizar un puerto como salida deberemos de decirle al programa que ese
puerto funcionará como salida. Para ello utilizaremos la siguiente línea de código:
GPIO.setup(Puerto/Pin, GPIO.OUT)
Una vez que nuestro puerto trabaja como output, podremos establecer los valores de
0/false/0V/LOW ó 1/true/3.3V/High. Para ello utilizaremos el siguiente comando:
GPIO.output(13, 1) #fijamos la salida a 1/true/high
GPIO.output(13, 0) #fijamos la salida a 0/false/low
La siguiente pregunta que se nos plantea es cómo utilizar esta función. La deberemos utilizar al
final del programa, ya que reseteará todos los pines que hayamos utilizado. También debemos
tener en cuenta que el programa no siempre finaliza de forma correcta, ya que podría haber
algún error (excepción) y no terminar correctamente, o podemos pararlo nosotros de forma
manual tecleando Ctrl+C. Para tener en cuenta estas tres posibilidades en la finalización de un
programa, y que se limpien los puertos ocurra cual ocurra, una opción limpia es la de ordenar
nuestro código de la siguiente forma:
import RPi.GPIO as GPIO
try:
#Aquí introducimos nuestro código principal (lo que queramos que haga RP)
except KeyboardInterrupt:
# Esta interrupción se corresponde al evento cuando tecleamos Ctrl+C
except:
# Este apartado recogerá el resto de excepciones
finally:
GPIO.cleanup() #Limpiamos los puertos que hayamos utilizado
Conectando un sensor
Ahora que ya sabemos trabajar con las entradas y salidas de la Raspberry Pi, llega el momento
de comunicarnos con el mundo real. Para ello, le conectaremos sensores y recibiremos los
valores que éstos nos ofrezcan. Como vimos en tutoriales anteriores, tenemos dos tipos de
sensores con los que trabajar, sensores analógicos y sensores digitales. En el caso de la
Raspberry Pi, ésta sólo admite digitales así que para poder utilizar sensores analógicos
necesitaremos un conversor analógico digital como este [11].
A continuación presentamos el código Python que tomará las lecturas de este sensor y que
imprimirá si existe o no movimiento. Destacar que cuando este sensor devuelve el valor 1
significa que hay movimiento y que si devuelve 0 significa que no lo hay.
Tendremos varias formas de guardar este código en la RP. Por un lado, una vez conectados por
ssh, podemos utilizar el editor de texto nano (o cualquiera con el que estemos acostumbrados
a trabajar), copiar este código, y guardarlo con el nombre que queramos (por ejemplo
“lecturaPIR”) con la extensión “.py” que indicará que es un código Python (lecturaPIR.py). Otra
opción, que igual os parece más atractiva, es la de entrar visualmente a las carpetas de la RP y
colocar nuestro código en una de ellas. Una forma muy práctica de hacer esto es, si hemos
estado utilizando el programa XShell en Windows, instalar Xftp. Una vez instalado, nos
conectaremos por ssh a nuestra RP, clicamos en el icono correspondiente y nos
aparecerá una ventana con la estructura de archivos de nuestra RP. Creamos una carpeta donde
guardaremos nuestros códigos, creamos el archivo y copiamos el código anterior, guardándolo
con la extensión “.py”.
Para poner nuestro programa a funcionar, una vez que estemos conectados por ssh, nos
situaremos dentro de la carpeta donde esté nuestro código y teclearemos el siguiente comando:
Ahora que ya sabemos manejar un sensor digital en el que no nos hacía falta el uso de librerías,
trataremos un ejemplo en el que se requieren librerías para recoger los valores. Recordad que
las librerías son códigos que nos traducen los valores de los voltajes que recoge la placa y los
transforma a valores “legibles” para nosotros. Al igual que en el tutorial anterior [18]
utilizaremos el ejemplo del sensor de temperatura y humedad DHT22. Como ya explicamos, la
conexión es sencilla: este sensor tiene 3 pines (normalmente tiene 4 y uno no se conecta).
Tendremos que conectar Vcc (cable rojo) a los 5V de nuestra placa y GND (cable negro) a la
tierra. El otro pin (DATA) le conectaremos a un pin digital de la placa.
Como hemos dicho, para poder recoger los valores del sensor, necesitaremos las librerías que
nos hagan la conversión del voltaje que recoja la placa a unos valores legibles de temperatura y
humedad. Las librerías en Python del DHT22 para Raspberry Pi las ofrece Adafruit y se llaman
“Adafruit_Python_DHT”. A continuación os mostraremos los pasos para instalar la librería y
luego poder utilizarla en vuestros programas simplemente importándola.
Nos conectaremos por ssh a nuestra placa como en ocasiones anteriores, e iremos ejecutando
los siguientes comandos:
mkdir -p /home/pi/sources //creamos carpeta llamada sources dentro del directorio /home/pi
Ahora que está instalada la librería, la forma de recoger el dato en nuestros programas en
Python es la siguiente:
humidity, temperature = Adafruit_DHT.read_retry(Adafruit_DHT.DHT22, 4)
El primer argumento de la función (Adafruit_DHT.DHT22) indica el tipo del sensor. En nuestro
caso será DHT22, si fuera un DHT11 sería Adafruit_DHT.DHT11 y si fuera un AM2302 sería
Adafruit_DHT.AM2302, todos ellos son de la misma familia de sensores y utilizan la misma
librería. El segundo argumento (4) es el pin en el que tenemos conectado el pin DATA del sensor.
Es importante destacar que esta librería utiliza el modo BCM, aunque nosotros podremos tratar
los pines del resto de nuestro programa con el modo que queramos (pero el mismo modo para
todo el resto).
A continuación podéis ver el código que utilizaremos para realizar la lectura del sensor:
Ahora, guardamos el programa como hemos explicado anteriormente, por ejemplo con el
nombre DHT22Lectura.py y lo ejecutamos:
Es importante que antes de comenzar a trabajar con el chip, entendamos bien cómo funcionan
los pines SCL y SDA, y para ello deberemos conocer brevemente qué es el bus I2C, si queréis más
información podéis encontrarla, por ejemplo, en [13].
En pocas palabras, el bus I2C es una interfaz utilizada para comunicar distintos
microcontroladores, controladores con periféricos, etc. En nuestro caso queremos conectar RP
con un conversor. El bus está compuesto principalmente por 4 líneas, dos de ellas son las de
alimentación y tierra, las otras dos son SDA y SCL. La línea SDA nos permitirá enviar datos y la
SCL permitirá sincronizar la comunicación entre los dispositivos. Si nos fijamos en el dibujo de la
Figura 12 y pensamos en nuestros dispositivos, el máster (el que ordena cuándo quiere recibir
la información) será nuestra RP y el esclavo el conversor.
El bus I2C no viene habilitado por defecto en la RP, por lo tanto tendremos que hacerlo nosotros.
Los pasos para habilitar el bus son los siguientes:
1. Nos conectaremos por ssh (como hemos hecho anteriormente) a la RP.
ssh pi@192.168.X.X (sustituir por la dirección de vuestra RP)
Una vez habilitado el puerto I2C podremos comunicar el conversor analógico digital con nuestra
RP. Para comprobar su funcionamiento vamos a “crear” un sensor analógico de luminosidad con
ayuda de un LDR y resistencias. El funcionamiento de este componente ya fue explicado en
anteriores tutoriales, y puede ser consultado en [18]. Además, le añadiremos unos LEDs que se
encenderán dependiendo de la cantidad de luz que llegue al dispositivo. El montaje se muestra
en la Figura 16.
Ahora que ya tenemos listo el montaje, necesitaremos descargarnos las librerías del conversor.
En este caso, no se pueden instalar si no que te descargas el fichero y luego lo importas en el
código. Que ocurra una u otra cosa dependerá del tipo de librería. Podéis encontrarlas en [21].
A continuación presentamos el código que ejecutaremos en nuestra RP. El objetivo del código
es el de recoger los valores de luminosidad recogidos por el conversor.
Para que nos sea más sencillo, podemos guardar este código en la misma carpeta de la librería
del conversor. Si queremos hacerlo más limpio, por Internet podéis encontrar cómo importar la
librería. Para ejecutar el programa, nos metemos en la carpeta donde tengamos guardado el
código y ejeutamos la siguiente línea:
1. http://www.raspberrypi.org/products/
2. http://www.raspberrypi.org/downloads/
3. http://sourceforge.net/projects/win32diskimager/
4. http://es.wikipedia.org/wiki/Secure_Shell
5. http://nideaderedes.urlansoft.com/2014/01/15/raspberry-pi-como-conectarnos-via-ssh-sin-
monitor/
6. http://rastrack.co.uk
7. http://www.raspberrypi.org/documentation/configuration/raspi-config.md
8. http://www.tightvnc.com/download.php
9. https://launchpadlibrarian.net/18980633/Python%20para%20todos.pdf
10. http://es.tldp.org/Tutoriales/Python/tut.pdf
11. http://tienda.bricogeek.com/bricogeek/678-conversor-adc-8-bits-mcp3008.html
12. https://www.adafruit.com/products/1083
13. http://www.electroensaimada.com/i2c.html
14. http://www.electroensaimada.com/ip-estaacutetica.html
15. http://raspi.tv/2013/rpi-gpio-basics-1-how-to-check-what-rpi-gpio-version-you-have
16. http://www.xatakahome.com/domotica/algunas-cosas-a-tener-en-cuenta-antes-de-usar-una-
raspberry-pi
17. http://www.electroensaimada.com/raspberry-pi.html
18. Tutorial II: Comunicándonos con el mundo real. http://sociotal.eu/content/knowledge-transfer
19. http://www.home-automation-community.com/temperature-and-humidity-from-am2302-
dht22-sensor-displayed-as-chart/
20. https://www.netsarang.com/products/xsh_overview.html
21. https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code
22. https://www.raspberrypi.org/forums/viewtopic.php?p=798866#p798866
23. https://www.raspberrypi.org/forums/viewtopic.php?f=36&t=110557
Agradecimientos
Este tutorial ha sido realizado dentro del proyecto europeo SocIoTal (www.sociotal.eu). Este
proyecto ha recibido financiación del Séptimo Programa Marco de la Unión Europea para
investigación, desarrollo tecnológico y demostración bajo el acuerdo de concesión nº 609112.