{"id":385,"date":"2010-11-18T22:24:04","date_gmt":"2010-11-18T21:24:04","guid":{"rendered":"http:\/\/electronicapractica.crearblog.com\/?p=385"},"modified":"2019-06-13T19:41:43","modified_gmt":"2019-06-13T17:41:43","slug":"eeprom-con-i%c2%b2c-bus","status":"publish","type":"post","link":"https:\/\/www.diarioelectronicohoy.com\/blog\/eeprom-con-i%c2%b2c-bus","title":{"rendered":"EEPROM con I\u00b2C-BUS"},"content":{"rendered":"

<\/a><\/p>\n

Como utilizar una memoria EEPROM desde Arduino<\/span><\/h2>\n

El Arduino es una peque\u00f1a maravilla, en esto estar\u00e1n de acuerdo con migo los que ya la conocen. Yo tuve que hacer un proyecto para un amigo, con el Arduino. Me coment\u00f3 sobre la necesidad de usar alg\u00fan tipo de almacenaje externo, para guardar los \u00faltimos datos, en caso de perdida de la alimentaci\u00f3n.<\/p>\n

En la actualidad, hay muchas opciones de almacenaje disponibles y pens\u00e9 en el uso de una 24LC256 (a todas luces, con una capacidad demasiado grande para lo que iba a utilizar), parece ser una opci\u00f3n muy popular, pero no pod\u00eda sacrificar 4 pines I\/O s\u00f3lo para almacenar unos pocos bytes. Entonces, me puse a indagar, el modo de guardar dichos datos en un lugar accesible utilizando el m\u00ednimo de pines de la tarjeta de Arduino y part\u00ed de la informaci\u00f3n del Atmega168.<\/p>\n

Seg\u00fan la documentaci\u00f3n del Atmega168, el Arduino equipado con \u00e9ste microcontrolador, tiene una memoria interna EEPROM (No Vol\u00e1til) de tan s\u00f3lo 512 bytes (ver referencia<\/a>), que puede ser insuficiente en algunos casos. Finalmente, en el proyecto utilic\u00e9 unos pocos bytes de la propia memoria NV del Atmega168 con el que hice el proyecto. Sin embargo en mi cabeza, rondaba la idea inicial del uso de una EEPROM adicional y as\u00ed empez\u00f3 este tutorial, voy a usar una EEPROM serie 24LC64 ya que se trata de un elemento bastante utilizado en TV y otros elementos del mercado.<\/p>\n

As\u00ed que, vamos usar una EEPROM externa, en mi caso he usado una EEPROM serie 24LC64 que tiene una capacidad de 64 Kbit, es I\u00b2C y un precio alrededor de 2.88 euros. Este es el enlace de hojas de especificaciones<\/a> para los que quieran utilizar la 24LC256 y para el caso de la 24LC64, en este sitio<\/a>.<\/p>\n

DESCRIPCI\u00d3N FUNCIONAL DE LA EEPROM<\/span><\/h2>\n

El 24xx64 soporta un bus bidireccional de 2 cables y el protocolo de transmisi\u00f3n de datos. Un dispositivo que env\u00eda datos en el bus es definido como un transmisor, y un dispositivo que recibe datos como un receptor. El bus debe ser controlado por un dispositivo maestro que genera el reloj serie (SCL), controla el acceso de bus, y genera las condiciones de START y STOP mientras el 24xx64 trabaja como un esclavo. Tanto el maestro como el esclavo pueden funcionar como un transmisor o receptor pero el dispositivo maestro determina cual modo es activado.<\/p>\n

\"\"<\/a>Arduino y la EEPROM se comunican entre entre s\u00ed, mediante el bus I\u00b2C, el cual se trata de un bus de comunicaciones serie, formado por dos l\u00edneas: una para los datos y otra para el reloj. Como ya debe saber, este sistema de comunicaci\u00f3n permite la intercomunicaci\u00f3n de hasta 114 dispositivos en una misma red, aunque en ciertos casos se puede llegar a los 127 dispositivos.<\/p>\n

\"\"<\/a>La librer\u00eda Wire que podemos encontrar en el mismo IDE Arduino, permite manejar un bus I\u00b2C. En este art\u00edculo<\/a> del web y este otro art\u00edculo<\/a> (del portugu\u00e9s Daniel Gon\u00e7alves) para el uso de I\u00b2C EEPROM con el Arduino, son perfectos, ya que s\u00f3lo ocupar\u00e1 2 pines (pin 4 y 5). Los pines A0 a A2 se usan para indicar la direcci\u00f3n del bus I\u00b2C EEPROM, si est\u00e1n todos conectados a GND la direcci\u00f3n de Arduino es 0x50, ver hoja de datos. Por lo tanto, podr\u00eda poner hasta 8 eeproms en el mismo bus y lograr hasta 2 Mbyte de memoria.<\/p>\n

\"\"<\/a><\/p>\n

El pin 7 (WP) puede ser conectado a Vss, Vcc o dejarlo flotando. Una resistencia interna lo polariza a masa, este pin mantendr\u00e1 el dispositivo en el estado de no protecci\u00f3n, al dejarlo flotando. As\u00ed pues, de ser conectado a VCC, las operaciones de escritura son inhibidas. Las operaciones de lectura no se ven afectadas. Por lo tanto, al ser conectado a Vss, permitir\u00e1 la operaci\u00f3n de memoria normal (lectura\/escritura, la memoria entera 0000-1FFF).<\/p>\n

\"\"<\/a>Con el c\u00f3digo disponible sobre el enlace Playground de Arduino<\/a>, usted no tiene que preocuparse del bit de control. La direcci\u00f3n del dispositivo EEPROM en binario ser\u00e1 1010XXX donde XXX es Address 2, Address 1 y Address 0 en este orden. Por ejemplo, si el pin 3, 2,1 es Bajo-Bajo-Alto, en ese orden, la direcci\u00f3n binaria ser\u00e1 1010 001, o hex 0x50.<\/p>\n

En definitiva los pines 3, 2 y 1 determinan la direcci\u00f3n del chip; I\u00b2C utiliza las direcciones de 7 bits + 1 bit de control. Para simplificar, si conecta los tres pines a masa, le dar\u00e1 la direcci\u00f3n 1010000, o en hex 0x50, que corresponden a los 7 bits (MSB) m\u00e1s significativos, el bit 0<\/strong> no debe preocuparnos, lo genera la misma orden de lectura\/escritura<\/strong>.<\/p>\n

\"\"<\/a>En cuanto a las conexiones de los pines: el pin 5 de la EEPROM (SDA) lo conectamos a la entrada anal\u00f3gica 4 de nuestro Arduino, el pin 6 (SCL) a la entrada anal\u00f3gica 5 (observar en la foto de m\u00e1s abajo que, los cables de color no se cruzan, por la disposici\u00f3n de la placa de pruebas), el pin 8 a +5V y todos los dem\u00e1s a tierra o masa. Los pines anal\u00f3gicos 4 y 5 de Arduino son los que usa la librer\u00eda Wire.<\/p>\n

No debemos olvidarnos de inicializar la conexi\u00f3n \u00a0\u00a0\u00a0Wire.begin(); <\/strong> antes de usar estas funciones:<\/p>\n

\"\"<\/a>Como muestra de como, escribir y leer en una EEPROM, a continuaci\u00f3n, pongo el ejemplo de kans, que encontr\u00e9 en la red y con el que yo prob\u00e9: se trata de escribir una cadena de caracteres en una EEPROM, cuando se alimente nuestro Arduino, pasando despu\u00e9s leerla y enviarla al ordenador v\u00eda serie. Para ver los resultados, podemos utilizar el monitor de la IDE Arduino o descargarnos el programa GTerminal<\/strong> que es una aplicaci\u00f3n libre y que puede encontrar en la red.<\/p>\n

Al tratarse de una memoria no vol\u00e1til, debemos comentar la (l\u00ednea 59) de escritura, para comprobar que permanecen los datos guardados con anterioridad.<\/p>\n

\/* \r\n* Uso del I2C bus con la EEPROM 24LC64 \r\n* Ejemplo: eeprom.pde * Este c\u00f3digo pertenece a: \r\n* Autor: kans \r\n* Fecha: 05\/03\/2008 \r\n* \r\n* http:\/\/pastebin.com\/f3a36644b *\/\r\n\r\n  #include <Wire.h> \/\/libreria \"Wire.h\" I\u00b2C\r\n \/\/ Las siguientes funciones para lectura y escritura en una EEPROM \r\n \/\/ se encuentran en el wiki de Arduino: \r\n \/\/ http:\/\/www.arduino.cc\/playground\/Code\/I\u00b2CEEPROM\r\n\r\n  void I\u00b2C_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data )\r\n  {\r\n   int rdata = data;\r\n   Wire.beginTransmission(deviceaddress);\r\n   Wire.send((int)(eeaddress >> 8));    \/\/ MSB\r\n   Wire.send((int)(eeaddress & 0xFF));  \/\/ LSB\r\n   Wire.send(rdata);\r\n   Wire.endTransmission();\r\n  }\r\n\r\n  \/\/ADVERTENCIA: address es una direcci\u00f3n de p\u00e1gina, de 6 bits termina envolver\u00e1 \r\n \/\/ alrededor adem\u00e1s, los datos pueden ser como m\u00e1ximo alrededor 30 byte, porque  \r\n \/\/ la libreria Wire tiene un b\u00fafer de 32 byte\r\n\r\n  void I\u00b2C_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage,\r\n  byte* data,  byte length )\r\n  {\r\n   Wire.beginTransmission(deviceaddress);\r\n   Wire.send((int)(eeaddresspage >> 8));   \/\/ MSB\r\n   Wire.send((int)(eeaddresspage & 0xFF)); \/\/ LSB\r\n   byte c;\r\n   for ( c = 0; c < length; c++)    Wire.send(data[c]);\r\n    Wire.endTransmission();   }\r\n    byte I\u00b2C_eeprom_read_byte( int deviceaddress, unsigned int eeaddress )\r\n    {    \r\n   byte rdata = 0xFF;    Wire.beginTransmission(deviceaddress);\r\n   Wire.send((int)(eeaddress >> 8));   \/\/ MSB\r\n   Wire.send((int)(eeaddress & 0xFF)); \/\/ LSB\r\n   Wire.endTransmission();\r\n   Wire.requestFrom(deviceaddress,1);\r\n   if (Wire.available()) rdata = Wire.receive();\r\n   return rdata;\r\n  }\r\n\r\n \/\/ tal vez no hay que leer m\u00e1s de 30 o 32 bytes de una vez!\r\n  void I\u00b2C_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length )\r\n  {\r\n   Wire.beginTransmission(deviceaddress);\r\n   Wire.send((int)(eeaddress >> 8));   \/\/ MSB\r\n   Wire.send((int)(eeaddress & 0xFF));   \/\/ LSB\r\n   Wire.endTransmission();\r\n   Wire.requestFrom(deviceaddress,length);\r\n   int c = 0;\r\n   for ( c = 0; c < length; c++ )\r\n   if (Wire.available()) buffer[c] = Wire.receive();\r\n  }       \r\n\r\n   void setup()\r\n  {\r\n   char cadena[] = \"hola mundo desde una eeprom\"; \/\/ cadena a escribir\r\n   Wire.begin();  \/\/ es obligatorio inicializar la conexion\r\n   Serial.begin(9600);\r\n   I\u00b2C_eeprom_write_page(0x50, 0, (byte *)cadena, sizeof(cadena));  \/\/ escribir la cadena al>\r\n     \/\/ principio de la EEPROM; comentar esta l\u00ednea para probar que la memoria es no vol\u00e1til\r\n   delay(10); \/\/peque\u00f1a pausa despues de escribir en la memoria\r\n  }\r\n\r\n  void loop()\r\n  {\r\n  int addr=0; \/\/direcci\u00f3n a leer\r\n  byte b = I\u00b2C_eeprom_read_byte(0x50, 0);  \/\/ acceso a la primera posici\u00f3n de memoria\r\n\r\n  while (b!=0)\r\n  {\r\n   Serial.print((char)b); \/\/enviar al ordenador\r\n   addr++;  \/\/siguiente direccion\r\n   b = I\u00b2C_eeprom_read_byte(0x50, addr);  \/\/acceso a posici\u00f3n de memoria\r\n  }\r\n   Serial.println();\r\n   delay(2000);\r\n  }<\/pre>\n
El c\u00f3digo anterior, con un copiar\/pegar puede descargarlo en su editor de texto habitual y gu\u00e1rdelo como \u00abeeprom.pde\u00bb, por ejemplo y corra su propia experiencia, son unos pocos elementos los que intervienen, cuatro trozos de hilo de colores y la EEPROM, observe la foto.<\/p>\n
La \u00faltima parte de este tutorial, es en realidad utilizar el c\u00f3digo en su software. Dado que el creador de las funciones relacionadas anteriormente (Kans) no ha creado un archivo .h por sus motivos, simplemente tendremos que copiar y pegar todas esta funciones, al principio de su c\u00f3digo.<\/p>\n
El c\u00f3digo incluye cuatro funciones:<\/p>\n
I\u00b2C_eeprom_write_byte<\/strong>,
\nI\u00b2C_eeprom_write_page<\/strong>,
\nbyte I\u00b2C_eeprom_read_byte<\/strong>, y
\nI\u00b2C_eeprom_read_buffer<\/strong>.<\/p><\/blockquote>\n
Estas se explican por s\u00ed mismo si se lee el c\u00f3digo, por ejemplo, para escribir los datos byte \u00ab0xAB\u00bb para bloquear la 1 \u00aa (recuerde una EEPROM 64kbit tiene disponibles 8192×8 bloques) de la EEPROM, cuya direcci\u00f3n es 0x50, se deber\u00eda utilizar:<\/p>\n
I\u00b2C_eeprom_write_byte (0x50, 1, 0xAB);<\/strong><\/p><\/blockquote>\n
Y para leer los datos debe escribir:<\/p>\n
temp = I\u00b2C_eeprom_read_byte (0x50, 1);<\/strong><\/p><\/blockquote>\n
El par\u00e1metro deviceaddress<\/strong> (direcci\u00f3n del dispositivo) al que hacen referencia estas funciones en el caso de esta memoria se trata del 0\u00d750.<\/p>\n
\"\"<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Como utilizar una memoria EEPROM desde Arduino El Arduino es una peque\u00f1a maravilla, en esto estar\u00e1n de acuerdo con migo los que ya la conocen. Yo tuve que hacer un proyecto para un amigo, con el Arduino. Me coment\u00f3 sobre la necesidad de usar alg\u00fan tipo de almacenaje externo, para guardar los \u00faltimos datos, en […]<\/p>\n","protected":false},"author":4,"featured_media":4469,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_exactmetrics_skip_tracking":false,"_exactmetrics_sitenote_active":false,"_exactmetrics_sitenote_note":"","_exactmetrics_sitenote_category":0,"footnotes":""},"categories":[22,27,15],"tags":[44,45,148,82],"class_list":["post-385","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-arduino","category-eeprom-con-ic-bus","category-microcontroladores","tag-24lc256","tag-24lc64","tag-e2prom","tag-eeprom"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts\/385","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/comments?post=385"}],"version-history":[{"count":11,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts\/385\/revisions"}],"predecessor-version":[{"id":4838,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts\/385\/revisions\/4838"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/media\/4469"}],"wp:attachment":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/media?parent=385"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/categories?post=385"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/tags?post=385"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}