Un Arduino UNO
	Un PCF8575
	Un módulo de 16 relés

¿Te faltan pines en tu Arduino para ese proyecto que tienes en mente? ¿Te gustaría tener mas disponibles para controlar entradas y salidas digitales? Pues si es así, has venido al sitio adecuado. Sigue leyendo y veras que añadir pines a nuestros micro controladores es mucho más fácil de lo que creías.

Normalmente los pines que tienen disponibles un Arduino UNO o un ESP32 son suficientes para hacer tutoriales o pequeños inventos, pero en cuanto empieces a aceptar pedidos de clientes el número de pines disponible se queda corto con mucha más rapidez de la que te gustaría. Si. Ya sé que el Arduino MEGA o DUE, tiene bastantes más pines disponibles, pero, aun así, al final pueden no ser suficientes.

Aumentar el número de pines de entrada o salida acaba siendo una necesidad irrenunciable y el sistema de añadir más Arduinos UNO para usar sus pines acaba siendo muy poco práctico por lo que se impone alguna otra solución.

Y como suelo deciros, si a ti se te ha ocurrido que estaría bien tener un chip que tuviera múltiples salidas adicionales que pudiéramos controlar cómodamente con nuestros Arduinos, ya hay algunos listos que han desarrollado chips con estas prestaciones para ver si son capaces de sacarnos la pasta con ellos y al final basta con mirar que nos ofrece el mercado, porque aunque te parezca mentira y seas el más listo de tu pueblo, no somos los únicos humanos inteligentes y hay gente que ya se ha currado el tema por nosotros y basta con tirar de billetera (En este caso muy poca pasta)

Por eso me ha parecido sensato, dedicar algunas sesiones a ver cómo usar estos chips que nos resuelven la papeleta cuando el número de pines disponibles empieza a crecer más allá de lo que normalmente necesitamos en Arduino. En esta sesión vamos a hablar del chip integrado PCF8575, de cómo conectarlo a nuestros Arduinos y de cómo programarlo para añadir 16 puertas adicionales de entradas salidas con un mínimo de complicaciones (Mas allá de tirar 16 cables adicionales)

El PCF8575 es un expansor de puertas de entrada / salida, controlado por I2C que permite aumentar el número de pines digitales disponibles en la mayoría de los controladores actuales, añadiendo 16 puertas digitales bidireccionales.

Para los amigos de Arduino, normalmente lo compraremos en forma de Breakout Board, para poder manejarlo de forma cómoda como es el caso de la tarjeta que os muestro encima y que incorpora el Integrado PCF8575 (Cuya data sheet tienes aquí).

Sus características principales son:[one-fourth]  [/one-fourth][three-fourth last][margin value=»5″ /][fancy-ul style=»rounded-tick»] [three-fourth last][margin value=»5″ /][fancy-ul style=»rounded-tick»]

• Expansor I2C
• 16 bits de entrada / salida
• 400 Khz bus I2C
• Dirección I2C mediante 3 pines hardware (permite hasta 8 unidades en el mismo bus I2C)
• Latched Outputs.

Para que podamos usarlo con Arduinos y similares tenemos que empezar como siempre, descargando la librería correspondiente que puedes encontrar aquí.

Pincha en code y luego en descargar el zip y podrás instalar la librería como siempre con tu Arduino (\\Programa\Incluir Librería\Añadir biblioteca ZIP).

En mi caso y como ejemplo voy a usar un módulo de 16 relés, para ilustrar el manejo de 16 Salidas digitales usando solo las dos líneas de control del bus I2C, y veréis que es bastante fácil, aunque lo tirar 16 cables hasta el expansor es un asco, vosotros podéis usar las que queráis.

De hecho, en la imagen de la conexión solo voy a pintar 8 líneas de conexión porque si pusiera todo el resultado sería un asco de muy difícil observación por lo que me permitiré esta pequeña licencia (Y por pura vagancia, claro)

Aquí tenéis el esquema de las conexiones:

Fíjate, que solo usamos dos líneas de Arduino que corresponden a los pines I2C (A5 y A6), además de Vcc y GND para alimentar el circuito. Pero en la imagen ves que he enviado 8 líneas de control al módulo de relés, que las que realmente controlan el estado de los mismos desde el expansor a través de la ordenes que envía Arduino desde el I2C.

La forma de controlar las salidas del expansor PCF8575 es de la más simple si estas habituado a la sintaxis de Arduino.  Tenemos que incluir la librería que hemos descargado más arriba:

#include "PCF8575.h"

Después, definimos una instancia del expansor, donde vas a ver que incluimos la dirección I2C por defecto del mismo (0x20):

PCF8575 EXT(0x20);

Y ya estamos listos para usar los pines extras. La librería nos define una serie de constantes para su uso, en especial referidos a los pines de salida o entrada del expansor, del mismo modo que los de Arduino se numeran de pin 0 al pin 13, los del expansor se numeran de P0 a P15, de forma que podemos declarar el pin 12 como salida, y el 10 como entrada en el setup, así:

EXT.pinMode(12, OUTPUT);
EXT.pinMode(10, INPUT);

Para después inicializar la instancia:

EXT.begin();

Y eso es todo, ya podemos usar los pines como si fueran de los habituales de Arduino. Por ejemplo, podemos leer el pin 10 a una variable bool, y asignar la salida 12:

bool V10 = EXT.digitalRead(10);
EXT.digitalWrite(12, LOW);

Es decir, exactamente igual que cualquier otro pin digital de tu Arduino, con la salvedad de preceder el digitalRead o digitalWrite por el nombre del objeto PCF8575 que hayas instanciado, y no hay mas.

Como ejemplo práctico voy a usar un programa con un Arduino UNO, en el que haremos una secuencia de encendido de los 16 relés de un módulo de 16 entradas, que controlaremos desde los pines de salida del PCF8575 directamente

Para ello vamos a hacer un programa que vaya recorriendo un ciclo de activación de los relés 0 al 15, desactivando el relé al pasar al siguiente.

Para ello voy a hacer una pequeña trampa que consiste, que, en lugar de usar las descripciones de los pines, que os indicaba arriba como P0, P1, P2…. P15, usare la nomenclatura 0,1,2, …15 porque me resulta mucho más adecuada al programa para poder hacer un for que los vaya gobernando.

El programa quedaría como esto, poco más o menos:

#include "PCF8575.h"
PCF8575 EXT(0x20);

Empezamos incluyendo la librería correspondiente y después instanciamos un objeto del tipo PCF8575 (Que es una manera retorcida de decir que creamos un objeto de ese tipo). Como voy a gobernar un modulo externo de 16 relés con solo los 2 pines I2C de Arduino, mi intención es hacer un bucle donde se vayan activando y desactivando en secuencia con un tiempo de pausa entre cada operación, por eso, vamos a definir el tiempo de esa pausa:

int pause = 400;

Pasamos al Setup para hacer lo habitual e inicializar el objeto que acabamos de crear:

EXT.begin();

Y ahora nos toca programar las 16 puertas que vamos a usar como salidas, y como soy terriblemente vago no pienso hacerlo de una en una, sino que usaré un bucle for (2 líneas, no 16):

for (int i=0; i<16; i++)
     EXT.pinMode(i, OUTPUT);

Con esto vamos a hacer otro par de bucles en loop que active y desactiven los 16 relés en orden (Vamos, como un blinkig led , pero con relés)

for (int i=0; i<16; i++)
   { Serial.println(i);
     EXT.digitalWrite(i, LOW);
     delay (pause);
     EXT.digitalWrite(i, HIGH);
     delay (pause);
   }

Recuerda que las definiciones de P0 a P15 corresponden con el rango de 0 a 15, y lo usamos para contar el for, eso es todo. Aquí os dejo el programa completo en descarga:

PCF8575_External_IO

Y este es el video donde se muestra el resultado final para que veas que no te engaño: