Archivo de la etiqueta: proyectos

Teclado I2C con chip PCF8574 y Arduino


En la anterior entrada he hablado de como convertir una pantalla LCD para comunicarse con nuestras placas Arduino a través del protocolo de comunicación I2C, la cual podéis ver aquí. Entonces decidí investigar acerca de como realizar un teclado I2C para poder trabajar con nuestro Arduino sin necesidad de utilizar un montón de pines digitales, que podremos utilizar para otros menesteres, y aunque no he encontrado mucha información he conseguido obtener un teclado I2C que funciona perfectamente para nuestros proyectos, pasando de emplear 8 pines digitales a sólo 2 pines de comunicación (SDA y SCL en nuestro Arduino). El teclado que he empleado para las pruebas ha sido un teclado de membrana muy económico como el de la imagen.

KEY4X4M01

Para ello usaremos el integrado PCF8574 y como hemos comentado anteriormente hay que tener en cuenta que se pueden encontrar dos tipos de integrados PCF8574, uno el PCF8574N y otro el PCF8574A, que se diferencian en el valor de la dirección del dispositivo que podemos asignar, aumentando así las posibilidades a la hora de crear más dispositivos I2C para trabajar con nuestras placas Arduino, os dejo unas imagenes de como poder seleccionar la dirección I2C para el dispositivo en cada uno de los integrados arriba mencionados y una tabla de referencia de direcciones para el PCF8574N según se conecten los pines A0, A1 y A2.

Direcciones diferentes PCF8574

Tabla referencia Direcciones I2C

En esta imagen podéis ver como cablear todos los componentes para poder convertir vuestro teclado matricial en un teclado I2C con el que poder trabajar perfectamente desde vuestro Arduino (yo he usado el integrado PCF8574N para las pruebas):

Conexion teclado a pcf8574

NOTA: Yo he optado por conectar los pines A0, A1 y A2 del PCF8574N a tierra, para así obtener como dirección del dispositivo I2C (en este caso el teclado de membrana) 0×20 (en valor hexadecimal).

Os pongo también el esquemático realizado en Eagle por si alguien lo entiende mejor:

Esquematico eagle Teclado I2C PCF8574

El ejemplo que he usado para realizar las pruebas es el siguiente:

/*Probando Teclado I2C con integrado PCF8574 y Arduino UNO*/

//Añadimos las librerias
#include <Wire.h>
#include <Keypad_I2C.h>
#include <Keypad.h>

//Indicamos el numero de filas
const byte FILAS = 4;
//Indicamos el numero de columnas
const byte COLUMNAS = 4; 

//Indicamos como queremos que nos devuelva el valor de la tecla pulsada
char teclas[FILAS][COLUMNAS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};

//Indicamos los pines de configuracion de filas y columnas
byte PinsFilas[FILAS] = {0,1,2,3}; 
byte PinsColumnas[COLUMNAS] = {4,5,6,7};

//Indicamos la direccion I2C de nuestro dispositivo, se puede modificar dependiendo de las conexiones A0,A1 y A2
//Mirar datasheet PCF8574
int i2caddress = 0x20;

Keypad_I2C kpd = Keypad_I2C( makeKeymap(teclas), PinsFilas, PinsColumnas, FILAS, COLUMNAS, i2caddress );

void setup()
{
  Serial.begin(9600); //Iniciamos configuracion serie para ver las teclas pulsadas
  kpd.begin();  //Iniciamos el teclado
}

void loop()
{
  char tecla = kpd.getKey();  //Asignamos el valor devuelto por el teclado a la variable tecla
  //Mostramos el valor por el monitor serie
  if (tecla)
  {
    Serial.println(tecla);
  }
}

Aquí podéis ver una imagen del circuito montado y conectado al Arduino y además un ejemplo de la pulsación de las teclas a través del monitor Serie:

IMAG0028

Monitor Serie Teclado I2C PCF8574

Como siempre os dejo los archivos para que podáis hacer funcionar perfectamente este ejemplo: https://www.mediafire.com/?28b26tzosl6hrxi

