Insoladora con Leds UV

Después de haber experimentado distintos procedimientos de realización de circuitos impresos por el método de transferencia térmica, sin resultados positivos, opté por experimentar con el método de la insoladora.
Una opción era la de comprarme la insoladora por eBay, pero las pocas que encontré no me parecían baratas, además de ser de lámparas ultravioletas (de ahí el elevado precio). En cambio, en eBay, por un módico precio de 19,95€ + 5,50€ de gastos de envío, sí pude encontrar un kit para montar, consistente en una placa, 35 diodos LED UV, 35 resistencias, conectores macho y hembra y hasta una tira de estaño para soldar los componentes - esto último, todo un detallazo. Más abajo, en la sección de enlaces, podéis encontrar la dirección en eBay. Es una buena solución, pero...
Mi idea, parece ser, era experimentar y hacerme con una insoladora casera, de cosecha propia, por lo que opté por recorrerme la red en busca de un diseño que me sirviese de base para mi propia solución.

Investigando

¿Lámparas o LEDs?

Lo primero que observé fue que el coste de los diseños con lámparas ultravioletas, además de ¿obsoletos?, resultaban algo más caros. No tan caros como podía resultar hace algún tiempo, pero descarté esta solución. Como curiosidad, parece ser que el uso que están dando a estas lámparas es para los típicos detectores de billetes 'de curso legal', billetes que muestran ciertas patrones o marcas de agua cuando se exponen a la luz ultravioleta, y para el secado de el esmalte de uñas (actividad que se ha puesto de moda y puede observarse la proliferación de estos negocios yendo por la calle).
En cambio, había profusión de diseños de insoladoras con LEDs UV. Existe mucha información al respecto, muchas soluciones prácticas, desde cálculos de cómo distanciar los LEDs entre sí, hasta el valor de las resistencias que se ponen en serie con los LEDs. Sin olvidarme de los esquemas de la placa en donde montar los componentes. Y con tal profusión de información, fue por ahí por dónde me decanté. El diseño iba a ser con LEDs UV.

Diseño de la placa

La mayoría de las placas tenían una distribución matricial de los LEDs. Es decir, quedaban posicionados en los nodos de una retícula cuadrangular. Aunque era la distribución más fácil de realizar, consideré que no era la más eficiente, desde un punto de vista de radiación luminosa. Imaginé que la intensidad luminosa no sería muy homogénea en un plano paralelo a la placa radiante, por lo que busque otra distribución.

La distribución que me pareció más eficiente fue la disposición de los LEDs en el centro de cada uno de los hexágonos que conforman una retícula hexagonal. En la siguiente imagen, los puntos negros indican la posición de los LEDs en una retícula hexagonal.

Esto hacía un total de 9 x 4 + 8 x 3 LEDs, es decir, el diseño iba a requerir un total de 60 LEDs. Y con esta distribución iba a conseguir, en teoría, una iluminación bastante más homogénea que la que podía ofrecer una retícula cuadrangular. Más adelante, indicaré y justificaré la distancia entre LEDs.

Ahora, hablemos de la tolerancia de los componentes y el porqué agrupar los LEDs de tres en tres y en la disposición que muestro. Agrupo los LEDs de tres en tres por las características eléctricas de los LEDs y por la tensión de alimentación que voy a utilizar. Más adelante mostraré los cálculos realizados. Pero antes, algunas consideraciones.

El tamaño de la tarjeta donde van los LEDs no iba a ser mayor de 150x100 mm2. Este tamaño me es suficiente para el diseño de placas que pienso realizar: las de un tamaño similar a tarjeta de crédito, es decir, tipo Raspberry Pi. Si suponemos que los LEDs los voy a espaciar 18 mm (después diré el porqué de esta elección) las dimensiones mínimas de la tarjeta que contendrá los LEDs será de:

8 * 18mm x 6 * 18mm sen(60º) => 144 x 93,53 mm2

por lo que con una tarjeta de tamaño estándar de 150x100 mm2 tendré suficiente para disponer los 60 LEDs y los 4 taladros de sujeción de la placa en la caja contenedora.

Cálculos

Iba a alimentar la tarjeta con una tensión estándar de 12 Vcc. Pero la fuente que compré solo me daba 11Vcc. Las características de los LEDs UV que vamos a utilizar tienen una tensión de caída de entre 3,0V a 3,8V. Nosotros consideraremos que es 3,3V y limitaremos la corriente a 20mA (aunque el máximo valor admisible suele ser 30mA para estos diodos, con el riesgo de dañarlos definitivamente) . Si serializamos 3 diodos  UV y 1 resistencia, esta resistencia tendrá que tener un valor máximo de:

(11Vcc - 3 x 3,3V) / 20 mA =  55 ohmios. => 56 ohmios.

Vamos a poner en lugar de la calculada (55 ohmios), que no tiene un valor comercial, una de un valor superior: 56 ohmios. Con esta resistencia, bajaremos algo la luminosidad de los diodos, pero aseguraremos que circulan por ellos menos de 20mA.

OJO con este valor: Yo he puesto 56 ohmios arriesgándome algo. Si la fuente que ponemos finalmente proporciona 12Vcc, la corriente sería superior a los 30mA (alrededor de 37,5mA) lo que destruiría parte de los diodos LEDs.

Ahora vamos a calcular la distancia de separación entre los diodos LEDs. Para ello nos valdremos de nuevo de las características de los diodos que vamos a utilizar, que nos dice entre otras características que el ángulo óptimo de visión (de radiación), que se obtiene mediante una pequeña lente acoplada sobre el elemento radiante, varía de 15º a 30º.
De acuerdo al esquema de al lado, tenemos que:

h = d / tan(a/2)

nosotros vamos a considerar que d=18mm y a=(15º+30º)/2, con lo que tenemos :

h = 18mm / tan(22,5/2) =  90,5mm

ésta es a la distancia que tendríamos que poner el fotolito de la retícula de diodos para recibir una luminosidad homogénea sobre todo el fotolito. Finalmente, yo consideré una distancia de 80mm ¿porqué? sobre todo, por no hacer la caja contenedora excesivamente alta, y porque estamos hablando de un ángulo óptimo, pero la radiación no cae abruptamente a partir del ángulo óptimo de visión, y, por tanto, aunque reduzcamos la altura h, continúa existiendo un solape completo entre los dos conos contiguos de radiación. Quizás alguien sea más purista y sitúe la distancia del fotolito al plano de la retícula de diodos a la que resulte del cálculo realizado. Bueno, sería interesante hacer experimentos y comprobar la eficiencia de este montaje con los datos teóricos.

Diseño de la placa

Con todas estas consideraciones, para el diseño de la placa utilicé, como en otras ocasiones anteriores, el programa Kicad. Con este programa diseñé el esquema electrónico y el circuito impreso.

En la sección de enlaces se encuentra el fichero comprimido UVLeds.zip con todos los ficheros generados con el programa Kicad.

Fabricación del circuito impreso

