TUTORIAL III:

PRIMEROS PASOS CON RASPBERRY PI

Carmen López de la Torre (Universidad de Cantabria) Ignacio Elicegui Maestro (Universidad de Cantabria)

Objetivos de este tutorial

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!

¿Qué es Raspberry Pi?

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.

En la actualidad existen tres modelos [1] de Raspberry Pi: 1 A+, 1 B+ y 2 B. A continuación describimos las características más importantes de estas placas.

- 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 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) o VideoCore IV 3D graphics core o Micro SD (antes era SD) o Menos consumo que su predecesor

Figura 1. Raspberry Pi 1 A+

Figura 2. Raspberry Pi 1 B+

- 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

Para este tutorial utilizaremos la Raspberry Pi 2 model B.

Configuración inicial de la Raspberry Pi

- ¿Qué materiales necesitamos? o Raspberry Pi (nosotros usaremos la Raspberry Pi 2 model B) o Tarjeta SD

Este es un punto bastante importante a la hora de configurar nuestra RP. Aunque en principio RP puede utilizar tarjetas SD de clase 4 o superior, éstas son muy lentas y lo ideal es una tarjeta de categoría 10. En cuanto a capacidad, una tarjeta de 4GB sería suficiente, aunque para curarse en salud para futuras actualizaciones del sistema operativo (SO) es mejor tener una de 8GB. En esta tarjeta instalaremos el SO, recordad que tiene que estar conectada siempre, la información de arranque de la placa estará en la tarjeta.

o Alimentación Para alimentar nuestra placa necesitaremos un cargador micro usb de 5V. La corriente necesaria dependerá de los periféricos que le queramos conectar. La intensidad mínima para la RP sería unos 750/800mA, aunque se calentará bastante. Para que trabaje de forma más relajada se recomienda utilizar cargadores de unos 2100mA. Si vuestros proyectos no están bien alimentados podéis experimentar problemas por ello, ya que la placa podría no tener suficiente corriente para trabajar.

o Para poder conectarnos con nuestra RP necesitaremos o bien un simple cable de red o bien un adaptador inalámbrico (normalmente plug and play).

- Configuración de la Raspberry Pi

o Paso 1: Montar la imagen del SO en la tarjeta SD

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

o Paso 2: Conectarse de forma remota a la Raspberry Pi

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].

El comando que utilizaremos para conectarnos es el siguiente:

ssh pi@192.168.X.X (sustituir por la dirección de vuestra RP)

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.

o Paso 3: Configuración inicial de la RP

Para configurar nuestra RP, una vez que nos hayamos conectado por ssh, teclearemos el siguiente comando: sudo raspi-config

El mensaje que nos aparecerá será una ventana como esta (Figura 4):

Figura 4. Menu de configuración de la Raspberry Pi

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.

o Paso 4: Establecer una ip estática a la Raspberry Pi

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.

En primer lugar nos conectamos por SSH a la RP:

ssh pi@192.168.X.X (sustituir por la dirección de vuestra RP)

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.

Con la información anterior, tecleamos:

cd /etc/network (accedemos al directorio)

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:

iface eth0 inet static

address 192.168.X.X (nueva IP fija)

netmask 255.255.255.0 (poner nuestra máscara de red)

gateway 192.168.Y.Y (poner la dirección de nuestro router)

Figura 5. Archivo "interfaces" antes de ser modificado

Figura 6. Archivo "interfaces" modificado

Para finalizar, guardamos el archivo tecleando Ctrl+X, nos preguntará si queremos guardar los cambios, le diremos que “yes”.

Para comprobar que se ha configurado la IP de forma correcta, reiniciamos la placa tecleando sudo reboot y una vez que se haya reiniciado, nos volveremos a conectar por ssh (se desconecta al reiniciarla) y tecleamos otra vez ifconfig para comprobar que la IP es la nueva que hemos asignado. Más detalles en [14].

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].

o Paso 5: Acceder al escritorio gráfico (no es necesario)

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:

sudo apt-get install tightvncserver (para instalar el programa servidor en la RP)

tightvncserver (si es la primera vez que hacemos este paso nos pedirá ponerle una contraseña)

vncserver:1 –geometry 1920x1080 –depth 16

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.

Ahora es el momento de poner en funcionamiento el VNC cliente, explicaremos cómo lo hacemos en Linux y en Windows.

- Linux:

El cliente lo instalaremos en el ordenador en el que vayamos a trabajar con el entorno gráfico de la RP. Para ello teclearemos los siguientes comandos