Espero que os sirva de ayuda la entrada!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Convertir una pantalla LCD a I2C con el chip PCF8574


En esta entrada os voy a enseñar como poder adaptar vuestras pantallas LCD a una pantalla que se comunique a través del protocolo I2C (empleando sólo dos pines SDA y SCL). En una anterior entrada hemos hablado de un módulo que permite realizar esta operación de manera sencilla y económica, pero y si queremos montarnos nuestro propio módulo, o asignar diferentes direcciones a dispositivos para nuestros proyectos porque hay varios dispositivos con la misma dirección y no podemos trabajar con ambos. Todo esto es muy sencillo gracias al integrado PCF8574, que es un expansor de entradas/salidas compatible con la mayoría de los microcontroladores existentes, que nos permite convertir una comunicación en paralelo con un dispositivo a una comunicación I2C, además de poder indicar la dirección que queremos asignar a este dispositivo I2C.

Aquí podéis ver el pinout del integrado PCF8574N:

Pinout PCF8574

Hay que tener en cuenta que se pueden encontrar dos tipos de integrados PCF8574, uno el PCF8574N y otro el PCF8574A, que se diferencian en el valor de la dirección del dispositivo que podemos asignar, aumentando así las posibilidades a la hora de crear más dispositivos I2C para trabajar con nuestras placas Arduino, os dejo unas imagenes de como poder seleccionar la dirección I2C para el dispositivo en cada uno de los integrados arriba mencionados y una tabla de referencia de direcciones para el PCF8574N según se conecten los pines A0, A1 y A2.

Direcciones diferentes PCF8574

Tabla referencia Direcciones I2C

Ahora vamos a ver como cablear nuestras pantalla LCD al integrado PCF8574 para conseguir una comunicación I2C entre nuestro Arduino y la pantalla LCD:

LCD I2C PCF8574

NOTA: Faltan por conectar las resistencias de pullup de 4.7K en las líneas SDA y SCL que van a nuestro Arduino.

Yo he optado por conectar los pines A0, A1 y A2 del PCF8574 a tierra, para así obtener como dirección del dispositivo I2C (en este caso la pantalla LCD) 0x20 (en valor hexadecimal).

Os pongo también el esquemático en Eagle por si alguien lo entiende mejor que con el Fritzing:

Esquemático eagle PCF8574 LCD

Os pongo el ejemplo que he usado para realizar las pruebas básicas de funcionamiento y con el que no he tenido ningún problema:

#include <Wire.h> 
#include <LCD_I2C.h>

LCD_I2C lcd(0x20,16,2);  //Indicamos la dirección de la pantalla LCD 0x20 y el numero de columnas y filas 16*2

void setup()
{
  lcd.init(); //Inicializamos la pantalla LCD
  lcd.backlight();  //Activamos la iluminación de la pantalla
  //lcd.noBacklight(); //Desactivamos la iluminación de la pantalla
  lcd.setCursor(1,0);
  lcd.print("Visitanos en:");  //Imprimimos un mensaje
  lcd.setCursor(1,1);
  lcd.print("Taller Arduino");
}

void loop()
{
}

Aquí podéis ver el resultado:

IMAG0021

Para conseguir que funcionara todo correctamente he tenido que modificar la librería LyquidCrystal_I2C, así que en este archivo comprimido va una librería con la que funciona perfectamente la pantalla LCD, así como el datasheet del PCF8574 y el archivo Fritzing: https://www.mediafire.com/?3tcm58ig07a2eb5

Espero que os sirva de ayuda la entrada!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Sensor de temperatura LM35 y arduino


Vamos a ver como poder realizar mediciones de temperatura con nuestro Arduino y el sensor LM35. Dicho sensor es un sensor analógico de la casa Texas Instruments, que nos permite realizar medidas de temperatura de una forma bastante precisa a través de las entradas analógicas de nuestro Arduino (pines A0-A5) sin necesidad de emplear ninguna librería especifica para su programación.