Como aún no tenía la insoladora, y como con los otros procedimientos que había utilizado, el de transferencia térmica del fotolito al circuito impreso, había obtenido un total fracaso, opté por dibujar (es un decir) las pistas del circuito impreso con un rotulador indeleble. Después de experimentar con varios rotuladores utilicé finalmente el modelo Lumocolor (negro) de la marca STAEDTLER. El circuito, después de aplicar el cloruro férrico, se quedó con este aspecto (sí, un poco chungo pero funcionó a la perfección):

Lista de componentes

Para la fabricación del circuito impreso he dispuesto de los siguientes componentes:
- 1 placa virgen de 100x150 mm2.

- 60 LEDs UV.

- 20 resistencias de 56 ohmios.
- 4 soportes de plástico autoadhesivos.
Los LEDs UV los compré a través de eBay a Bright Components. Los venden en bolsas de 50 leds a 4,53€ la bolsa (por lo que tuve que comprar dos bolsas) que con los gastos de envío (3,81€) me salió por un total de 12,87€ los 100 diodos UV. Decir que el envío me llegó en menos de 5 días.
El resto del material se puede comprar sin problemas en cualquier tienda de componentes electrónicos (también los diodos UV per oresultan más caros que comprándolos fuera).
El acabado final con los diodos y resistencias montados es el que se muestra a continuación:

Caja contenedora

La caja contenedora la he fabricado de madera ¿? y tiene el siguiente aspecto a medio terminar:

Se puede observar la retícula de diodos, el temporizador realizado con un 555 al que le he atacado un relé de salida para activar/desactivar la retícula de diodos.

y la consola de monitorización y control de la insoladora.

El led rojo indica que la insoladora está conectada a la fuente de alimentación.
El led verde se ilumina mientras los LEDs UV están encendidos.
El pulsador negro es para activar el temporizador.
El pulsador rojo es para desactivar el temporizador (y apagar manualmente los LEDs UV.
El commutador en 1) escala de hasta 10 minutos de temporizador; y en 2) escala de hasta 25 minutos.
Con el potenciómetro se regula el temporizador de 1 a 10 y de 10 a 25 minutos, más o menos.
El temporizador será objeto de otra entrada de este blog.
La caja contenedora se completó 1) con una ventana superior de cristal de 2mm de espesor, donde descansaría el fotolito y el circuito impreso fotosensible, y 2) con una tapa de madera a la que le pegué una lamina gruesa de goma para que hiciese presión sobre el fotolito+circuito impreso mientras estaban iluminando los LEDs UV.
Y eso es todo.

Enlaces

- IL010 UV09 Placa 35 LED UV enlazable. KIT desmontado Color UV, Alimentación 9V
- Espectro electromagnético
- Radiación ultravioleta
- Diversos usos de lámparas UV
- Billetes de Euro
- LED calculator
- Kicad
- Ficheros Kicad del esquema y circuito impreso de LEDs UV para insoladora
- Leyendo Entradas Digitales con las Raspberry. Calibrado de Temporizador para Insoladora

- 50 x Ultra Violet / UV / Purple LED 5mm - 3000mcd

Leyendo Entradas Digitales con las Raspberry. Calibrado de Temporizador para Insoladora

Durante todo estos últimos días me he dedicado a realizar una insoladora. Sí, una insoladora. ¿Y para qué quiero yo una insoladora? Pues muy sencillo. He desarrollado una tarjeta de expansión con Kicad y quería fabricarme una tarjeta con el diseño implementado. Empecé con el método de la transferencia térmica desde papel a placa de cobre, utilizando papel de todo tipo e impresoras láser y también de inyección de tinta...y no lo conseguí. Utilicé, para diseños muy sencillos, rotuladores indelebles (me compré una colección de marcas y tipos) consiguiendo unos resultados más que aceptables: 1) un circuito impreso temporizador para la insoladora; y 2) un circuito impreso para un array de leds ultravioletas, también para la insoladora. Prometo escribir sobre la fabricación de una insoladora más adelante. Pongo un anticipo de lo que he llegado a realizar, con la fotografía del artefacto funcionando:

En la imagen, con el array de Leds UV activo, podemos ver la disposición hexagonal de los leds (60) en primer plano y, detrás, el temporizador, pudiendo observar los dos condensadores (izda), el circuito integrado 555 (centro) y el relé (dcha) que conecta la tensión de 12Vcc.
Pero con un rotulador indeleble no puedes ambicionar fabricarte circuitos impresos de precisión y con acabado profesional. A lo mucho que puedes aspirar es a diseñar unas placas como las que hice para la insoladora en donde los componentes están suficientemente espaciados y las pistas pueden ser de un grosor aceptable y espaciadas suficientemente.
El temporizador lo he diseñado con dos escalas de tiempo y con ciertas posibilidades de calibración. Las dos escalas de tiempo permitían unos rangos de temporización teóricos de a) 1 a 5 minutos y de b) 2 a 20 minutos, más o menos. Pero ¿cómo podía saber con exactitud los rangos reales y calibrarlos a valores próximos a los teóricos? Pues, muy sencillo: utilizando las posibilidades de la Raspberry, que me permite leer el estado de unas entradas digitales, la de ciertos pines del conector de expansión de 2x13 pines. Y eso es lo que hice.

Consideraciones

El array de leds está alimentado a 12Vcc, voltaje que es proporcionado por el cierre de una salida del relé del temporizador. Teniendo en cuenta esto, haremos un montaje teórico con Fritzing, sustituyendo la salida del relé por un pulsador. En el montaje real, utilizaremos la salida del relé.

Descripción del circuito

Vamos a utilizar dos pines del Raspberry:
- el pin 18 (GPIO24) como entrada.
- el pin 22 (GPIO25) como salida.
La tensión que le llega a la entrada GPIO24 la vamos a reducir mediante un divisor de tensión. Hemos de tener en cuenta que lo que queremos comprobar es la presencia, o no, de una tensión de 12Vcc, y los pines del conector del Raspberry trabajan a 3,3Vcc. No es conveniente, por tanto, que superemos esta tensión. Por tanto, el divisor de tensión estará formado por dos resistencias en serie. Por un extremo conectaremos 12Vcc (el pulsador), el otro extremos lo pondremos a tierra; y el punto de unión de las dos resistencias será la que conectaremos al pin 18 (GPIO24) de la Raspberry.

      +12Vcc <=====> 10k ohms <=== pin 18 RaspPi ===>; 2k2 ohms <=====> GND

Además, también mostraremos la presencia de los 12Vcc encendiendo un led serializado con una resistencia de 1k ohms. Los cálculos se han hecho teniendo en cuenta que la tensión de caída a través del led es de 2Vcc, y que la máxima corriente a través del Led es de 20mA. Por tanto: (12Vcc-2Vcc)/20mA = 500 ohms, pero pongo una de 1k ohms al no tener ni los 500 ohms que me resulta en el cálculo ni el valor comercial de 560 ohms. He puesto la más próxima que tenía con un valor por encima de los 560. No puedo poner un valor menor, pues superaríamos los 20mA máximos que admite el diodo y nos lo fundiríamos.

¡¡¡¡ATENCIÓN!!! A la hora de montar el divisor de tensión habrá que extremar las precauciones. Yo me he cargado una entrada del Raspberry Pi.  Afortunadamente cuento con otras para probar el montaje.

