Archivo de la etiqueta: principiantes

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

Programando Arduino con Sublime Text 2


Gracias a los compañeros de Spainlabs me he enterado de la existencia de un muy buen software de programación, Sublime Text 2, con el que podemos programar nuestras placas Arduino de una forma que a mí parecer es más sencilla, ya que incorpora las siguientes características:

  • Presenta un minipama, que nos permite una previsualización de la estructura que presenta nuestro código, siendo muy útil para desplazarse a través de códigos grandes.
  • Presenta Multi Layout, esto significa que permite siete configuraciones de plantilla, es decir, podemos elegir editar en una sola ventana o hacer una división de hasta cuatro ventanas verticales o cuatro ventanas en cuadrícula.
  • Presenta Multi Cursor, que nos permite crear distintos cursores con los que podemos escribir texto de forma arbitraria en diferentes posiciones del archivo.
  • Presenta Multi Sección, que permite realizar una selección múltiple de un término por diferentes partes del archivo.
  • Soporte nativo para distintos lenguajes de programación.
  • Remarcado de sintaxis completamente configurable a través de archivos de configuración del usuario.
  • Búsqueda dinámica, que permite realizar búsquedas de expresiones regulares o por archivos, proyectos, directorios, una conjunción de ellos o todo a la vez.
  • Auto completado y marcado de llaves, que permite auto completar código con los comandos del lenguaje de programación, así como abrir y cerrar bloques de código mediante las llaves.
  • Configuración total de Keybindings, que nos permite configurar todas las teclas a nuestro gusto.
  • Coloreado y envoltura de sintaxis, que permite resaltar las expresiones propias de la sintaxis del lenguaje para facilitar su lectura.
  • Presenta Pestañas, que permite abrir varios documentos y organizarlos en pestañas.
  • Resaltado de paréntesis e identación, que al colocar el cursor en un paréntesis, corchete o llave, resalta esta y el paréntesis, corchete o llave de cierre o apertura correspondiente.
  • Presenta el número de línea de código.
  • Está disponible para distintos sistemas operativos.

Captura de pantalla sublime text 2

¿Como podemos entonces programar Arduino desde Sublime Text 2? Pues gracias a un plugin llamado Stino, que necesitaremos descargar y copiar en la siguiente ruta: C:\Users\”USUARIO”\AppData\Roaming\Sublime Text 2\Packages. Os pongo una imagen para que veáis como lo tengo hecho yo en mi ordenador.

Plugin Stino

Además necesitaremos también tener instalado/copiado el IDE de Arduino en nuestro ordenador, ya que desde Sublime Text 2 tendremos que indicar donde está el directorio de Arduino (para poder coger las librerías, sintaxis, configuraciones, etc…), donde se encuentra el directorio de nuestro Sketchbook (directorio donde guardamos nuestros programas realizados con Arduino). Para ello deberemos ir a la barra de menú de Sublime Text 2 e ir a Preferences y marcar Show Arduino Menu para que aparezca el menú de Arduino. Podéis ver como queda en esta imagen.

Menu Arduino preferencias

 

Una vez que tengamos el menú de Arduino visible, es cuando necesitamos indicarle a Sublime Text 2 donde están los directorios del IDE de Arduino, estos se le indican a través de los siguientes menús:

Preferencias Arduino

 

Como veis os aparecerán todas las opciones de compilación, carga, consola serie, selección de placa, selección de puerto, skecthbook, ejemplos, librerías, etc… que permitirán realizar correctamente todas las operaciones con vuestra placa Arduino.

También se pueden establecer unas teclas especiales, llamadas Keybindings, que permitan realizar la compilación, carga y apertura del monitor serie de la siguiente manera: Vamos al menú Preferences de Sublime Text 2 y pulsamos sobre Key Bindings – User.

keybindings

 

Y modificamos el contenido de ese archivo por este trozo de código:

[
{ "keys": ["f5"], "command": "compile_sketch" },
{ "keys": ["f6"], "command": "upload_sketch" },
{ "keys": ["f7"], "command": "start_serial_monitor" }
]