Encapsulados LM35

LM35

 

 

 

 

 

 

 

 

 

 

Como se puede ver es un sensor que presenta únicamente 3 pines (VCC, GND y Data), por ello su conexión es muy sencilla. Además presenta las siguientes características:

  • Está calibrado directamente en grados Celsius.
  • Rango de medición de -55ºC a 150ºC.
  • La tensión de salida es proporcional a la temperatura. Esto quiere decir que 1ºC equivale a 10mV.
  • Presenta una precisión garantizada de 0.5ºC a 25ºC.
  • Presenta un rango de alimentación entre 4 y 30V.
  • Presenta baja impedancia de salida.
  • Presenta baja corriente de alimentación (60uA).
  • No necesita de circuitos adicionales para su calibración.
  • Presenta un coste bastante reducido.

Aquí podéis ver una imagen de como conectaríamos este sensor a nuestro Arduino para poder realizar las mediciones de temperatura:

LM35 fritzing

Como siempre os dejo los archivos Fritzing de este ejemplo, el datasheet del sensor y el código empleado para su programación. Lo podéis descargar desde este enlace: http://www.mediafire.com/?atycg43ubfnnunn

Aquí tenéis un código de ejemplo, de como obtener tanto el voltaje leído por el sensor, como los grados centígrados y los grados fahrenheit, además de mostrar los valores máximos y mínimos para cada una de las medidas mencionadas.

/* Sketch de ejemplo para testear el sensor de temperatura analógico LM35
 Escrito por Regata para www.tallerarduino.wordpress.com

 MODO DE CONEXIÓN DEL SENSOR

 Conectamos el pin 1 que corresponde a la alimentación del sensor con los 5V del Arduino
 Conectamos el pin 2 que corresponde al pin de datos del sensor con cualquier pin analógico del Arduino A0
 Conectamos el pin 3 que corresponde al pin de masa (GND) del sensor con el pin GND del Arduino

*/

int temp = 0;  //Pin analógico A0 del Arduino donde conectaremos el pin de datos del sensor LM35
float maxC = 0, minC = 100, maxF = 0, minF = 500;  //Variables para ir comprobando maximos y minimos

void setup()
{
  Serial.begin(9600);  //Iniciamos comunicación serie con el Arduino para ver los resultados del sensor
                       //a través de la consola serie del IDE de Arduino
}

void loop()
{
  float gradosC, gradosF;  //Declaramos estas variables tipo float para guardar los valores de lectura

  gradosC = (5.0 * analogRead(temp) * 100.0) / 1024;  //Esta es la funcion con la que obtenemos la medida del sensor
                                                      // en ºC

  gradosF = (gradosC * 1.8) + 32;  //Multiplicando los ºC por 1.8 y luego sumando 32 obtenemos grados Fahrenheit

  //Mostramos mensaje con valores actuales de temperatura, asi como maximos y minimos de cada uno de ellos
  Serial.print("Medidas actuales\n");
  Serial.print("C: ");
  Serial.print(gradosC);
  Serial.print("\tF: ");
  Serial.print(gradosF);
  //Comprobacion de maximos y minimos de temperatura
  if (maxC < gradosC)
    maxC = gradosC;
  if (gradosC < minC)
    minC = gradosC;
  if (maxF < gradosF)
    maxF = gradosF;
  if (gradosF < minF)
    minF = gradosF;
  Serial.print("\nMedidas maximas\n");
  Serial.print("C: ");
  Serial.print(maxC);
  Serial.print("\tF: ");
  Serial.print(maxF);
  Serial.print("\nMedidas minimas\n");
  Serial.print("C: ");
  Serial.print(minC);
  Serial.print("\tF: ");
  Serial.print(minF);
  Serial.print("\n\n");
  delay(2000);  //Usamos un retardo de 2 segundos entre lectura y lectura
}

Aquí podéis ver una captura de las medidas actuales que toma el sensor, así como las medidas mínimas y máximas capturadas por el sistema:

Captura Sensor LM35

Espero que os sirva de ayuda la entrada!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Arduino Yún: un Arduino con wifi


Hace unos días Massimo Banzi ha presentado, en la Maker Faire Bay Area, la placa Arduino Yún (la primera placa de una familia de productos con wifi que combinan Arduino con sistemas Linux). Realizada en colaboración con Dog Hunter (compañía con una extensa experiencia con linux), esta placa adopta la distribución linux Linino.

Arduino Yun top

Arduino Yun bottom

Básicamente la placa Arduino Yún es una combinación entre una placa Arduino Leonardo y un sistema wifi MIPS GNU/Linux basado en OpenWRT con la distribución Linino instalada. El sistema está basado en el chip ATMega324 (el que incorpora el Arduino Leonardo) y un Atheros AR9331.

Arduino Yun esquema

Esta placa además de ser programada a través del puerto USB que trae integrado también se puede programar vía Wifi.

La verdad es que se trata de una placa bastante interesante para nuestros proyectos, y a un precio bastante asequible, que será de 69$ más impuestos.

Podéis obtener más información aquí.

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Arduino Robot: Lottie Lemon


Nuevo robot educativo gracias a la colaboración entre la Asociación de Robótica Educativa Complubot y del equipo de Arduino. Este robot, llamado Lottie Lemon, presenta dos procesadores ATMEGA32U4 (uno en cada una de sus placas) y se encargan tanto de controlar los motores que se encuentran en la placa inferior como de los sensores que se encuentran en la placa superior. La programación de este robot es similar a la programación de un Arduino Leonardo. Os dejo unas fotos de está maravilla educativa en el tema de la robótica.

ArduinoRobot

Robot Lottie Lemon

LottieLemon_figure_hardware_top

LottieLemon_figure_hardware_bottom_back

Para más información podéis visitar los siguientes enlaces: Página oficial Arduino Robot, primeros pasos con Arduino Robot y Librerías Arduino Robot.

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

sensor de temperatura tmp36 y arduino


En esta nueva entrada vamos a ver como usar un sensor de temperatura analógico (emplea uno de los pines analógicos) modelo TMP36 con nuestra placa Arduino, dicho sensor es de la casa Analog Devices y permite realizar unas medidas de temperatura bastante precisas y a un muy reducido coste.

Foto Sensor TMP 36 GZ

Como podéis ver el sensor empleado es de tipo TO-92 (encapsulado como el DS18B20 o el de algunos transistores). Además se caracteriza por ser un sensor que es muy empleado para realizar medidas de temperatura y es muy sencillo de emplear (no hacen falta librerías para su uso). Es un sensor que se puede alimentar entre un rango de voltaje que va desde los 2.7V hasta los 5.5V, viene calibrado directamente en grados centígrados (ºC), presenta un factor de escala lineal de 10 mV/ºC (esto es la relación entre el cambio en la señal de salida y el cambio en la señal de la medida, es decir, cada 10 mV aumenta 1 ºC). Las características generales son:

Caracteristicas TMP36

Aquí os dejo un enlace para que podáis descargaros el datasheet del sensor de temperatura, el esquema en fritzing de conexionado y el sketch de Arduino: http://www.mediafire.com/?c26yr7fk48my0fw

Os pongo el esquema para la conexión del sensor a Arduino:

Conexion Fritzing TMP36

Aquí tenéis un código de ejemplo, de como obtener tanto el voltaje leído por el sensor, como los grados centígrados y los grados fahrenheit, además de mostrar los valores máximos y mínimos para cada una de las medidas mencionadas.

/* Sketch de ejemplo para testear el sensor de temperatura analógico TMP36
 Escrito por Regata para www.tallerarduino.wordpress.com

 MODO DE CONEXIÓN DEL SENSOR

 Conectamos el pin 1 que corresponde a la alimentación del sensor con los 5V del Arduino
 Conectamos el pin 2 que corresponde al pin de datos del sensor con cualquier pin analógico del Arduino
 Conectamos el pin 3 que corresponde al pin de masa (GND) del sensor con el pin GND del Arduino

*/

