LiquidCrystal y Arduino

Me han traido un par de pantallas LCD de 2 filas x 40 columnas, así que me he puesto a conectarlas al arduino a ver que podía mostrar por ellas.

Lo más interesante que se me ha ocurrido es mostrar la temperatura recogida por el tmp36, así que, allá vamos.

Lo primero es estudiar un poco la pantalla.

Esta en cuestión tiene 14 pines hembra por detrás, más los dos cables de iluminación del fondo.

PIN	Descripción
1	GND
2	+5V/td>
3	En principio hay que conectarlo a +5V, pero a través de un potenciómetro. En mi caso concreto, ha funcionado conectado a GND directamente. Regula el brillo de las letras. Es por eso que un valor erróneo en esta patilla hace que no se muestre nada por la pantalla.
4	RS (bajo para command, alto para character)
5	RW (bajo para escritura, alto para lectura)
6	Enable
7-14	Pines de datos
15-16	Luz de fondo +5V y GND. En este display están en el otro extremo como cables sueltos.

El esquema de la conexión es el siguiente y también he añadido el sensor de temperatura.

La API es bastante sencilla y se puede consultar en la página de Arduino (http://arduino.cc/en/Reference/LiquidCrystal). El código es bastante sencillo, podéis consultarlo en mi cuenta de github aquí.

El resultado es el siguiente, que lejos de ser espectacular, es mejor que mostrar lecturas por un puerto Serie.

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.

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

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.

Lego(c) 8043: modelo B

Enlazo un vídeo con unas fotos del espectacular modelo B del 8043.

Hay unas fotos de algunos detalles de la cabina, las orugas, la pala y vista general.

Y un par de vídeos, uno cogiendo pinzas y depositándolas en un taper, y otro haciendo slalom entre botes de mermelada.

La calidad del vídeo y el pulso del cámara, como siempre, horribles.

RaspberryPi: GPIO

Me había prometido que este 2013 iba a escribir una entrada mínimo cada mes. Está ya bien entrado el año y de momento sólo hay una. Hoy voy a intentar ponerle remedio presentando un juguete nuevo que tengo desde hace poco más de un año y que entre pitos y flautas, no he podido exprimir todo lo que me gustaría. Estoy hablando de la RaspberryPi.

Hablar de la RaspberryPi daría para muchos blogs. Yo me voy a centrar hoy en hacer una pequeña prueba de lo que es capaz su GPIO (General Purpose Input/Output), http://elinux.org/RPi_Low-level_peripherals.

Resumiendo mucho y salvando las distancias, son 26 pines digitales para conectar cualquier cosa que nos interese. Algo parecido a un Arduino, repito, salvando las distancias. Es muy importante recalcar que son digitales, cosa que me acabo de dar cuenta, así que todos mis planes para conectar algo analógico, de momento, quedan relegados a un segundo plano.

Para programar esto hay una librería hecha en Python, https://pypi.python.org/pypi/RPi.GPIO.

Como prueba de concepto he hecho lo siguiente. Dos botones y dos leds; cuando se pulsa un botón se ilumina su led correspondiente.


El código es el siguiente, es relativamente sencillo y se explica sólo.

import RPi.GPIO as GPIO

GPIO.cleanup()

pinVerdeEntrada = 11
pinVerdeSalida = 12

pinAmarilloEntrada = 15
pinAmarilloSalida = 16

GPIO.setmode(GPIO.BOARD)

GPIO.setup(pinVerdeSalida,GPIO.OUT)
GPIO.setup(pinAmarilloSalida,GPIO.OUT)

GPIO.setup(pinVerdeEntrada,GPIO.IN,pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(pinAmarilloEntrada,GPIO.IN,pull_up_down=GPIO.PUD_DOWN)

while True:
GPIO.output( pinAmarilloSalida , GPIO.input(pinAmarilloEntrada) )
GPIO.output( pinVerdeSalida , GPIO.input(pinVerdeEntrada) )

GPIO.cleanup()

Un esquema del circuito, para más claridad, y un vídeo para los más incrédulos.

Como primera prueba de contacto, está bastante bien.

Acelerómetros

Hoy os voy a contar mis aventuras y desventuras intentando conectar un acelerómetro de tres ejes al arduino. El acelerómetro en cuestión es este.

Conectarlo al Arduino Uno, es muy sencillo. Lo que más me ha costado ha sido la soldadura de los pines, pero todo mejora con la práctica. Lo podéis ver en el siguiente esquema de Fritzing.

A continuación va el sketch que he escrito para el Arduino Uno. Como hago habitualmente, recojo los valores de la salida X,Y,Z y la envío por el puerto serie.


int pinX = A0; // a este pin analógico va conectada la patilla X
int pinY = A1; // a este pin analógico va conectada la patilla Y
int pinZ = A2; // a este pin analógico va conectada la patilla Z

int valorX = 0; // de aquí leo el valor de la patilla X
int valorY = 0; // de aquí leo el valor de la patilla Y
int valorZ = 0; // de aquí leo el valor de la patilla Z

void setup(){

// configuro las patillas como entrada
  pinMode(pinX,INPUT);
  pinMode(pinY,INPUT);
  pinMode(pinZ,INPUT);

//configuro la velocidad de escritura del puerto serie
  Serial.begin(9600);
}//setup

void loop(){
  delay(100); // pongo un pequeño retraso

// leo los valores
  valorX = analogRead( pinX );
  valorY = analogRead( pinY );
  valorZ = analogRead( pinZ );


// los escribo al puerto serie de la forma -> por ejemplo ->
// 123 123 123
  Serial.print( valorX );
  Serial.print(" ");

  Serial.print( valorY );
  Serial.print(" ");

  Serial.print( valorZ );
  Serial.print(" ");

  Serial.println();
  Serial.flush();
}//loop

La salida del puerto serie es la siguiente tras hacer algunos giros. 

Como la salida no es muy espectacular, voy a aprovechar la salida por el puerto serie para mostar unas gráficas con Matlab. La salida es la siguiente.

Cuando la gráfica está en reposo el sensor no registra aceleración. En este video de bastante mala calidad todo sea dicho, se puede ver el sensor en movimiento. Sólo me centro en el eje X

Si el "mando" queda quieto, la gráfica es una constante. Si giramos hacia un lado vemos que crece o decrece según el sentido del giro.