sudo apt-get install xtightvncviewer (para instalar el programa cliente en el ordenador)

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)

A continuación introduciremos la contraseña y ya tendremos listo nuestro entorno gráfico.

- 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

En la Figura 8 se muestra una captura del entorno gráfico de Raspberry Pi.

Figura 8. Entorno gráfico de la Raspberry Pi

Para cerrar la sesión, cerramos la ventana del entorno gráfico en el cliente, y para el servidor tecleamos lo siguiente:

ps –ef|grep vnc //veremos todas las sesiones con los displays

vncserver –kill :número_del_display

Conceptos básicos sobre nuestra Raspberry Pi

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 la Figura 7 se presenta el esquema de pines para la Raspberry Pi 2B y su correspondencia en la placa en la Figura 8.

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:

sudo apt-get update

sudo apt-get upgrade

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 10. Interfaces Rasbperry Pi 2 model B

Figura 9. Esquema de pines Raspberry 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)

La Figura 10 muestra las principales interfaces de la Raspberry Pi 2 model B.

o ¿Cómo utilizar las entradas y salidas GPIO?

A la hora de escribir un programa para la Raspberry Pi en Python, en primer lugar tendremos que indicar que vamos a utilizar las entradas y salidas de la RP. Para ello, la primera línea de nuestro programa será la siguiente

import RPi.GPIO as GPIO

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) # Modo BCM -> puertos GPIO GPIO.setmode(GPIO.BCM)

Manejo de los puertos de entrada

Antes de leer un puerto debemos establecerlo como entrada, para ello utilizaremos el siguiente comando:

GPIO.setup(Puerto/Pin, GPIO.IN)

El primer parámetro será el puerto o pin (dependiendo de la nomenclatura que hayamos dicho que vamos a utilizar) y el segundo indica que lo establecemos como entrada.

Por ejemplo, vamos a utilizar la nomenclatura de puerto GPIO y establecer el GPIO23 como entrada:

import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) # nomenclatura de puertos GPIO GPIO.setup(23, GPIO.IN) # establecemos el puerto GPIO 23 como entrada

Una vez que ya hemos dicho que funciona como entrada podremos leerlo. Los valores que podremos leer son booleanos, es decir, podremos leer 0/false/0V/LOW ó 1/true/3.3V/High. Podremos leer el valor con la siguiente línea de código:

GPIO.input(Puerto/Pin)

Manejo de los puertos de salida

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)

El primer parámetro será el puerto o pin (dependiendo de la nomenclatura que hayamos dicho que vamos a utilizar) y el segundo indica que lo establecemos como salida.

Por ejemplo, vamos a utilizar la nomenclatura de pines y establecer el pin 13 como salida:

import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) # nomenclatura pines GPIO.setup(13, GPIO.OUT) # establecemos el pin 13 como salida

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

Llegados a este punto es importante que conozcamos el concepto de GPIO.cleanup(). Esta funcionalidad nos permite “limpiar” todos los puertos que hayamos usado, reseteándolos y estableciéndolos como entradas. Pero, ¿por qué es importante hacer esto? La respuesta a esta pregunta es que nos prevé de situaciones que puedan dañar la placa. Por ejemplo, si dejamos un puerto de salida en high, no lo reseteamos y en otro momento ponemos sin darnos cuenta ese puerto en GND podríamos freír la placa.

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 # Aquí definimos la nomenclatura de los puertos, inicializamos variables, etc. 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].

• Conectando un sensor digital Comenzaremos conectando un sensor digital, en este caso utilizaremos un sensor de movimiento por infrarrojos, también llamados PIR. Este sensor tiene tres pines (Vcc, GND y OUT) por lo que conectaremos Vcc a 3.3V, GND a una de nuestras tierras, y OUT lo conectaremos al pin 7 o GPIO4. 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.

1. import RPi.GPIO as GPIO 2. from time import sleep # Librería para poder poner tiempos de espera 3. 4. GPIO.setmode(GPIO.BOARD) # nomenclatura de número de pines 5. GPIO.setup(7,GPIO.IN) # pin número 7 será la entrada del sensor 6. 7. try: 8. while True: 9. if GPIO.input(7): # si el sensor devuelve 1 10. print(GPIO.input(7)) # imprime el valor que devuelve el sensor 11. print("Hay movimiento") 12. else: 13. print(GPIO.input(7)) # imprime el valor que devuelve el sensor 14. print("No hay movimiento") 15. sleep(1) # tiempo de espera de 1 segundo 16. except KeyboardInterrupt: 17. print ("Paramos el programa") 18. except: 19. print ("Ha habido un error y el programa se ha cerrado") 20. finally: 21. GPIO.cleanup()

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:

sudo python lecturaPIR.py

Ahora comenzaremos a ver un mensaje u otro en la pantalla dependiendo si registra movimiento o no (podemos jugar pasando la mano por encima, cambiar las distancias, etc.). Cuando queramos que nuestro programa deje de funcionar teclearemos Ctrl+C, en ese momento el programa terminará y se hará el cleanup de los pines.

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:

sudo apt-get install -y build-essential python-dev git //dependencias

mkdir -p /home/pi/sources //creamos carpeta llamada sources dentro del directorio /home/pi

cd /home/pi/sources //entramos en la carpeta sources

git clone https://github.com/adafruit/Adafruit_Python_DHT.git //descargamos las librerías

cd Adafruit_Python_DHT //nos metemos en la carpeta de la librería

sudo python setup.py install //instalamos la librería

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:

1. import RPi.GPIO as GPIO 2. from time import sleep # Librería para poder poner tiempos de espera 3. import Adafruit_DHT 4. 5. GPIO.setmode(GPIO.BOARD) # nomenclatura de número de pines 6. GPIO.setup(7,GPIO.IN) # pin número 7 será la entrada del sensor 7. 8. try: 9. while True: 10. if GPIO.input(7): # cuando se reciba un valor en el pin 7 11. humidity, temperature = Adafruit_DHT.read_retry(Adafruit_DHT.DHT22, 4) 12. print("Temperatura = {0:.2f} y humedad = {1:.2f}%".format(temperature, humidity)) 13. sleep(1) # tiempo de espera de 1 segundo 14. except KeyboardInterrupt: 15. print ("Paramos el programa") 16. except: 17. print ("Se ha producido un error y el programa se ha cerrado") 18. finally: 19. GPIO.cleanup()

Ahora, guardamos el programa como hemos explicado anteriormente, por ejemplo con el nombre DHT22Lectura.py y lo ejecutamos:

sudo python DHT22Lectura.py

En la pantalla nos empezarán a aparecer líneas como las siguientes:

Temperatura = 25.30 y humedad = 56.90% Temperatura = 25.35 y humedad = 56.91% Temperatura = 25.29 y humedad = 56.90% …

Cuando queramos dejar de recibir valores por pantalla, teclearemos Ctrl+C

• Conectando un sensor analógico

Como hemos dicho anteriormente, la Raspberry Pi no tiene entradas analógicas como el Arduino, por ello necesitaremos algo que nos ayude a convertir las señales enviadas por los sensores analógicos en señales digitales. En nuestro caso utilizaremos el chip ADS1015, podéis encontrar más información sobre este componente en [12]. En la Figura 11 podéis ver el chip; sobre él hemos marcado los pines que utilizaremos para leer un sensor analógico. De izquierda a derecha podemos ver: el pin VDD por el que se alimenta el chip y que conectaremos a la entrada de 3.3V de la RP; el pin GND que conectaremos a un pin GND de la RP; los pines SCL y SDA que son los pines por los cuales el chip se va a comunicar con la RP, SCL ayuda a poder sincronizar los envíos y SDA envía el dato; los pines A0, A1, A2 y A3 son las distintas entradas

analógicas a las que conectaremos nuestros sensores y que el chip se encargará de traducir a digital.

Figura 11. Conversor analógico digital ADS1015

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.

Figura 12. Bus I2C (Fuente Wikipedia)

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)

2. Entraremos en la configuración de la RP (sudo raspi-config) y habilitaremos el“i2c”. Para ello seleccionaremos el apartado de “Advanced options” y nos aparecerá elsiguiente menú:

Figura 13. Panel de opciones avanzadas de Raspberry Pi

Seleccionamos la línea marcada en rojo en la Figura 13 (que es la correspondiente al I2C) y a continuación aceptamos a lo que nos vaya diciendo (que es que si queremos habilitarlo y que esté habilitado cuando encendamos la placa en futuras ocasiones).

3. Reiniciaremos la placa sudo reboot4. Nos volvemos a conectar por ssh y modificaremos el archivo situado en /etc/modules

añadiendo una nueva línea “i2c-dev”cd /etcsudo nano modulesEn este fichero añadiremos la líneai2c-devPara salir del editor y guardar el archivo tecleamos “Ctrl+X”, abajo nos preguntará siqueremos guardar los cambios, teclearemos “y” + intro, después nos preguntará siqueremos dejar el mismo nombre al fichero, teclearemos “y” + intro.

Figura 14. Fichero "modules" antes de ser modificado

Figura 15. Fichero "modules" después de ser modificado

5. Reiniciaremos la placa otra vez sudo reboot6. Ejecutaremos la siguiente línea para instalar “python-smbus” y “i2c-tools” para

ayudarnos en la posible búsqueda de errores y para permitir utilizar la interfaz i2c conPython.

sudo apt-get install i2c-tools python-smbus

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.

Figura 16. Montaje lectura LDR con ADS1015

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.

1. import RPi.GPIO as GPIO2. from time import sleep # Librería para poder poner tiempos de espera 3. 4. ADS1015 = 0x005. gain = 4096 # +/- 4.096V6. sps = 250 # 250 samples per second7. 8. GPIO.setmode(GPIO.BOARD) # nomenclatura de número de pines9. GPIO.setup(11,GPIO.OUT) # pin número 11 se establece como salida

10. GPIO.setup(13,GPIO.OUT) # pin número 13 se establece como salida 11. GPIO.setup(15,GPIO.OUT) # pin número 15 se establece como salida 12. 13. adc = ADS1x15(ic=ADS1015)14. 15. try:16. while True:17. volts = adc.readADCSingleEnded(0, gain, sps) / 1000 # entrada A0 18. if volts < 1.75 : #si valor en el pin está entre 1.3 y 1.75V 19. print "%.6f" % (volts) #imprime el valor que devuelve el conversor 20. print("1 LED") 21. GPIO.output(11, 1) #encendemos led conectado al pin 11 22. GPIO.output(13, 0) #apagamos led conectado al pin 13 23. GPIO.output(15, 0) #apagamos led conectado al pin 15 24. sleep (1) # tiempo de espera de 1 segundo 25. elif 1.75 <= volts <= 2.2 : #si valor en pin está entre 1.75 y 2.2V 26. print "%.6f" % (volts) #imprime el valor que devuelve el conversor 27. print("2 LED") 28. GPIO.output(11, 1) #encendemos led conectado al pin 11 29. GPIO.output(13, 1) #encendemos led conectado al pin 13 30. GPIO.output(15, 0) #apagamos led conectado al pin 15 31. sleep(1) # tiempo de espera de 1 segundo 32. else: #si valor en pin es mayor que 2.2V 33. print "%.6f" % (volts) #imprime el valor que devuelve el conversor 34. print("3 LED") 35. GPIO.output(11, 1) #encendemos led conectado al pin 11 36. GPIO.output(13, 1) #encendemos led conectado al pin 13 37. GPIO.output(15, 1) #encendemos led conectado al pin 15 38. sleep (1) # tiempo de espera de 1 segundo 39. except KeyboardInterrupt:40. print ("Paramos el programa")41. except:42. print ("Ha habido un error y el programa se ha cerrado")43. finally:44. GPIO.cleanup()

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:

sudo python LecturaLDR.py

Bibliografía

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_Shell5. http://nideaderedes.urlansoft.com/2014/01/15/raspberry-pi-como-conectarnos-via-ssh-sin-

monitor/6. http://rastrack.co.uk7. http://www.raspberrypi.org/documentation/configuration/raspi-config.md8. http://www.tightvnc.com/download.php9. https://launchpadlibrarian.net/18980633/Python%20para%20todos.pdf10. http://es.tldp.org/Tutoriales/Python/tut.pdf11. http://tienda.bricogeek.com/bricogeek/678-conversor-adc-8-bits-mcp3008.html12. https://www.adafruit.com/products/108313. http://www.electroensaimada.com/i2c.html14. http://www.electroensaimada.com/ip-estaacutetica.html15. http://raspi.tv/2013/rpi-gpio-basics-1-how-to-check-what-rpi-gpio-version-you-have16. http://www.xatakahome.com/domotica/algunas-cosas-a-tener-en-cuenta-antes-de-usar-una-

raspberry-pi17. http://www.electroensaimada.com/raspberry-pi.html18. Tutorial II: Comunicándonos con el mundo real. http://sociotal.eu/content/knowledge-transfer19. http://www.home-automation-community.com/temperature-and-humidity-from-am2302-

dht22-sensor-displayed-as-chart/20. https://www.netsarang.com/products/xsh_overview.html21. https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code22. https://www.raspberrypi.org/forums/viewtopic.php?p=798866#p79886623. 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.