Raspi y entrada analógica (PCF8591)

Una de las “carencias” de la tarjeta Raspberry Pi es, sin duda, la falta de una entrada analógica (o que permita la conversión de la misma), tal y como existen en otros dispositivos (Arduino o Cubieboard sin ir más lejos).

Para paliar esto os comentamos hoy la posibilidad de añadir mediante una pequeña circuitería la conversión A/D a muestra Raspi. Para ello haremos uso del bus I2C que esta incorpora y de un chip encargado de la “misión” : el PCF8591.El chip PCF8591 realiza la conversión A/D con una resolución de 8 bits y mediante el método de aproximaciones sucesivas.

¡Vamos allá!

Para poner en marcha este chip podemos optar por localizarlo en el mercado o bien optar por un módulo pre-configurado que lo incorpora. Podemos encontrar este módulo en Webtronika . Este módulo hace uso del chip PCF8591 de la firma NXP (antigua Philips) e incorpora 4 entradas analógicas. También incorpora varios dispositivos analógicos pre-conectados y configurables vía “jumpers”. El módulo  viene acompañado del cable (tipo Dupont) de 4 hilos -  preciso para su conexionado a patillas de placa – sin necesidad de soldadura.

Lo comentado en este artículo (tanto a nivel hardware como software) puede aplicarse tanto al chip como al módulo que lo incorpora.

En esencia, lo que comentamos a continuación es:

- Descripción básica del circuito PCF8591.
– Pre-configuración software de la Raspberry Pi.
– Implementación y cableado del módulo.
– Primeras pruebas sobre el sistema.
– Programa Python de manejo del módulo.

Nota: el programa python puede descargarse desde nuestra Web

- Descripción básica del circuito PCF8591 -

El circuito PCF8591 incorpora 4 entradas analógicas y una salida gestionables remotamente mediante bus serie I2C. Opera con un bajo consumo (8-bits CMOS) y puede ser direccionado mediante 3 patillas al efecto (en el módulo estas ya se han pre-ajustado). Internamente el chip se encarga de multiplexar la información que captura en cada entrada y almacenarla para su lectura vía bus I2C.

Si utilizamos el módulo comentado vemos que el conexionado del mismo responde a este esquema …

Además, el módulo incorpora 3 sensores de test con los que podemos realizar de forma inmediata las primeras pruebas. En concreto, podemos “convertir” señales analógicas provenientes de un sensor de LUZ (LDR en modo divisor), temperatura (también en modo divisor de señal) y un potenciómetro que nos permitira “jugar” con valores en la entrada analógica a la que este está conectado. Una de las patillas (AIN2) no está usada por los sensores montados el módulo. Si queremos utilizar (o no) las señales de test instaladas tan solo tendremos que dejar puesto (o quitar) el “jumper” que utiliza cada señal. En este esquema podemos entenderlo algo mejor:

- Pre-configuración software de la Raspberry Pi  -

Para poder manejar el chip (o el módulo) desde la Raspberry Pi hemos de efectuar ciertas comprobaciones y/o instalaciones previas.
En primer lugar hemos de verificar que el fichero /etc/modprobe.d/raspi-blacklist.confcontiene algo similar a esto

podemos editarlo – si fuera preciso – mediante

sudo nano /etc/modprobe.d/raspi-blacklist.conf

despues hemos de comprobar que el fichero /etc/modules contiene estas 2 líneas al final del mismo

si no las tuviera lo editaremos con

sudo nano /etc/modules

ahora hemos de instalar varios componentes para el manejo del bus I2C.

Instalamos

sudo apt-get install python-smbus

sudo apt-get install i2c-tools    (no es esencial)

sudo modprobe i2c-dev

sudo modprobe i2c-bcm2708

finalmente reiniciamos la Raspbery

- Implementación y cableado del módulo -

Como siempre, efectuaremos el cableado entre el módulo y la Raspberry Pi (utilizamos el cable que este incorpora) de forma cuidadosa y verificando las conexiones descritas en este esquema. Vemos que la tensión de entrada para el módulo es de 3,3 V. razón por la que la referencia para la conversión AD sera de este nivel (¡ no de 5 V !).

Una vez instalado el software preciso y realizado el cableado efectuaremos las primeras pruebas.

- Primeras pruebas sobre el sistema -