Hasta aquí el diseño de entrada. Vamos a repetir la entrada del pin 18 replicando su valor en la salida del pin 22, también mediante un Led, serializado con una resistencia, que irá replicando el estado del otro Led, como resultado de la lectura que se haga con un programa. El cálculo de la resistencia a serializar es similar a los cálculos anteriores, cambiando la tensión que actuará sobre el Led+resistencia: (3,3Vcc-2Vcc)/20mA = 65 ohms, valor no comercial, pero pondremos el valor superior más próximo a este valor, resultando ser 75 ohms. En el esquema teórico aparece 220 ohms que también es válido, aunque el Led lucirá menos, pero se encenderá.

Programa de comprobación

Podemos hacer una comprobación del funcionamiento de los dos pines mediante la utilidad gpio. En Controlando un relé con una salida del conector GPIO del Raspberry Pi se muestra el modo de instalar esta utilidad, utilidad que viene incluida en la libreria WiringPi.

Lo primero que haremos será definir los dos pines, por lo que ejecutaremos:

gpio -g mode 25 out
gpio -g mode 24 in

Seguidamente, activaremos el Led de salida, y lo apagaremos, mediante las siguientes órdenes:

gpio -g write 25 1
gpio -g write 25 0

Podemos observar que estamos utilizando, en lugar del número físico del pin, el número lógico de la etiqueta GPIO. Podemos hacerlo así a lutilizar el parámetro -g. Si no queremos utilizar este parámetro, podemos hacer lo mismo ejecutando lo siguiente:

gpio mode 22 out
gpio mode 18 in
gpio write 22 1
gpio write 22 0

Y para la señal de entrada podemos invocar gpio con los parámetros oportunos:

gpio -g read 24
gpio read 18

Una vez que hemos comprobado el correcto funcionamiento del pin de entrada y del de salida, vamos a calcular los tiempos de funcionamiento del temporizador que controlará el encendido de los Leds UV de la insoladora. El programa nos va a permitir mostrar el tiempo en que está activo el relé de salida del temporizador, y por tanto el Led indicador encendido, lo hemos realizado en python.

from datetime import datetime
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BOARD)
GPIO.setup(18, GPIO.IN)
GPIO.setup(22, GPIO.OUT)

state = 0
st = datetime.now()
while True:

 # state toggle button is pressed
        if ( GPIO.input(18) == True ):
  if (state == 0):
   st = datetime.now()
   state = 1
   GPIO.output(22, GPIO.HIGH)
   print "START: ", st.strftime("%H:%M:%S")
 if ( GPIO.input(18) == False):
  if (state == 1):
   state = 0
   GPIO.output(22, GPIO.LOW)
   st2 = datetime.now()
   print "STOP:  ",st2.strftime("%H:%M:%S"), (st2-st)

Lo que hace el programa es, en primer lugar, configurar los dos pines utilizados para seguidamente entrar en un bucle sin fin, en donde comprueba los cambios de estado del pin de entrada, replicándolos en el pin de salida. Si el estado pasa a '1', se muestra y se guarda la hora de inicio. Cuando el estado pasa a '0', se muestra la hora de finalización y el tiempo que ha transcurrido desde que se inició el temporizador.
En la siguiente imagen podemos observar el programa funcionando, mostrando los tiempos de inicio y final del temporizador, en las dos escalas implementadas.

Con este programa podemos ir ajustando un potenciómetro interior, y así ir calibrando el tiempo mínimo de una de las escalas con las que cuenta el temporizador. Para ajustar exactamente los tiempos de las dos escalas, mínimo y máximo, tendría que modificar el diseño e incluir más potenciómetros. Pero así me es suficiente para insolar una placa fotosensible, ya que estamos hablando de tiempos de insolación de alrededor de 3 minutos, valor que está dentro del rango de la escala pequeña.
 En la siguiente imagen podemos ver el montaje funcionando.

Y eso es todo. Como ya he dicho, en cuanto pueda publicaré un par de artículos sobre la insoladora y sobre el temporizador, incluyendo los resultados de las pruebas realizadas.

Enlaces

- WiringPi
- raspberry-gpio-python
- Librería RPi.GPIO 0.5.4
- LED calculator for single LEDs
- timertest.py
- Controlando un relé con una salida del conector GPIO del Raspberry Pi

A vueltas con el servidor miniDLNA : Actualizando fácilmente su contenido

No hace mucho que escribí sobre este mismo tema, sobre el modo de transformar mi plataforma Ubuntu en un servidor DLNA (ver Viendo películas de tu plataforma Ubuntu en el monitor de televisión en este mismo blog). Parece que hubo un cierto interés en el asunto, tanto como que uno de los amables lectores me sugirió que hablase sobre una utilidad que facilita la labor de actualización de los contenidos del servidor miniDLNA. En eso va a consistir esta entrada, en actualizar la base de datos asociada al miniDLNA, sin tener que refrescar el método utilizado, que por cierto era algo pedestre.

Primera solución

 Esta primera opción que voy a exponer es la estoy utilizando en la actualidad. Es muy sencilla y a cualquiera se le hubiera podido ocurrir. Nos crearemos un fichero de órdenes, o shell-script, que ejecutaremos desde un terminal, cada vez que queramos actualizar la base de datos del miniDLNA.Sin ser muy original, a este fichero lo he llamado minidlna.sh, situándolo en mi carpeta personal.

user1@user-desktop:~$ cd $HOME
user1@user-desktop:~$ touch minidlna.sh
user1@user-desktop:~$ ls minidlna.sh
minidlna.sh
user1@user-desktop:~$

Lo siguiente que vamos a hacer es editar el fichero recién creado dejándolo como se muestra en la siguiente imagen

La primera línea borra la base de datos, la segunda regenera la base de datos, actualizándola con el contenido que encuentre en las carpetas definidas en el fichero de configuración de miniDLNA, y finalmente, reiniciamos el servidor. Guardamos el fichero y le asignamos permisos de ejecución (x) a todos los usuarios (a).

user1@user-desktop:~$ chmod x+a minidlna.sh
user1@user-desktop:~$ ls -la minidlna.sh
-rwxrwxr-x 1 user1 user 146 feb 24 08:41 minidlna.sh

Ejecutamos minidlna.sh desde un terminal y desde donde se encuentra el fichero de órdenes, que hemos considerado que fuera nuestra carpeta personal:

user1@user-desktop:~$ ./minidlna.sh
[sudo] password for user: 
 * Restarting DLNA/UPnP-AV media server minidlna                         [ OK ] 
user1@user-desktop:~$

Y al finalizar la ejecución de minidlna.sh tendremos actualizada la base de datos asociada.
Como podemos ver, el procedimiento es sencillo y rápido. Pero aún puede ser más sencillo y rápido si lo dejamos accesible en el área de indicadores de la barra de menús, tal y como vamos a mostrar en el siguiente apartado.

Indicador miniDLNA en barra de menús

Lo primero que vamos a realizar será bajarnos el fichero que contiene la aplicación del indicador miniDLNA, utilizando la instrucción wget desde un terminal.

