Tenía por ahí perdido un buzzer y hoy me he puesto a conectarlo al Arduino. En mi cabeza sonaban músicas de 007 y la del Monkey Island. Nada más lejos de la realidad.
Primero, un poquito de documentación, que se puede encontrar en los dos siguientes enlaces de la playgroun de arduino
El cableado es tan sencillo que no voy a hacer esquema. Se conecta el cable negro a GND y el rojo a la salida digital que tengamos en el código.
En el tutorial de melodía hay un código de ejemplo, que es en el que me he basado para hacer el mío. Que se puede encontrar aquí, en mi cuenta de github.
Y a continuación un vídeo. Con la escala musical. El sonido es del propio Arduino+Buzzer, no es de ningún gato callejero agonizando. Creo que no he comprado un buen buzzer, porque los videos que hay en youtube son espectaculares.
Hoy voy a trastear un poco con el arduino y un shift register.
Este integrado, hablando muy por encima, nos transforma una entrada serie en una salida paralela. En este ejemplo concreto, a través de una patilla del integrado le pasamos en serie 8 bits, sincronizando con una patilla de reloj. Una vez que el integrado tiene estos ocho valores, le avisamos, por otra patilla, que saque estos bits, por las ocho salidas.
Es decir, si pasamos el siguiente byte, en bits: 01010000, la segunda y la cuatra patilla de salida del integrado tendrán un valor HIGH, mientras que el resto, estarán a LOW.
Estos integrados se usan para la mencionada conversión serie-paralelo, o en casos en el que número de patillas de salida de nuestro controlador, no es suficiente. En este caso concreto, con tres patillas (datos,reloj y "latch") tenemos ocho salidas. La mejora es evidente. También hay integrados de más salidas, con lo que ganancia es mayor.
Voy a mostrar el funcionamiento básico de este integrado con una tira de ocho leds haciendo el efecto "coche fántástico".
El esquema de conexión es el siguiente, y aunque quede bonito, es un poco engorroso de hacer, por todo lo que hay que conectar en tan poco espacio. Por alguna extraña razón, la salida del integrado tiene que ir la resistencia y luego el led. Si uso el led y luego la resistencia, no se iluminan. ¿Alguien me ilumina a mí y me explica porqué ?
El integrado elegido es el 74HC595, y podéis encontrar el datasheet aquí . Un tutorial de AdaFruit muy similar a este lo podéis encontrar aquí. . Que ellos han puesto un montón de dibujico y cosicas, y se entiende muy bien, sobre todo la parte del latch.
El código para el Arduino lo podéis encontrar aquí. Esta vez he intentado que esté un poco más comentado.
Y un pequeño vídeo, donde se puede ver todo en acción.
Y un kickstarter, http://www.bareconductive.com/, que vendrá el próximo año con el sello Arduino at Heart, que tiene infinitas posibilidades en cuanto al diseño de interfaces.
¿Quién no ha oído alguna vez la expresión, si no lo tienes lo pintas? Pues eso es precisamente lo que voy a intentar empezar a esbozar hoy. Ya no hacen falta switch buttons, cuyas patillas nunca encajan o se te queda la marca del círculo en el dedo índice. Ahora podemos pintar, literalmente pintar, cualquier interfaz y configurar su comportamiento: contacto o proximidad.
Podemos pintar teclados en mesas en lugar de tener todo un dispositivo, pintar un despertador en la pared al lado de la cama y que al pasar la mano se apague (y tener una RaspberryPi que controle hora, música y altavoces en el otro extremo), pintar interruptores en cualquier lugar, detectores de proximidad, pistas de DDR, instrumentos electrónicos, baldosas ...
Una vez hecha la introducción hay que ver un poco en qué se basa todo esto. La primera vez que lo vi, me pareció brujería. La magia es en realidad es un sensor capacitivo. Una muy breve introducción al mismo la podéis encontrar aquí.
Un punto muy interesante es que para probar esto en un Arduino, no hace falta nada más que unos trozos de papel de aluminio. La documentación de la librería de Arduino está en esta dirección (http://playground.arduino.cc//Main/CapacitiveSensor), y da una muy buena introducción a la capacitividad.
Al final hay un ejemplo bastante sencillo de reproducir, que es lo que he hecho yo en el siguiente esquema.
Se detecta que se está tocando cada trozo de papel de aluminio y se ilumina su led correspondiente. No es tan espectacular como el piano, pero para la primera prueba es más que suficiente.
El código lo podéis descargar de aquí y he intentado que esté bien documentado. Lo más complicado es ajustar el número de mediciones y valor a partir del cual se detecta que se está pulsando algo. Con la salida por el puerto serie de los valores leídos.
En este ejemplo sólo voy a probar el contacto total entre sensor y cuerpo humano. Con resistencias de más valor, el próximo paso será la cercanía y no el contacto.
Y como siempre al final, un vídeo.
Ajustar los valores para que detecte varias pulsaciones a la vez ha sido un poco de prueba y error. Tal vez con otros valores de resistencias y/o añadiendo un condensador como indican en el playground, mejore/estabilice las lecturas.
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.
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.
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.
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.
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.
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.
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.
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
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.