Guardamos y listo! Ahora ya podemos compilar con la tecla F5, cargar nuestro programa al Arduino con la tecla F6 y abrir el monitor serie con la tecla F7. Ya tenemos Sublime Text 2 listo para programar nuestros Arduino!!

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 Pinout y conexiones básicas


En mis visitas diarias a otros blogs he encontrado una buena información en www.pighixxx.com y www.akafugu.jp que creo que puede ser de ayuda a toda aquella gente que comienza en esto de la electrónica y en concreto en el tema de Arduino. Se trata de unos documentos que he recopilado en un único pdf para que sea más cómodo su uso, en los que aparecen los distintos pinouts de las placas Arduino más comunes.

Arduino uno pinout

También podéis encontrar una hoja donde aparecen los pinouts más comunes de algunos de los componentes electrónicos que normalmente usamos en nuestros proyectos.

Componentes electrónicos pinout

Así como unas magnifícas páginas en las que se pueden ver las conexiones básicas de distintos componentes a nuestro Arduino y que puede ser de una muy buena ayuda tanto para aquellos que están empezando con Arduino o otro microcontrolador, como para aquellas personas que ya están curtidas en estos temas.

conexiones basicas arduino

Sin más, os dejo el enlace al documento pdf en el que vais a encontrar todo este estupendo material de ayuda:
http://www.mediafire.com/download/zrssl27tiasi17r/Arduino_Pinout_y_Conexiones_Basicas.pdf

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

LCD I2C y Arduino


A veces cuando estás montando un proyecto, puede que te quedes corto con los pines de tu tarjeta Arduino y necesites optimizar las conexiones hardware de tu diseño. En esta entrada vamos a ver como poder obtener unos pines más pasando de emplear una lcd conectada en modo paralelo (empleamos 6 pines) a una lcd que emplea el protocolo de comunicación I2C (empleamos 2 pines analógicos en el caso del Uno, pines digitales 2 y 3 para el Leonardo y pines 20 y 21 digitales en el caso del Mega). Yo me he comprado un adaptador bastante económico a través de ebay que va soldado a los pines de nuestra pantalla lcd, aunque también se venden los módulos y pantalla juntos. Os dejo unas fotos para que podáis ver el módulo (hay muchos en el mercado pero que funcionan exactamente igual de bien):

Pantalla y Adaptador

LCD I2C Adaptador

Como podéis ver este módulo trae cuatro pines que a partir de ahora son los que vamos a usar y que son los siguientes: GND, VCC, SDA y SCL. Además trae un potenciometro gracias al cual podremos regular el brillo de la pantalla (para poder ver correctamente los caracteres en ella) y un jumper para activar o desactivar el backlight (luz) de la pantalla (también se puede activar o desactivar por software).

La conexión a nuestras placas es bastante sencilla ya que solo son 4 cables, aunque hay que tener en cuenta la placa Arduino que vayamos a emplear ya que como he dicho antes cambia la disposición de estos pines, por tanto para la tarjeta Arduino Uno emplearemos los pines A4(SDA) y A5(SCL), para la Arduino Leonardo emplearemos los pines SDA y SCL y para la Arduino Mega emplearemos D20(SDA) y D21(SCL). Os dejo unos ejemplos de conexión:

Conexiones Modulo I2C LCD ARDUINO

Os dejo un código de ejemplo:

/* Sketch de ejemplo para testear el módulo adaptador paralelo a I2C de pantalla LCD
 Escrito por YWROBOT, modificado por Regata para www.tallerarduino.wordpress.com*/
 
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

//Comprobamos la version de nuestro IDE de Arduino y dependiendo de si es una version superior a la 1 ejecutamos distintos comandos
//esto es necesario ya que para versiones anteriores se empleaba el comando print para imprimir caracteres y ahora se emplea el comando write
#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args)  write(args);
#else
#define printByte(args)  print(args,BYTE);
#endif