wget https://launchpad.net/minidlna-ai/trunk/initial/+download/minidlna-ai-0.0.2.tar.gz

Sería conveniente comprobar que lo que nos bajamos es la última versión, por lo que no estaría de más buscar en Google por las versiones existentes ('launchpad minidlna-ai'), o yendo directamente a https://launchpad.net/minidlna-ai donde podremos bajarnos la versión más reciente.
Una vez descargado, creamos una carpeta cualquiera, descomprimimos desde la carpeta el fichero descargado y vemos los ficheros que aparecen en la carpeta:

user1@user-desktop:~$ mkdir minidlna
user1@user-desktop:~$ cd minidlna
user1@user-desktop:~/minidlna$ tar -zxvf  ../minidlna-ai-0.0.2.tar.gz  
readme
minidlna-ai.desktop
minidlna-ai24-red.svg
minidlna-ai24-off.svg
minidlna-ai24.svg
minidlna-ai.py
default.conf
user1@user-desktop:~/minidlna$ ls -la
total 76
drwxr-xr-x   2 user1 user  4096 feb 24 12:08 .
drwxr-xr-x 205 user1 user 12288 feb 24 12:07 ..
-rw-r--r--   1 user1 user  2345 ago 13  2012 default.conf
-rw-r--r--   1 user1 user 10892 ago 13  2012 minidlna-ai24-off.svg
-rw-r--r--   1 user1 user 10891 ago 13  2012 minidlna-ai24-red.svg
-rw-r--r--   1 user1 user 12311 ago 14  2012 minidlna-ai24.svg
-rwxr-xr-x   1 user1 user   308 ago 13  2012 minidlna-ai.desktop
-rwxr-xr-x   1 user1 user  5606 ene 25  2013 minidlna-ai.py
-rw-r--r--   1 user1 user  2310 ene 27  2013 readme
user1@user-desktop:~/minidlna$

En el fichero readme vienen las instrucciones, en inglés, para instalar el indicador minidlna. Lo vamos a seguir, comentando paso a paso lo que debemos hacer.

Procedimiento de instalación del indicador miniDLNA

1. Instalamos el paquete python3-gi, para satisfacer las dependencias del indicador.
2. Copiamos el contenido de la carpeta en donde hemos descomprimido el archivo descargado en /opt/minidlna-ai/.
3. Copiamos el fichero minidlna-ai.desktop en la carpeta ~/.config/autostart/ con objeto de que se active en cada sesión de usuario, o en ~/.local/share/applications para acceso desde el escritorio.
4. detenemos el servicio minidlna, que debe estar ejecutándose como un servicio root.
5. ejecutamos manualmente el fichero minidlna-ai.py con objeto de que se copie el fichero de configuración existente en ~/.config/minidlna.
6. Editamos, si es preciso, el fichero ~/.config/minidlna/mindlna.conf con los datos apropiados

media_dir=/path/to/media # ubicación de las carpetas con contenido multimedia
db_dir=/home/<user>/.config/minidlna # ubicación de la base de datos .db
log_dir=/home/<user>/.config/minidlna # ubicación del fichero 'log'

Ni que decir tiene que tendremos que sustituir la etiqueta <user> con el nombre de usuario pertinente.
Resumiendo lo anterior, nos queda como sigue:

 user1@user-desktop:~/minidlna$ sudo apt-get install python3-gi
user1@user-desktop:~/minidlna$ sudo cp *.* /opt/minidlna-ai/
user1@user-desktop:~/minidlna$ cp minidlna-ai.desktop ~/.config/autostart/
user1@user-desktop:~/minidlna$ cp minidlna-ai.desktop ~/.local/share/applications
user1@user-desktop:~/minidlna$ sudo service minidlna stop
user1@user-desktop:~/minidlna$ python minidlna-ai.py 
                  -editamos fichero ~/.config/minidlna/mindlna.conf -
user1@user-desktop:~/minidlna$ sudo service minidlna start

y eso es todo. Reiniciamos el equipo y comprobamos que el indicador minidlna-ui aparece en el área de indicadores de la barra de menús y de que la funcionalidad es la esperada.

En el menú desplegable podemos observar que podemos actualizar la base de datos con nuevo contenido multimedia, desconectar y conectar, así como salir de la aplicación.
Como siempre, aprovecho la ocasión para invitar a los amables lectores a que comenten el artículo, con mejoras, correcciones, sugerencias, etc. así como de nuevas entradas.

Enlaces

- miniDLNA
- minidlna-ai
- Viendo películas de tu plataforma Ubuntu en el monitor de televisión

Controlando un relé con una salida del conector GPIO del Raspberry Pi

En entradas anteriores he ido ampliando progresivamente las posibilidades de utilización de la Raspberry Pi, empezando, como no podía ser de otra manera, por la instalación del sistema operativo Raspbian, y he continuado con la implementación de una tarjeta de expansión del GPIO, de 2x13 pines. He sido capaz de utilizar el bus i2c para acceder a un Reloj en Tiempo Real, y de controlar las salidas digitales de un mcp23008 y mcp23017. La he integrado plenamente en mi red local, pudiendo comunicarme desde otro ordenador mediante el uso del comando ssh desde un terminal remoto. He instalado LAMP y phpmyAdmin, con lo que he potenciado mi RaspPi haciendo que pase a ser un servidor dinámico de páginas Web.
¿Qué más puedo hacer? Multitud de cosas. Pero en esta entrada voy a centrarme en el control de una salida digital que actuará un relé, activándolo o desactivándolo, a nuestra conveniencia. Oiremos un leve chasquido cada vez que actuemos sobre el relé, cambiándolo de estado. Pero para que dicho cambio de estado sea más visible (aparte de audible) conectaremos un LED tricolor (utilizaremos sólo dos colores) que cambiará entre dos colores (verde y azul) dependiendo del estado del relé (excitado o desexcitado).

Material necesario

El material que he utilizado para este montaje es el siguiente:

• 1 relé Finder : Serie 30 - Relé subminiatura D.I.L. 2 A (30.22.7.005.0010), u otro de similares características.
• 3 resistencias de 330 ohmios.
• 1 LED tricolor  con cátodo común, o también nos valdría leds sencillos.
• 1 diodo 1N4001.
• 1 transistor NPN 2N2222A.
• 1 protoboard.
• conector de expansión (desarrollado por mi) para conexión de la protoboard al RaspPi. Ver entrada anterior en este blog (Conectando la Raspberry Pi a una protoboard).

Si he utilizado un LED tricolor ha sido porque no disponía de LEDs sencillos ¿?. Con un par de LEDs podríamos realizar el mismo montaje de prueba.
He probado el montaje con dos relés de distintas marcas pero con características similares, y el montaje ha funcionado perfectamente. 

Diseño del circuito

Para el diseño del circuito hemos utilizado el programa Fritzing. La mayoría de los componentes forman parte de la librería estándar del programa, exceptuando el relé, que he tenido de modificar/adaptar a las características del relé utilizado, y que incluyo el enlace para poder utilizarlo. También incluyo el enlace del componente correspondiente al conector de expansión.