Cada chip que conectemos al bus I2C estará direccionado adecuadamente mediante los 3 bits de direccionamiento que podemos pre-configurar y los bits fijados por el fabricante.

En el caso que nos ocupa – el módulo conversor AD – el chip PCF8591 se ha direccionado poniendo los bits A0, A1 y A2 a masa, con lo que su valor es 0 y, por tanto, el chip PCF8591 queda en la dirección 0×48. Los bits activos son el 4 (valor 8) y el 7 (valor 64), por lo que la dirección sería 64+8 = 72 (0×48).

Si hemos instalado las herramientas I2C comentadas, con el módulo conectado a la placa y energizado (el LED rojo D2 se encenderá) efectuamos desde un terminal el test siguiente:

ejecutamos

sudo i2cdetect 1

y obtendremos algo como esto

Nota: dependiendo de la versión de nuestra Raspberry puede ser preciso usar el comando como sudo i2cdetect 0

- Programa Python de manejo del módulo -

Para que los lectores puedan probar de una forma inmediata las bondades del módulo conversor ADC (o del chip PCF8591 si se direcciona en forma similar) hemos preparado una pequeña utilidad en lenguaje Python. Es este …

# ============================================= # -------- Programa para chip PCF8591 -------- # --------------------------------------------- # - (c) J.C.G.P. - DIVERTEKA / Webtronika 2013 # =============================================   #!/usr/bin/python import curses import smbus import time   # - Carga de modulo para I2C ----------------------------------- miADC = smbus.SMBus(1)   # - Rutina de lectura del valor ADC ----------------------------- # X = canal a leer (1 a 4) # --------------------------------------------------------------- def leeINPUT(X): # Configuro registro de control para lectura de canal X miADC.write_byte_data(0x48, (0x40 + X),X) time.sleep(0.2) lectura = miADC.read_byte(0x48) # read A/D return lectura # --------------------------------------------------------------- # ############################################################### # - PROGRAMA PRINCIPAL --- Usa curses para salida a pantalla ---- # ############################################################### # --------------------------------------------------------------- stdscr = curses.initscr() curses.cbreak() curses.start_color() curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE) hsize = curses.COLS vsize = curses.LINES curses.curs_set(0) curses.noecho stdscr.border(0) stdscr.keypad(1) stdscr.nodelay(1) try: stdscr.bkgd(curses.color_pair(1)) while True: # Rutina principal del programa char = stdscr.getch() if (char == 81 or char == 113): # Tecla Q/q break else: an1 = leeINPUT(1) an2 = leeINPUT(2) an3 = leeINPUT(3) an4 = leeINPUT(4) stdscr.addstr(vsize/6, (hsize/2)-18,"Lecturas analogicas con chip PCF8591") nON = an1 / 10 nOFF = 25 - nON stdscr.addstr((vsize/5)+3, (hsize/2)- 28,"Entrada AIN0 (Luz = " + str(an1).rjust(3) +') ' +'=' * nON + ' ' * nOFF) nON = an2 / 10 nOFF = 25 - nON stdscr.addstr((vsize/5)+5, (hsize/2)- 28,"Entrada AIN1 (Temp. = " + str(an2).rjust(3) +') ' +'=' * nON + ' ' * nOFF) nON = an3 / 10 nOFF = 25 - nON stdscr.addstr((vsize/5)+7, (hsize/2)- 28,"Entrada AIN2 (Libre = " + str(an3).rjust(3) +') ' +'=' * nON + ' ' * nOFF) nON = an4 / 10 nOFF = 25 - nON stdscr.addstr((vsize/5)+9, (hsize/2)- 28,"Entrada AIN3 (Poten.= " + str(an4).rjust(3) +') ' +'=' * nON + ' ' * nOFF) stdscr.addstr(vsize-4, (hsize/2)- 18," Pulsa [Q] para salir") stdscr.refresh() finally: curses.nocbreak() stdscr.keypad(0) curses.echo() curses.endwin()

Para utilizar este programa tendremos que tener el módulo PCF8591 a la Raspberry Pi y, desde un terminal, ejecutar:

sudo python adc.py

Nota: dependiendo de la versión (revisión) de nuestra Raspberry es posible que la línea

miADC = smbus.SMBus(1)

haya de ser cambiada por

miADC = smbus.SMBus(0)

A DIVERTIRSE