//Creamos diferentes caracteres
uint8_t bell[8]  = {0x4,0xe,0xe,0xe,0x1f,0x0,0x4};
uint8_t note[8]  = {0x2,0x3,0x2,0xe,0x1e,0xc,0x0};
uint8_t clock[8] = {0x0,0xe,0x15,0x17,0x11,0xe,0x0};
uint8_t heart[8] = {0x0,0xa,0x1f,0x1f,0xe,0x4,0x0};
uint8_t duck[8]  = {0x0,0xc,0x1d,0xf,0xf,0x6,0x0};
uint8_t check[8] = {0x0,0x1,0x3,0x16,0x1c,0x8,0x0};
uint8_t cross[8] = {0x0,0x1b,0xe,0x4,0xe,0x1b,0x0};
uint8_t retarrow[8] = {	0x1,0x1,0x5,0x9,0x1f,0x8,0x4};
  
LiquidCrystal_I2C lcd(0x20,20,4);  // definimos la direccion de la pantalla LCD a 0x20 e indicamos el numero de columnas y filas de la pantalla

void setup()
{
  lcd.init();  //Iniciamos la pantalla
  lcd.backlight();  //Activamos el backligt
  //Le decimos a la pantalla que cree los distintos caracteres arriba definidos
  lcd.createChar(0, bell);
  lcd.createChar(1, note);
  lcd.createChar(2, clock);
  lcd.createChar(3, heart);
  lcd.createChar(4, duck);
  lcd.createChar(5, check);
  lcd.createChar(6, cross);
  lcd.createChar(7, retarrow);
  lcd.home();  //Posicionamos el cursor al inicio
  lcd.print("Visitanos en:"); //Imprimimos el mensaje
  lcd.setCursor(0, 1);  //Nos posicionamos en la primera columna de la fila 2
  lcd.print("www.tallerarduino.");  //Imprimimos el mensaje
  lcd.setCursor(7, 2);  //Nos posicionamos en la quintaa columna de la fila 3
  lcd.print("wordpress.com");  //Imprimimos el mensaje
  lcd.setCursor(4, 3);  //Nos posicionamos en la cuarta columa de la fila 4
  lcd.print("We ");
  lcd.printByte(3);
  lcd.print(" Arduino!");
  delay(10000);
  displayKeyCodes();  //Llamamos a la funcion displayKeyCodes
}

//Muestra todos los caracteres
void displayKeyCodes(void) 
{
  int i = 0;
  while (1) 
  {
    lcd.clear();  //Borramos la pantalla
    lcd.setCursor(0,1);  //Nos posicionamos en la primera columna de la segunda fila
    //Mostramos los distintos caractares
    lcd.print("Codigos: 0x"); 
    lcd.print(i, HEX);
    lcd.print("-0x"); 
    lcd.print(i+16, HEX);
    lcd.setCursor(2, 2);  
    for (int j=0; j<16; j++)
      lcd.printByte(i+j);
    i+=16;
    delay(4000);
  }
}

void loop()
{
}

Aquí podéis ver un video del funcionamiento del programa sobre la pantalla LCD:

Y por último os dejo los archivos, donde viene el skecth, la librería para usar este módulo con vuestra pantalla LCD y el esquema de conexionado en Fritzing: http://www.mediafire.com/?naoloa8um1xfs0m

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

pinguino kit: programa pinguino gráficamente


Pinguino Kit (actualmente en la versión v1.1) es un entorno que permite programar las placas Pinguino Pic gráficamente. Esta herramienta pretende convertirse en una herramienta de enseñanza de programación y electrónica digital básica, centrada en estas placas. Os dejo una captura del IDE de Pinguino Kit y un vídeo en el que podéis ver un poco su funcionamiento y el método para realizar programas.

IDE Pinguino Kit

Podéis encontrar más información en los siguientes enlaces: Página del proyecto Pinguino Kit y zona de descarga e instalación del IDE de Pinguino Kit.

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