Las partes críticas del diseño corresponden a los valores de las resistencias. Debemos tener en cuenta, por un lado, que los 5Vdc que proporciona la RaspPi a través del conector GPIO P1 de 2x13 pines, están muy limitados ( a menos de 300mA). Además, la corriente que puede proporcionar cada uno de los pines del conector GPIO (en este caso estamos utilizando la salida GPIO25) en teoría se limita a 3mA. Pero parece ser que este límite es en teoría (ver Understanding Outputs), ya que en la práctica se han hecho cálculos de que una salida puede llegar a dar 16mA pero con el límite de 51mA para el conjunto de todas las salidas.
El relé requiere una corriente de excitación de su bobina de al menos 30 mA. Por lo que pondremos un transistor que amplifique suficientemente la corriente del pin GPIO25, para despreocuparnos del asunto, transistor NPN que atacaremos su base con la salida GPIO25. Limitaremos la corriente de salida del GPIO25 con una resistencia de 330 ohmios (3,3V - 0,6V = 2,7V => 2,7/330 = 8,2mA). Con una ganancia del transistor (hFE) de al menos 35, tendría la posibilidad de proporcionar, si fuera preciso, una corriente de 287 mA, corriente que estará de todos modos limitada por la resistencia de la bobina del relé (125Ω) a 32mA (5V - 1Vce = 4Vdc => 4/287=32mA).

Montaje del diseño en la protoboard

Una vez realizadas las comprobaciones pertinentes, pasaremos a montar todos los componentes en la protoboard, con la RaspPi sin tensión. Comprobaremos concienzudamente la polaridad de los diodos y transistores y una vez que estemos seguro de ello, conectaremos el cable plano entre la RaspPi y el conector de expansión y alimentaremos a la RaspPi.

Prueba del montaje

Para comprobar que el montaje funciona bien utilizaré una utilidad que viene con la librería WiringPi, de acceso al conector GPIO. Podemos comprobar que se ha instalado previamente tecleando en la consola remota, abierta con ssh, la instrucción gpio -v. Si nos da un error, deberemos instalarla. Por si no la hubiéramos instalado previamente, indico a continuación las instrucciones a seguir para su instalación:

sudo apt-get install git-core
sudo apt-get update
sudo apt-get upgrade
git clone git://git.drogon.net/wiringPi
cd wiringPi
git pull origin
cd wiringPi
./build

La primera instrucción será precisa si no tuviéramos instalado el software de control de versiones Git.
Una vez instalada, podemos comprobar que se ha instalado perfectamente tecleando de nuevo:

gpio -v
gpio -h
gpio readall

pudiendo ver en las siguientes imágenes lo que nos muestran estas instrucciones.

Ha funcionado a la perfección. La última sentencia nos ha mostrado el estado de los 20 pines del conector GPIO, y la relación biunívoca entre el pin físico y lógico. Se descartan los pines de alimentación y de puesta a tierra.
Procedamos a cambiar de estado el relé, ejecutando las siguientes instrucciones:

La primera instrucción pone el pin lógico 25 como salida. La siguiente instrucción activa la salida y por tanto el relé, con lo que cambia el color del LED tricolor, y con la última instrucción desactiva la salida y conescuentemente el relé, por lo que el led tricolor recupera el color original. En las instrucciones hemos incluido el parámetro -g para indicarle que estamos utilizando los pines lógicos.
Bien, eso es todo. Como siempre, confío en que esta entrada sea de interés y, también, de nuevo reiterar que agradecería todos los comentarios de los lectores, comentarios que sean para ampliar, mejorar, rectificar, etc. o proponer nuevas entradas que sirvan para resolver y aclarar dudas y aprender nuevos usos de la tarjeta Raspberry Pi, o de otros temas técnicos.

Enlaces

- Finder : Serie 30 - Relé subminiatura D.I.L. 2 A.
- Full-Spectrum Multicolor Discrete RGB LEDs with Leads.
- Hoja de características diodo 1N4001.
- Hoja de características transistor NPN 2N2222A.
- Raspberry Pi Wiki Hub.
- GPIO current specifications.
- Understanding Outputs
- How to use GPIOs on raspberry pi (Simple I/O, PWM and UART)
- Raspberry Pi – Driving a Relay using GPIO.
- Raspberry Pi, interactuando con GPIO desde la línea de comandos.
- Git (software de control de versiones).
- Wiring Pi.
- The GPIO utility.
- Fritzing.
- RelayControlledByRaspPi.

- Relay DPDT 2 x switch.

Conectándonos al RaspberryPi en red local

En esta nueva entrada voy a tratar de abarcar todo lo que necesitamos realizar para conectarnos a nuestro RaspPi de forma remota, primero, a través de nuestra red local; y lo completaremos con el modo de acceder sin problemas desde cualquier parte del mundo (que tenga acceso a Internet).
El modo fácil de comunicarnos con nuestro RaspPi es conectando 1) la salida HDMI (o de vídeo) a un televisor y 2) un teclado+ratón inalámbricos a través de uno de los puertos USB de los que dispone la RaspPi (v2). Éste ha sido el modo que he utilizado para instalar el sistema operativo Raspbian y una serie de paquetes que me permitirán conectarme de forma remota, pudiendo prescindir del monitor de televisión y del teclado+ratón inalámbricos. Estamos hablado de la versión 2 de la Raspberry Pi. Si fuéramos a utilizar la versión 1 de la RaspPi, debemos tener en cuenta que no disponemos de conector RJ-45 y solo dispone de un puerto USB.

Accediendo desde nuestra red local

La RaspPi trae de origen un conector RJ-45 para conectarnos a una red local mediante un cable Ethernet que enchufemos a nuestro router/switcher. Si éste va a ser el modo de acceder, nos podemos saltar el siguiente apartado e ir directamente a Accediendo mediante el comando ssh.
También tenemos la posibilidad de conectarnos a través de una línea serie (en Enlaces se explica el modo de implementarlo), accediendo directamente a la consola de comandos del sistema Raspbian, opción que vamos a descartar, al ser algo más complejo el montaje requerido y no aportar nada interesante.

Configuración de la red WiFi

También podemos acceder por WiFi, siempre y cuando conectemos un adaptador USB-WiFi a uno de los dos puertos USB con que viene dotado nuestra RaspPi (Modelo B). Habrá que elegir, de entre todas las visibles, la red WiFi a la que nos queramos y podamos conectar, red que probablemente estará protegida por contraseña, y que tendremos que introducir para ser aceptados como usuarios de este red local.
Pero ¿cómo podemos conectarnos a una red WiFi? El modo más sencillo sería entrado a través de la interfaz gráfica LXDE que trae por defecto Raspbian y pulsar sobre el icono WiFi Config. Seleccionaríamos la red e introduciríamos la correspondiente contraseña.
¿y si por el motivo que sea no tenemos modo de conectarnos a la red local? El modo que tendremos de  configurar el acceso a la red WiFi consistirá en editar los ficheros de configuración en donde se guardan los datos de la conexión, edición que podemos hacer desde otro PC.
Extraeremos la SDcard del RaspPi, la insertaremos en nuestro PC, nos iremos a la partición en donde se encuentre nuestro sistema operativo Raspbian y procederemos a editar los ficheros pertinentes.
Raspbian necesita dos ficheros para configurar el acceso a una red WiFi protegida por contraseña y encriptación WPA2/WPA (WiFi Protected Access), más segura que con la obsoleta WEP (Wired Equivalent Privacy):

