MSRobotics - Usando Una Memoria EEPROM Con Arduino

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 5

MSRobotics (http://msrobotics.

net/)
Grupo MS MSRobotics

Buscar

  

(https://twitter.com/project_arduino) (http://msrobotics.net) (https://www.youtube.com/user/mortalstar)

(https://www.facebook.com/msroboticsnet)

MENU 

MENÚ PRINCIPAL
L O MÁS D ESTAC AD O D EL MOMEN TO (/IN D EX.PH P)

MINI PCS
C L ASES D E R ASPBER R Y PI (/IN D EX.PH P/C L ASES-D E-R ASPBER R Y-PI)

MAN U AL ES (/IN D EX.PH P/MAN U AL ES)

L ABOR ATOR IO PI (/IN D EX.PH P/L ABOR ATOR IO-PI)

¿SABIAS QU E? (/IN D EX.PH P/A1 )

ARDUINO
PL AC AS AR D U IN O (/IN D EX.PH P/PL AC AS-AR D U IN O)

MAN U AL ES AR D (/IN D EX.PH P/MAN U AL ES-AR D )

L ABOR ATOR IO AR D (/IN D EX.PH P/L ABOR ATOR IO-AR D )

SABIAS QU E? (/IN D EX.PH P/SABIAS-QU E)


Tweets por @project_arduino

MSRobotics
@project_arduino

Hoy realizamos el mantenimiento de un lector de cds . No te pierdas el vídeo en


nuestro canal de #youtube youtube.com/watch?v=KC8jwt… #pc #tecnicosistemas
#informatica #computador #computadores #computadoras #1990 #retro #disquete
#diskette #diskettes #acer #dvd #cd #bluray

24 sept. 2020

MSRobotics
Insertar Ver en Twitter

IMPRESORAS 3D
IMPR ESOR A 3 D (/IN D EX.PH P/IMPR ESOR A-3 D )
Manuales Printer 3D (/index.php/impresora-3d/manuales-printer-3d)

Laboratorio 3D (/index.php/impresora-3d/laboratorio-3d)

Sabia que? (/index.php/impresora-3d/sabia-que)

PROGRAMACION
PR OGR AMAC IÓN (/IN D EX.PH P/PR OGR AMAC ION )
MANUALES C y C++ (/index.php/programacion/c-o-c)

MANUALES JavaScript (/index.php/programacion/manuales-javascript)


Imprimir (/index.php/laboratorio-ard/159-usando-una-memoria-eeprom-con-arduino?
tmpl=component&print=1&layout=default) M
Correo electrónico (/index.php/component/mailto/?
tmpl=component&template=a4joomla-dealer3r-free&link=1523d2089ec05c36a8dab77572d0136f15ad4cc0)
Usando una memoria EEPROM con Arduino
Categoría de nivel principal o raíz: Arduino (/index.php/laboratorio-ard/13-menuu/arduino)
Categoría: Laboratorio ARD (/index.php/laboratorio-ard)
C Publicado: 05 Octubre 2016
< Visto: 1650
Voto 5 Votar

Arduino tiene una memoria no volátil de tan sólo 512 bytes, que puede ser insuficiente en algunos casos.

Pero podemos usar una EEPROM externa, en mi caso he usado una EEPROM serie 24LC256 que tiene una capacidad de
256 Kbit (32K x 8 bytes) y un precio de 2.88 euros. Os dejo el enlace a

la hoja de especificaciones (/images/arduino/laboratorioADR/eeprom/21203N.rar).

La comunicación entre Arduino y la EEPROM se realiza mediante el bus I2C


(http://es.wikipedia.org/wiki/I%C2%B2C) , que se trata de un bus de comunicaciones serie
formado por dos lineas: una para los datos y otra para el reloj.

La librería Wire (http://wiring.org.co/reference/libraries/Wire/index.html) permite manejar un bus


I2C desde nuestro Arduino, y en este artículo
(http://www.arduino.cc/playground/Code/I2CEEPROM) del wiki encontramos 4 funciones que
usando la librería anterior implementan la lectura/escritura en la EEPROM.

El parámetro deviceaddress al que hacen referencia estas funciones en el caso de esta memoria se trata del 0x50.

No debemos olvidarnos de inicializar la conexión antes de usar estas funciones:

Wire.begin();

En cuanto a las conexiones de los pines: el pin 5 de la EEPROM (SDA) lo conectamos a la entrada analógica 4 de nuestro
Arduino, el pin 6 (SCL) a la entrada analógica 5 (observar en la foto que los cables de color naranja se cruzan), el pin 8 a
5V y todos los demás a tierra.

Los pines analógicos 4 y 5 de Arduino son los que usa la librería Wire.

En cuanto al sk etch, os pongo el ejemplo con el que lo probé: se trata de escribir una cadena de caracteres cuando
enciende nuestro Arduino y de leerla y enviarla al ordenador repetidamente.

1. /* Ejemplo EEPROM
2. * Autor: kans
3. * Fecha: 05/03/2008
4. */
5.
6. #include <Wire.h> //libreria I2C
7.
8. //Las siguientes funciones para lectura y escritura en una EEPROM se encuentran en el wiki de Arduino:
http://www.arduino.cc/playground/Code/I2CEEPROM
9.
10. void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
11. int rdata = data;
12. Wire.beginTransmission(deviceaddress);
13. Wire.send((int)(eeaddress >> 8)); // MSB
14. Wire.send((int)(eeaddress & 0xFF)); // LSB
15. Wire.send(rdata);
16. Wire.endTransmission();
17. }
18.
19. // WARNING: address is a page address, 6-bit end will wrap around
20. // also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
21. void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
22. Wire.beginTransmission(deviceaddress);
23. Wire.send((int)(eeaddresspage >> 8)); // MSB
24. Wire.send((int)(eeaddresspage & 0xFF)); // LSB
25. byte c;
26. for ( c = 0; c < length; c++)
27. Wire.send(data[c]);
28. Wire.endTransmission();
29. }
30.
31. byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
32. byte rdata = 0xFF;
33. Wire.beginTransmission(deviceaddress);
34. Wire.send((int)(eeaddress >> 8)); // MSB
35. Wire.send((int)(eeaddress & 0xFF)); // LSB
36. Wire.endTransmission();
37. Wire.requestFrom(deviceaddress,1);
38. if (Wire.available()) rdata = Wire.receive();
39. return rdata;
40. }
41.
42. // maybe let's not read more than 30 or 32 bytes at a time!
43. void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
44. Wire.beginTransmission(deviceaddress);
45. Wire.send((int)(eeaddress >> 8)); // MSB
46. Wire.send((int)(eeaddress & 0xFF)); // LSB
47. Wire.endTransmission();
48. Wire.requestFrom(deviceaddress,length);
49. int c = 0;
50. for ( c = 0; c < length; c++ )
51. if (Wire.available()) buffer[c] = Wire.receive();
52. }
53.
54.
55. void setup() {
56. char cadena[] = "hola mundo desde una eeprom"; //cadena a escribir
57. Wire.begin(); //es obligatorio inicializar la conexion
58. Serial.begin(9600);
59. i2c_eeprom_write_page(0x50, 0, (byte *)cadena, sizeof(cadena)); //escribir la cadena al principio de la EEPROM;
comentar esta linea para probar que la memoria es no volatil
60. delay(10); //peque�a pausa despues de escribir en la memoria
61. }
62.
63. void loop() {
64. int addr=0; //direccion a leer
65. byte b = i2c_eeprom_read_byte(0x50, 0); //acceso a la primera posicion de memoria
66.
67. while (b!=0) {
68. Serial.print((char)b); //enviar al ordenador
69. addr++; //siguiente direccion
70. b = i2c_eeprom_read_byte(0x50, addr); //acceso a posicion de memoria
71. }
72. Serial.println();
73. delay(2000);
74. }

Al tratarse de una memoria no volátil, podemos comentar la escritura (línea 59) para comprobar que permanecen los datos
guardados con anterioridad.

 Anterior (/index.php/laboratorio-ard/209-que-son-y-como-usar-interrupciones-en-arduino)
Siguiente  (/index.php/laboratorio-ard/158-sensor-de-sonido-con-arduino)

(http://opensource.org/) (http://w w w.reprap.org/w iki/Proyecto_Clone_Wars)

(http://reprap.org/) (https://w w w.raspberrypi.org/) (https://w w w.arduino.cc/)

(http://w iring.org.co/)

(http://w iring.org.co/)

(https://w w w.gnu.org/)

También podría gustarte