sábado, 12 de octubre de 2013

Conexión i2c entre Arduino y RaspberryPi

Siguiendo la fiebre de conectar cosas entre si, os muestro a continuación cómo he conectado una RaspberryPi y un Arduino a través del protocolo i2c

Como la RaspberryPi funciona a 3.3V y el arduino a 5V, he utilizado un conversor de niveles lógicos. Concretamente, este modelo. La gente de quick2wire comenta que también se puede hacer sin este conversor. Yo he hecho la prueba y también ha funcionado, pero no sé a largo plazo que efectos puede tener sobre la RaspberryPi.

A continuación, el cableado, intentándolo dejar todo claro, creo que está un poco liado.


La conexión con el conversor es sencilla. Tiene dos partes, una para High Voltage (como la canción de Electric Six), donde conectamos tierra y 3.3 de la rpi, y otra para el Low Voltage, donde conectamos tierra y 5 del Arduino.

Luego también conecto las dos patillas del bus i2c. SDA, es el pin analógico 4 del arduino con el header 3 de la rpi. Y el SCL, es el pin analógico 5 del arduino, con el header 5 de la raspberry.

Nada más conectar todo y dejando el arduino corriendo, sin ejecutar nada en la rpi, ya se puede ver que hay algo conectado al i2c de la rpi.


pi@raspberrypi2 ~/trastear/i2c $ sudo i2cdetect -y 0

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f

00:          -- -- -- -- -- 08 -- -- -- -- -- -- --

10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

70: -- -- -- -- -- -- -- --



Una vez hecho esto, adjunto el código para la Raspberry, que parece ser que sólo puede hacer de maestro, y el código para el arduino, que hará de esclavo.

La documentación del i2c de quick2wire está aquí y es bastante mala, todo hay que decirlo. Y para activar el i2c en la RaspberryPi, que viene desactivado por defecto, aquí. Esto si viene bien explicado.

Y para los más incrédulos, un vídeo.



Acelerómetro con Raspberry PI

Hace algunos meses conecté un acelerómetro adxl335 a las entradas análogicas del Arduino. Expongo ahora como he conectado el mismo acelerómetro a una Raspberry Pi a través del conversor analógico-digital MCP3008.

Una vez entendido el cableado de la conexión con el TMP36, es bastante sencillo.



Y el código en github. Es exactamente igual a la conexión con el TMP.

miércoles, 2 de octubre de 2013

Raspberry Pi y sensores de temperatura

Aquí nos encontramos con la primera dificultad, y es que mientras que la salida del sensor es analógica, el GPIO de la RaspberryPi, sólo tiene entradas digitales. Esto tiene fácil solución si se usa un ADC (conversor analógico-digital), en este caso, el MCP3800.

Este conversor, nos permite conectar hasta 8 dispositivos analógicos y leer el valor a partir de un protocolo llamado SPI (Serial Port Interface). Y más concretamente utilizado la técnica del 'bit banging'. Aunque hay alguna librería como spi-dev que lo debería de hacer más sencillo, lo dejo como mejora.

Hay un par de tutoriales de este sensor y conversor con la RaspberryPi en AdaFruit (http://learn.adafruit.com/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi/overview, http://learn.adafruit.com/send-raspberry-pi-data-to-cosm/overview). Y si necesitáis el datasheet del MCP3800, lo buscáis en google, que para eso está.

El cableado es un poco más complejo.


El código, como no podía ser de otra manera si hay una RaspberryPi rondando, en Python. En el artículo de Adafruit tenéis uno que funciona perfectamente en 2.7 y además añade una manera de subir los resultados a internet.

Como el enlace de COSM no me ha funcionado, y prefiero python 3, pues he utilizado la librería gpio de quick2wire y este es el resultado. Lo más complicado es el bit banging del protocolo spi. No voy a comentar el código de adafruit, que ya está bien explicado en su web, ni la parte del bit banging, porque se escapa un poco a mis habilidades como literato.

Enlace a código con python 3 y librería quick2wire de la lectura de un tmp36.

Algún lector avispado, se habrá dado cuenta que la conversión que se está haciendo de milivoltios a grados centígrados no es la misma que hacíamos con el arduino. Pues yo tampoco sé la razón.

Arduino y sensores de temperatura

Esta parte es bastante sencilla y me he basado en este tutorial de AdaFruit (http://learn.adafruit.com/tmp36-temperature-sensor)

El cableado, sencillo donde los haya, es el siguiente.



Y el código para el Arduino. También bastante sencillo. Lo más complido aquí es calcular la temperatura en ºC, a partir del voltage que nos devuelve la patilla central. El datasheet del sensor y el tutorial de AdaFruit nos dan la siguiente fórmula.

Este es el enlace al código para el Arduino. A partir de ahora para comodidad y profesionalidad, lo voy a subir a una cuenta en github.

Explico a continuación las fórmulas.

Voltage en el pin en Mili Voltios = valor del pin Analógico de Arduino * 5000 / 1024

5000 es porque yo utilizo un Arduino UNO, que funciona a 5V. Si utilizara otro Arduino que funcione a 3.3V, hay que utilizar el valor 3300. O como se verá más adelante, una Raspberry Pi, que funciona a 3.3.

Lo que hace esta fórmula es normalizar el valor 0-1023 que devuelve el pin a un valor 0-5000 mV que son 5 V. Lo de convertir a mili Voltios es porque el datasheet del sensor nos da la relación entre miliVoltios y ºC mediante la siguiente fórmula.

Temperatura en ºC = (mili Voltios - 500) / 10

Disculpad si he cometido algún error con la nomenclatura de las magnitudes físicas. Estoy abierto a correcciones/sugerencias/comentarios.

Las lecturas no son del todo estables como he podido comprobar en esta salida del puerto serie. Sobre estabilizar las lecturas, hay cientos de cosas muy profesionales si se busca en google. Como no pretendo, de momento, controlar ningún proceso crítico con esto, quedo contento con el experimento.

------------------------------
Valor entrada analógica: 154
mV: 751.95
Grados ºC: 25.20
------------------------------
Valor entrada analógica: 157
mV: 766.60
Grados ºC: 26.66
------------------------------
Valor entrada analógica: 152
mV: 742.19
Grados ºC: 24.22
------------------------------
Valor entrada analógica: 156
mV: 761.72
Grados ºC: 26.17
------------------------------
Valor entrada analógica: 152
mV: 742.19
Grados ºC: 24.22
------------------------------

martes, 1 de octubre de 2013

Sensores de temperatura

Desde que mi habitación da al norte y un árbol me tapa el poco sol que pudiera llegar, me he vuelto un poco paranóico con el tema frio/calor. Con la excusa de la temperatura, voy a jugar un poco con este sensor. Es un sensor de temperatura que por la patilla (sin doble sentido, aunque de precio muy reducido) central, nos da la temperatura que registra.


Este artículo va a tener dos partes. En la primera se va a conectar a un Arduino y se mostrará su lectura por la consola del puerto serie. La segunda, y con algo más de chicha, voy a conectar el tmp36 a una Raspberry Pi.

Y tras esta espectacular entrada, que parece más bien hecha para rellenar que para otra cosa, manos a la obra.