/etc/network/interfaces
/etc/wpa_suplicant/wpa_suplicant.conf

Desde nuestro PC, y en modo root editaremos el fichero interfaces, o nos aseguraremos de que, al menos, contiene las siguientes líneas de código:

Podemos sustituir wpa-roam por wpa-conf si queremos que la conexión se realice por WiFi, a pesar de que estemos conectados por un cable Ethernet. Si lo que hemos puesto es wpa-roam, en el momento que conectemos un cable de red se desactivará la conexión WiFi, y si lo desenchufamos tratará de establecer una conexión por WiFi, buscando entre todas las redes que detecte en este momento y que estén habilitadas en el fichero wpa_suplicant.conf, fichero que vamos a editar, también en modo root:

Nos crearemos un bloque, similar al que en la imagen anterior hemos realzado en verde, y similar al resto de bloques que tengamos. Introduciremos el nombre de la red a la que queremos conectarnos y la contraseña válida para poder acceder. Comprobaremos que los demás parámetros son adecuados.

# Identificador de RED SSID
ssid="Identificador de Red"

# contraseña válida para la red a la que queremos acceder
psk="la contraseña asociada a esta red"

# tipo de protocolo: RSN (para WPA2) y WPA (para WPA1)
proto=WPA

# tipo de gestión de contraseñas:
#   - WPA-PSK (Pre-Shared) o
#   - WPA-EAP (Enterprise)
key_mgmt=WPA-PSK

# tipo de apareamiento: CCMP (WPA2) o TKIP (WPA1)
pairwise=TKIP

# opciones de autorización: OPEN (WPA1/WPA2)
# otras posibles opciones poco frecuentes: SHARED y LEAP
auth_alg=OPEN

Extraeremos la SDcard, y la insertaremos en la RaspPi. Al finalizar el arranque, y si lo hemos hecho correctamente, será capaz de conectarse, si está en cobertura, a la nueva red WiFi.

Accediendo mediante el comando ssh

Averiguaremos si está en red, y la IP que le ha sido asignada, y de este modo entraremos a través del comando ssh. Los detalles de estos pasos vienen explicados aquí, y que corresponde a una entrada previa de este blog. La posibilidad de utilizar el comando ssh puede ser determinado en fase de instalación del sistema Raspbian:

Activado el servidor ssh, podemos invocarlo desde el terminal de comandos que abrimos en otro PC tecleando lo siguiente:

en donde hemos indicado el usuario (pi) y la dirección IP (192.168.1.105) de la sesión que queremos abrir en la RaspPi. Pero ¿no sería más fácil si utilizásemos el nombre de la RaspPi en vez de una ristra de números? Pues eso es lo que vamos a realizar. Para tal fin, vamos a instalar en la RaspPi el servidor Avahi, y utilidades complementarias. Avahi permite a los programas publicar y descubrir servicios y servidores que se están ejecutando en una red local sin una configuración específica.

sudo apt-get install avahi-daemon
sudo apt-get install avahi-utils

una vez instalado, debemos ejecutar el siguiente comando:

sudo insserv avahi-daemon

de este modo, el servicio se activará a cada arranque que realicemos del RaspPi.
Con la instrucción avahi-browse -a -d local se nos mostrarán todos los dispositivos que publican sus servicios a través de ZeroConfig/Bonjour en el dominio .local.
A partir de ahora, y por mucho que cambie la IP de nuestro RaspPi, no tendremos que estar averiguando la IP que tenga en este momento. Nos dirigiremos con el nombre que tenga asignado seguido por .local. Así si el nombre continua siendo raspberrypi, en vez de la IP pondremos raspberrypi.local. Si tenemos activado un servidor Web, introduciremos en el navegador raspberrypi.local. Para acceder mediante una consola remota podremos hacerlo tecleando ssh pi@raspberrypi.local, si queremos hacer un ping, también será posible tecleando ping raspberry.local, y así con todos los servicios instalados en la RaspPi.

Cambiando el hostname

Si queremos cambiar el hostname, lo podemos hacer de dos maneras:
1) ejecutando sudo raspi-config en la consola de comandos, o bien
2) de forma manual, con el siguiente procedimiento:

sudo nano /etc/hosts
sudo nano /etc/hostname
sudo /etc/init.d/hostname.sh
sudo reboot

En los dos ficheros que editemos sustituiremos el nombre actual, raspberrypi, con el nombre por el que queramos sea reconocido nuestro RaspPi.

Para hacer que sean los cambios permanentes, actualizando el kernel con el nuevo nombre, ejecutamos sudo /etc/init.d/hostname.sh y rearrancamos el equipo con la sentencia sudo reboot.

Enlaces

- Raspian
- Raspberry Pi - Installing a RS232 Serial Port
- Raspberry Pi - RS232 Serial Interface Options (Revisit)
- Configuración de la red y acceso a Internet
- How to Setup Wi-Fi On Your Raspberry Pi via the Command Line
- What's the difference between `wpa-roam` and `wpa-conf` in the /etc/network/interfaces file?
- Setting up for WiFi Roaming with wpa
- WPA support in Debian
- Linux WPA/WPA2/IEEE 802.1X Supplicant
- RPi Advanced Setup
- Avahi
- ¿Que es avahi y para que sirve?
- Advertising Linux Services via Avahi/Bonjour
- avahi-daemon man
- Zero-Configuration Networking

Instalando por enésima vez LAMP y phpMyAdmin, pero esta vez en Raspberry

No es la primera vez, ni será la última que me propongo instalar el paquete LAMP. Pero hace ya bastantes años que con anterioridad a LAMP, instalé WAMP. Eran los tiempos en que aún utilizaba Windows y que empezaba a hacer mis pinitos con Linux. Lo que LAMP significa para el entorno Linux, WAMP lo es para Windows.
LAMP no deja de ser un acrónimo que en su origen significaba: Linux (sistema operativo) , Apache (servidor Web), MySQL (Gestor de base de datos) y PHP ( lenguaje de programación diseñado para el desarrollo web de contenido dinámico). Y si cambiamos la L inicial por la W, se entiende lo de las siglas WAMP para el entorno Windows.

El conjunto de estas 4 piezas de software hizo posible desarrollar portales dinámicos capaces de atender simultáneamente decenas de miles de usuarios en red, a un coste ridículo.
Los cuatro elementos que componen LAMP pertenecen al mundo del Software libre y de Código abierto, una garantía para el usuario de no terminar a la larga siendo cautivo de intereses abusivos.
Con el tiempo, este paradigma de programación ha ido evolucionando e integrando otros módulos pero, a pesar de todo, conservando el acrónimo. Así para la letra P se han incorporado el lenguaje Perl o Python, para la M las bases de datos MariaDB y MongoDB, elementos que han continuado siendo de Software libre y Código abierto.
Aunque existen multitud de páginas (ver en la sección de Enlaces en esta misma entrada) que nos explican con todo lujo de detalles el procedimiento que hay que seguir para instalar este conjunto de programas, voy a intentar describir el modo en el que yo lo he hecho, ampliando algunos apartados que en estas páginas no venían descritas.