int temp = 5;  //Pin analógico A5 del Arduino donde conectaremos el pin de datos del sensor TMP36
float maxC = 0, minC = 100, maxF = 0, minF = 500, maxV = 0, minV = 5;  //Variables para ir comprobando maximos y minimos

void setup()
{
  Serial.begin(9600);  //Iniciamos comunicación serie con el Arduino para ver los resultados del sensor
                        //a través de la consola serie del IDE de Arduino
}

void loop()
{
  float voltaje, gradosC, gradosF;  //Declaramos estas variables tipo float para guardar los valores de lectura
                                    //del sensor, así como las conversiones a realizar para convertir a grados
                                    //centígrados y a grados Fahrenheit
                                    
  voltaje = analogRead(5) * 0.004882814;  //Con esta operación lo que hacemos es convertir el valor que nos devuelve
                                           //el analogRead(5) que va a estar comprendido entre 0 y 1023 a un valor
                                           //comprendido entre los 0.0 y los 5.0 voltios
                                           
  gradosC = (voltaje - 0.5) * 100.0;  //Gracias a esta fórmula que viene en el datasheet del sensor podemos convertir
                                       //el valor del voltaje a grados centigrados
                                       
  gradosF = ((voltaje - 0.5) * 100.0) * (9.0/5.0) + 32.0;  //Gracias a esta fórmula que viene en el datasheet del sensor podemos convertir
                                                           //el valor del voltaje a grados Fahrenheit
                                                           
  //Mostramos mensaje con valores actuales de humedad y temperatura, asi como maximos y minimos de cada uno de ellos
  Serial.print("Medidas actuales\n");
  Serial.print("C: "); 
  Serial.print(gradosC);
  Serial.print("\tF: "); 
  Serial.print(gradosF);
  Serial.print("\tV: "); 
  Serial.print(voltaje);
  //Comprobacion de maximos y minimos de humedad y temperatura
  if (maxC < gradosC)
    maxC = gradosC;
  if (gradosC < minC)
    minC = gradosC;
  if (maxF < gradosF)
    maxF = gradosF;
  if (gradosF < minF)
    minF = gradosF;
  if (maxV < voltaje)
    maxV = voltaje;
  if (voltaje < minV)
    minV = voltaje;
  Serial.print("\nMedidas maximas\n");
  Serial.print("C: "); 
  Serial.print(maxC);
  Serial.print("\tF: "); 
  Serial.print(maxF);
  Serial.print("\tV: "); 
  Serial.print(maxV);
  Serial.print("\nMedidas minimas\n");
  Serial.print("C: "); 
  Serial.print(minC);
  Serial.print("\tF: "); 
  Serial.print(minF);
  Serial.print("\tV: "); 
  Serial.print(minV);
  Serial.print("\n\n");
  delay(2000);  //Usamos un retardo de 2 segundos entre lectura y lectura  
}

La salida que obtenemos a través de la consola serie del IDE de Arduino es la siguiente:

Muestra de datos TMP36

Espero que os sirva de ayuda para vuestros proyectos!!

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Arduino Tutorials Cap7. Uso de las memorias SD


Muy buenas a todos! Tras un largo letargo de duro trabajo dónde no hemos tenido tiempo de nada, volvemos de nuevo con la serie de video tutoriales. Esta semana publicamos un nuevo capítulo de la serie “Arduino Tutorials”, esta vez se trata del capítulo número 7, el cual nos introduce en el mundo de las SD!

Como siempre todo este tutorial viene guiado con 3 ejemplos para facilitar el fácil entendimiento de los conceptos!

Aquí os dejo el link con todos los archivos necesarios para el desarrollo del tutorial

Sin más, aquí os dejo el video:

PD: perdonad la voz de moco que tengo en el video, pero el costipado no me ha dado respiro alguno! jejejeje

Enjoy!