ESCUELA SUPERIOR POLITÉCNICA DEL LITORAL

FACULTAD DE INGENIERÍA EN
EN ELECTRICIDAD Y COMPUTACIÓN
FIEC

PRÁCTICAS DE LABORATORIO DE
SISTEMAS EMBEBIDOS

Programación de un Sistema Embebido para el uso de la memoria

EEPROM

PRÁCTICA #5
OBJETIVOS

 Familiarizarse con los diferentes tipos de memorias.

 Aprender a programar un sistema embebido utilizando
adecuadamente su memoria no volátil.
 Conocer las características principales de las memorias EEPROM.

CONTENIDO

a) Tipos de memoria EEPROM

b) Características de la memoria EEPROM a utilizar
c) Uso de memoria EEPROM para un sistema embebido
d) Resumen de la práctica

TIPOS DE MEMORIA EEPROM

EPROM son las siglas de Erasable Programmable Read-Only

Memory (ROM programable borrable). Es un tipo de chip de memoria ROM no
volátil inventado por el ingeniero Dov Frohman. Está formada por celdas
de FAMOS (Floating Gate Avalanche-Injection Metal-Oxide Semiconductor) o
"transistores de puerta flotante", cada uno de los cuales viene de fábrica sin carga, por
lo que son leídos como 0 (por eso, una EPROM sin grabar se lee como 00 en todas
sus celdas). Se programan mediante un dispositivo electrónico que
proporciona voltajes superiores a los normalmente utilizados en los circuitos
electrónicos. Las celdas que reciben carga se leen entonces como un 1.

Las EEPROM pueden venir en diferentes tamaños y capacidades. Así, para la familia
2700 se pueden encontrar:

Tipo de Tamaño Tamaño Longitud Última dirección

EPROM — bits — Bytes (hex) (hex)
1702, 1702A 2 Kbits 256 100 000FF
2704 4 Kbits 512 200 001FF
2708 8 Kbits 1 KBytes 400 003FF
2716, 27C16 16 Kbits 2 KBytes 800 007FF
2732, 27C32 32 Kbits 4 KBytes 1000 00FFF
2764, 27C64 64 Kbits 8 KBytes 2000 01FFF
27128, 27C128 128 Kbits 16 KBytes 4000 03FFF
27256,
256 Kbits 32 KBytes 8000 07FFF
27C256
27512, 27C512 512 Kbits 64 KBytes 10000 0FFFF
27C010,
1 Mbits 128 KBytes 20000 1FFFF
27C100
27C020 2 Mbits 256 KBytes 40000 3FFFF
27C040 4 Mbits 512 KBytes 80000 7FFFF
27C080 8 Mbits 1 MBytes 100000 FFFFF
Características de la memoria EEPROM a utilizar
El ATmega328P —el microcontrolador del Arduino UNO, el Nano y otros de la línea
Arduino— tiene una capacidad de 1.024 bytes (1 Kb) de memoria EEPROM. La hoja
de datos nos indica que la EEPROM del ATmega328P acepta hasta 100.000 ciclos de
lectura/escritura. Parece mucho, pero el solo hecho de tener una cantidad de ciclos de
escritura acotada ya nos indica que su función no es en nada similar a una RAM. Es
para guardar datos, y no en forma momentánea y veloz, sino de manera durable. No
ponga nunca operaciones con la EEPROM dentro de la función loop(), ya que, dada la
velocidad de trabajo del microcontrolador, llegará rápidamente al límite de 100.000.

Uso de memoria EEPROM de un sistema embebido

1. Abrir Proteus
2. Dirigirse a la pestaña Source Code
3. Primero incluir la librería #include <EEPROM.h>, la cual nos
permitirá manipular, ya sea leer o escribir en la memoria.
4. Si se desea conocer el tamaño de la memoria se utiliza el comando:
EEPROM.length() y para mostrarlo en el monitor serial
Serial.println( EEPROM.length() );, pero antes se debe iniciar la
comunicación serial con el comando Serial.begin(9600);
5. Para leer algún dato almacenado en cierta dirección de la memoria
se utiliza: Serial.println( EEPROM.read(0) ); //donde el 0
representa la dirección 0 de la memoria eeprom
6. Para escribir algún dato, ya sea entero, flotante, carácter o cadena
de caracteres se utiliza: EEPROM.write(0, 39); //0 es la dirección
donde se almacenará y 39 el dato a almacenar.
7. Todo esto mencionado anteriormente después de incluir la librería
tiene que ir dentro del void setup(){}
8. El código a continuación permite la mostrar en serial el valor
guardado en la dirección 0 de la memoria eeprom y a su vez la
cadena guarada en la dirección 10:

#include <EEPROM.h> // libreria EEPROM

float temperatura = 27.50; // asigna valor a variable de punto flotante

char cadena[] = "Hola esta es una prueba"; // crea cadena de caracteres con un texto

void setup() {
Serial.begin(9600); // inicializa monitor serie a 9600 bps

EEPROM.put(0, temperatura); // almacena en direccion cero el punto flotante

EEPROM.put(10, cadena); // almacena en direccion diez la cadena

Serial.println("Valor de punto flotante en direccion 0:"); // imprime texto

Serial.println( EEPROM.get(0, temperatura) ); // obtiene valor de punto flotante
// en direccion cero y muestra
 Serial.println(" "); // espacio en blanco

Serial.println("Valor de la cadena en direccion 10:"); // imprime texto

Serial.println( EEPROM.get(10, cadena) ); // obtiene cadena de caracteres en
} // direccion diez y muestra

void loop() { // funcion loop() declarada pero sin contenido

// nada por aqui
}
a. Cabe recalcar el comando EEPROM.put es una variante del comando
EEPROM.write, su ventaja es que únicamente escribe el dato en esa
dirección si es un dato diferente al ya existente en dicha dirección.
9. C abe recalcar el comando EEPROM.get es una variante del comando
EEPROM.read, su ventaja es que puede mostrar los datos almacenado desde
ese espacio de memoria hasta acabar la cadena de caracteres en caso de serlo,
sin importar el tamaño, la función get calcula el tamaño.
10. Nunca colocar las funciones read, write, get o put en un loop infinito, ya que
podría rápidamente llegar al límite de veces que admite la memoria EEPROM.
11. Una vez ejecutándose la simulación, no dirigimos a la pestaña debug, y al final
en avr seleccionamos eproem memory

12. Otra opción, y que van a utilizar es:

//#define F_CPU 80000000ul
#include <avr/io.h>
#include <avr/eeprom.h> //archivo de cabecera para la utilización de la
EEPROM AVR
#include <util/delay.h>

uint8_t EEMEM dato; //creación de la variable dato de 8 bits en la EEPROM

AVR
int i=0;
int main(void)
{

iniciar_usart();//inicia el módulo USART PIC

DDRD=0xff; //como salidas digitales

 PORTD=0x00; //se inicia a 0
DDRB |= (0 << 0); //PIN 8 DE ARDUINO COMO ENTRADA
DDRB |= (1 << 3); //pin 11 del Arduino como salida

//eeprom_write_byte(&dato,20); //en la variable dato de la EEPROM AVR

//eeprom_write_byte(28,203); //en la variable dato de la EEPROM AVR
//se escribe el entero 203
PORTD=eeprom_read_byte(&dato); //en el puerto D se ve el valor leído
desde la variable
//dato de la EEPROM AVR
// i=0;
while(1) //ciclo del programa
{
//nada por ahora
while (!(PINB&(1<<PB0))){
PORTB = ((0 << PB3));
}
i++;
eeprom_write_byte(&dato,i); //en la variable dato de la EEPROM AVR

eeprom_write_byte((uint8_t*) 3,i);
//se escribe el entero i
PORTB = ((1 << PB3)); //asignar 1 al puerto b3
_delay_ms (50L);
while(PINB&(1<<PB0)){}
}
}

void iniciar_usart(){
UCSR0B=0b00011000; //transmisión y recepción habilitados a 8 bits
UCSR0C=0b00000110; //asíncrono, sin bit de paridad, 1 bit de parada a 8
bits
UBRR0=51; //para una velocidad de 9600 baudios con un oscilador de
8Mhz

}
//PARA MÁS INFORMACIÓN http://microcontroladores-
mrelberni.com/eeprom-avr-memoria-interna/

13. El código anterior ejecutan en gnu-toolchain, y su archivo .hex lo cargan en el

microcontrolador en proteus para observar su funcionamiento.

REPORTE:
1) Elaborar un código en proteus, en el cual se escriba un nuevo
valor en un nuevo espacio de memoria eprom cada vez que el
usuario presiones un botón conectado a cualquier pin digital.
(Use código de gnu-toolchain)
2) Capturas de la ejecución en el simulador proteus de al menos 4
estados.
3) Conclusiones
4) Recomendaciones