Procedimiento de instalación de LAMP

Lo vamos a realizar desde un terminal remoto conectándonos por ssh a Raspberry. Para ello, indicaremos el usuario con el que queremos conectarnos y averiguaremos la dirección IP en la que dentro de nuestra red local se encuentra nuestro RaspPi, pasando a ejecutar la sentencia ssh. Introduciremos la contraseña, lo que nos permitirá conectarnos a la RaspPi de forma remota.

¿Cómo he averiguado la dirección IP? Existen múltiples posibilidades. Si nos vamos al router de nuestra red local podremos averiguar la IP del equipo que tiene por nombre raspberry. Yo utilizo Fing, porque me es más cómodo, y porque tengo la aplicación instalada en mi Android. En este caso, el RaspPi me aparece como Edimax Technology. Pero ¿cómo sé que corresponde mi adaptador WiFi con Edimax Technology? Muy sencillo. Utilizo la instrucción lsusb de Linux para ver los dispositivos USB que tengo instalado en mi RaspPi.

Y de ahí identifico el vendedor del WiFi-USB, y con la aplicación Fing saco la dirección IP, asociada al vendedor identificado. Pero, qué duda cabe, es mucho más rápido utilizar la instrucción de linux ifconfig desde el propio terminal del RaspPi.

 Lo siguiente que vamos a hacer será instalar todos estos paquetes, tecleando por el terminal remoto lo siguiente:

sudo su
apt-get update && apt-get upgrade
apt-get install apache2 php5 mysql-client mysql-server

En el proceso de instalación de mysql se nos pedirá que introduzcamos una contraseña para el usuario root que se crea por defecto, lo que deberemos hacer, guardando en nuestra memoria la que hemos utilizado. Será la única manera de poder acceder a los servicios proporcionados por mysql.
Y ahora pasemos a probar si se nos han instalado y funcionan bien. Para ello, en un navegador introduciremos la dirección a la que responderá el servidor Web recién instalado en RaspberryPi, que coincide con su dirección IP. Se nos mostrará la página por defecto, que podemos editar para dejarla a nuestra entera satisfacción:

sudo nano /var/www/index.html

Al invocar este fichero desde un navegador (fichero que se abrirá como indicábamos con anterioridad simplemente introduciendo la dirección IP del RaspPi) podremos ver la página Web:

Prueba superada. Funciona el servidor Apache Web.
Ahora pasemos a probar que nos funciona el gestor de bases de datos que hemos instalado. En este caso, vamos a utilizar un acceso remoto a través del uso del comando ssh, como ya hemos hecho en otras ocasiones. Una vez hayamos establecido el acceso remoto con nuestro RaspPi, nos conectaremos al servidor mySQL, tecleando mysql --user=root -p. Si tecleamos correctamente la contraseña que nos solicita, que debe coincidir con la que introdujimos en fase de instalación de mySQL, entraremos en el monitor mySQL a nivel de comandos, tal como se muestra en la imagen siguiente. A partir de ahí podremos hacer uso de mysql, crear bases de datos, tablas, usuarios, introducir registros y todo aquello que solemos hacer con una base de datos.

Otra prueba superada. También funciona el servidor/gestor de bases de datos mySQL. Ahora, el siguiente en discordia, el que tenemos que probar que se ha instalado y funciona a la perfección, va a ser el PHP. Con tal fin, vamos a crearnos un fichero con el editor nano y con el contenido que se muestra en la imagen siguiente. Una vez guardado, lo invocaremos desde el navegador que utilicemos.

sudo nano /var/www/test.php

Lo llamamos desde el navegador que utilicemos y, si la instalación del PHP ha sido correcta y funciona, nos aparecerá lo siguiente:

Ya tenemos los tres paquetes básicos que conforman LAMP (además del sistema operativo Linux) funcionando a la perfección. Es el momento de instalar phpMyAdmin, una utilidad muy potente que se apoya en LAMP y que nos permite gestionar la base de dato MySQL desde un navegador.

Instalación de phpMyAdmin

De nuevo vamos a hacer uso de la consola remota para instalar phpMyAdmin.

sudo apt-get install phpmyadmin

Durante la instalación se nos pedirá que indiquemos 1) el servidor Web que utilizará phpAdmin por defecto, 2) los datos para crear la base de datos asociada a phpMyAdmin para su funcionamiento, y 3) la contraseña a utilizar por el usuario root, creado al instalar mySQL. Podemos utilizar la misma contraseña que introducimos. Ya tendremos tiempo de cambiarla o de crear nuevos usuarios con contraseñas y permisos específicos. En cuanto a la base de datos, yo he dejado los valores que por defecto sugiere utilizar.
Para que phpMyAdmin sea reconocido por el servidor Apache tendremos que editar el siguiente fichero:

sudo nano /etc/apache2/apache2.conf

Nos iremos al final del fichero y añadiremos la siguiente línea:

Include /etc/phpmyadmin/apache.conf

Finalmente reaarracaremos el servidor Apache:

sudo /etc/init.d/apache2 restart

y comprobaremos que phpMyAdmin es accesible desde nuestro navegador tecleando:

<IP del RaspPi>/phpmyadmin/

apareciéndonos en nuestro navegador lo siguiente:

Introduciremos el usuario (En este momento solo podemos acceder como usuario root) y la contraseña que hayamos considerado en la instalación de phpMyAdmin, redirigiéndonos a la página principal de gestión de bases de datos de MySQL:

A partir de ahora podremos gestionar MySQL de dos maneras: 1) utilizando la consola de comandos, tecleando mysql --user=root -p,  o 2) utilizando phpMyAdmin. Dependerá de lo que realmente queramos hacer para que nos decantemos para un modo u otro de gestión.
Podríamos continuar con ejemplos de cómo importar bases de datos, crear nuevos usuarios, acceder desde una aplicación JAVA que hayamos desarrollado. Pero por hoy considero suficiente lo avanzado, dejándolo para otra entrada los ejemplos que he propuesto.
Como siempre, estoy a las sugerencias de todos los lectores, que me propongan nuevos entradas o simples ampliaciones o mejoras a estas entradas existentes.

Enlaces

- LAMP (software bundle) en Wikipedia
- Software Libre y de Código Abierto, en Wikipedia
- RPi A Simple Wheezy LAMP install
- How to install LAMP on Raspberry Pi
- Raspberry Pi : Instalando LAMP y phpMyAdmin
- Turning your Raspberry Pi into a personal web server
- A vueltas con LAMP
- Fing - Network Tools (en play store)
- Apache HTTP Server
- MySQL
- phpMyAdmin
- Tutorial – Install PhpMyAdmin on your Raspberry Pi
- lsusb

Del MCP23008 al MCP23017 (de 8 bits a 16 bits mediante el interfaz i2c)

En la entrada anterior expusimos el modo de utilizar el MCP23008 para ampliar las salidas digitales del Raspberry Pi, en 8 bits por circuito integrado. En esta nueva entrada expondremos el modo de utilizar el MCP23017 para extender aún más las entradas/salidas digitales, hasta un total de 16 bits, por MCP23017 utilizado.
No voy a partir de cero, por lo que recomiendo leerse con anterioridad la entrada de este mismo blog: Expandiendo las Entradas y Salidas Digitales de Raspberry Pi con el MCP23008.

En el montaje virtual que hemos realizado con el programa Fritzing, podemos observar dos bloques de 8 LEDs cada uno, los rojos están conectados al puerto A del circuito integrado MCP23017, y los verdes al puerto B del mismo chip. Como en la entrada del MCP23008, cada LED está serializado con una resistencia de 330 ohmios, Así evitamos un excesivo consumo de corriente, evitando que las salidas de la RaspPi no lleguen a dañarse, por un lado, y por el otro, que la propia RaspPi sea capaz de proporcionar el consumo necesario para encender a todos los LEDs simultáneamente.

Lista de materiales

EL material requerido para este montaje es el siguiente:

• 1 MCP23017 (empaquetado en DIL28)
• 16 resistencias de 330 ohmios
• 8 LEDs rojos
• 8 LEDs verdes
• conector de expansión (desarrollado por mi) para conexión de la protoboard al RaspPi. Ver entrada anterior en este blog (Conectando la Raspberry Pi a una protoboard).

Evidentemente, para realizar las pruebas que queremos hacer, no se requieren que los LEDs sean del color indicado, ni que compremos tantos LEDs. Con poner algunos en ambos puertos, podremos comprobar que el montaje funciona.
En el montaje virtual he utilizado el mismo código de colores que en el montaje realizado para el MCP23008, por lo que no voy a extenderme en ello.

Características del MCP23017

Este chip, al igual que el MCP23008, tiene un espacio de direcciones que van desde 0x20 a 0x27, en función de los valores que vayan tomando los 3 bits de direccionamiento, A2, A1 y A0. En nuestro caso, estos tres bits están puestos a CERO.

Desde un punto de vista de programación, este chip dispone de 11 pares de registros, de 8 bits cada uno, con los que gestionamos su funcionalidad, leyendo/escribiendo en ellos a través del interfaz I2C. Uno de los registros (IOCONA/B) está compartido por ambos bancos. Esto significa que lo que hagamos en uno de ellos se reflejará en el otro. Este registro común nos permite configurar el modo de operar y de organizar los 22 registros.

Para este ejemplo, vamos a configurar los 11 pares de registros en dos bloques diferenciados, uno para el puerto A, direccionables por el interfaz i2c en el rango 0x00-0x0A, y el otro para el puerto B, en el rango 0x10-0x1A. La estructura de los registros una vez configurados convenientemente es la que mostrada en la siguiente imagen.

Pero esta disposición de registro no es la que tenemos nada más alimentarlo. Al darle tensión, todos los registros se inicializan a 0x00, excepto los IODIRA/B que lo hacen a 0xff, pasando a estar todos los bits de E/S en modo entrada. Tendremos que actuar, por tanto, sobre algunos bits del doble registro IOCONA/B para configurarlo tal como queremos:

• IOCON.BANK = 1, registros agrupados por Banco A o B.
• IOCON.SEQOP = 1, lectura/escritura de un byte (no secuencial).
• IODIRA/B = 0x00, todos los bits de ambos puertos en modo salida.

Debemos tener en cuenta que, al arranque, la disposición de los registros es distinta (IOCON.BANK = 0) y el modo de operar es secuencial (IOCON.SEQOP = 0). Por tanto, al arranque, tendremos que considerar al doble registro IOCONA/B ubicado en la dirección como 0x0A/0x0B, direcciones que utilizaremos al dirigirnos a ellos por el protocolo i2c.

Los bits BANK y SEQOP corresponden a los bits B7 y B5 del registro IOCON. Por lo que para poner ambos bits a '1' escribiremos en el registro IOCON el valor 0xA0 (b10100000). Este registro se puede direccionar indistintamente tanto por el puerto A, en 0x0A, como por el puerto B, en 0x0B. Debemos tener muy en cuenta que, una vez configurado el circuito integrado del modo en el que lo hemos hecho, las direcciones de acceso al registro IOCON pasan a ser indistitamente 0x05 (IOCONA) o 0x15 (IOCONB).

El programa ejemplo mcp23017

Antes de proceder con el nuevo programa podemos hacer una prueba con los otros dos programas ejemplo que desarrollamos para el MCP23008, y comprobar que también se ejecutan. Eso sí, solo parpadeadarán los LEDs rojos, los del puerto A.

Si ejecutamos el programa mcp23017 con la opción de ayuda (-h, o también --help) se muestra la funcionalidad que se ha implementado. 

El programa permite gestionar el circuito integrado. Por ejemplo, la opción --show muestra la distribución de los registros internos, y sus valores:

Vemos claramente, con el bit IOCON.BANK activo, la distribución de los registros en dos bloques idénticos, equivalentes al bloque existente en el MCP23008, 11 pares de registros, un par direccionable entre 00h y 0Ah y el otro par entre 10h y 1Ah.  En cambio, si desactivamos el bit IOCON.BANK, el programa muestra otra distribución de registros:

En esta configuración los registros de cada bloque se van alternando, dentro de un rango de direcciones entre 00h y 15h. Podemos observar que tanto IOCONA (0Ah) como IOCONB (0Bh) contienen el mismo valor (0x28), distinto de lo que hemos grabado en él (0x29), porque el bit menos significativo, al leerlo, devuelve el valor '0'.
En la imagen anterior vemos el modo de alterar un registro que es indicando el registro (mediante la etiqueta correspondiente) al que queremos acceder y el valor a escribir.
La opción --mode nos muestra el valor del registro IOCON (A=B) o podemos alterarlo escribiendo en él un valor entre 0x00 y 0xFF (0 y 255).
FInalmente, podemos activar tres demos de activación de los LEDs con distintos patrones: random, counter y flash. En la demo random, en un bucle sin fin, escribimos dos valores aleatorios y distintos simultáneamente a ambos puertos (GPIOA y GPIOB), esperamos 'n' milisegundos, e iniciamos de nuevo el bucle. Si pulsamos <CTRL-C> abortamos el programa. La demo counter, los bits del puerto A muestran de forma binaria el valor de un contador que se incrementa cada 'n' milisegundos. El puerto B muestra de forma binaria a un contador decrementándose con la misma cadencia. Y por último, la demo flash va alternando cada 'n' milisegundos el encendido completo de cada puerto.
En Enlaces está la dirección del fichero mcp23017.rar, que una vez descomprimido se puede generar el ejecutable invocando desde un terminal de comandos make all.
Y eso es todo. En una próxima entrada hablaré de la gestión de las entradas y de las interrupciones.

Enlaces

- MCP23017/MCP23S17 datasheet
- I2C access examples
- Source Package: i2c-tools (3.1.0-2)
- i2c - dev-interface
- Using I2C from userspace in Linux
- Raspberry pi and i2c gpios
- Expandiendo las Entradas y Salidas Digitales de Raspberry Pi con el MCP23008
- Fritzing
- MCP23017.fzz
- mcp23017.rar