Hola controlero o controlera, hoy vamos a ver como usar la EEPROM Interna PIC para poder almacenar datos cruciales en nuestros proyectos con microcontroladores.
Antes de comenzar, te invito a que veas el CURSO GRATIS DE MICROCONTROLADORES PIC
EEPROM INTERNA PIC
El microcontrolador tiene memoria eeprom interna donde almacenar información en esta memoria tiene la gran ventaja de que los datos almacenados en ésta no se borraran a menos que se sobrescriba sobre ellos, es decir la información almacenada allí, no se borrara así se desenergice el microcontrolador. Aunque esta memoria es limitada es de gran utilidad en algunos controles. Te voy a mostrar como guardar datos en la memoria EEPROM del PIC CCS.
En esta entrada vas a aprender como usar la memoria eeprom del pic 16f877a, 16f887, 18f4550 entre otros. El procedimiento es el mismo, sin importar el PIC que utilices, lo único que deberás hacer es cambiar en el encabezado la librería del PIC que estes utilizando.
Tambien podria interesarte el conocer como almacenar datos en la 👉 memoria eeprom externa del PIC cuando no tenemos el suficiente espacio en la memoria interna
Como guardar datos en la memoria EEPROM del PIC CCS
Estas sencillas instrucciones son las que debemos usar si lo que deseamos es guardar o almacenar datos en la memoria EEPROM del PIC usando PIC C Compiler CCS.
Características de la Memoria EEPROM
Antes de comenzar es necesario entender como está conformada la memoria EEPROM dentro del microcontrolador PIC. Para posteriormente proceder a grabar datos en ella.
Cada microcontrolador tiene un tamaño específico de memoria EEPROM la cual debe ser consultada en su datasheet.
Esta memoria está segmentada a 1 byte por dirección (celda). La lista a continuación ilustra la cantidad de memoria disponible para microcontroladores utilizados en nuestro curso de PIC con CCS C.
- PIC16F887 – 256 bytes
- PIC16F877A – 256 bytes
- PIC18F4550 – 256 bytes
A modo de ejemplo, en la siguiente imagen podemos ver como se distribuye la memoria EEPROM en estos microcontroladores:
⚠️ ATENCIÓN ⚠️
Las memorias EEPROM tienen una vida útil de aproximadamente 100000 escritas por cada una de las celdas de la memoria del PIC. Por lo que no puedes indiscriminadamente estar grabando en esta memoria constantemente porque vas a alcanzar ese límite.
Por eso almacena los datos de tu programa en periodos espaciados en el tiempo, o cuando algún evento especifico suceda.
También es una buena práctica no utilizar solo una celda, si no que por el contrario utilizar las 256 celdas y cuando estas estén llenas, volver a comenzar desde la celda cero.
Escribir memoria EEPROM del PIC
La instrucción para almacenar información en la memoria eeprom interna es la siguiente:
WRITE_EEPROM(dirección, valor)
dirección: Es un valor que comienza de 0 hasta le tamaño de la memoria del microcontrolador empleado. Ejemplo: 16F887 va de 0 a 255.
Valor: Es un byte, el cual será almacenado en la dirección especificada.
Leer memoria EEPROM del PIC
La instrucción para leer información en la memoria eeprom interna es la siguiente:
READ_EEPROM(dirección)
dirección: Es un valor que comienza de 0 hasta le tamaño de la memoria del microcontrolador empleado. Ejemplo: 16F887 va de 0 a 255.
Como ves el uso de la memoria EEPROM del PIC es muy sencillo, y una ves veas el fabuloso ejemplo de implementación tendrás las bases para crear tu propio proyecto!! Pues ya sabes como guardar datos en el PIC y que estos no se borren después de que dejes de alimentarlo.
Guardar int16, int32 o float en la EEPROM Interna con PIC
En ocasiones podemos querer guardar números con signos o números que ocupen más de 8 bits. Recordemos que la memoria interna solo permite datos de 0 a 255. Pero si necesitamos números mayores a esos?
Para eso, podremos en lugar de almacenar los datos en 1 celda, lo haremos en 2 celdas.
Para eso usaremos las instrucciones del CCS conocidas como make8(), make16() y make32().
Cuando tenemos un int16, lo que hacemos es dividirlo en 2 datos de 8 bits con make8().
int8 Data_h, Data_L; int16 DataLong; //Dato que se desea almacenar de 16bits Data_H=make8(DataLong,1); Data_L=make8(DataLong,0); WRITE_EEPROM(0,Data_H); WRITE_EEPROM(1,Data_L);
Luego cuando queramos leer esos datos, los leemos en dos variables int8 y los juntamos nuevamente en una variable int16 usando la función make16().
int8 Data_h, Data_L; int16 DataLong; Data_H=READ_EEPROM(0); Data_L=READ_EEPROM(1); DataLong=make16(Data_H,Data_L);
el mismo procedimiento puede ser aplicado con un int32 que posee 4 bytes, para eso podemos usar la instrucción make32(), y utilizar 4 bytes de la memoria eeprom.
int8 Data_0, Data_1, Data_2, Data_3; int32 DataLong; //Dato que se desea almacenar de 32bits Data_3=make32(DataLong,3); Data_2=make32(DataLong,2); Data_1=make32(DataLong,1); Data_0=make32(DataLong,0); WRITE_EEPROM(0,Data_0); WRITE_EEPROM(1,Data_1); WRITE_EEPROM(2,Data_2); WRITE_EEPROM(3,Data_3);
Luego cuando queramos leer esos datos provenientes del int32, los leemos en cuatro variables int8 y los juntamos nuevamente en una variable int32 usando la función make32().
int8 D_0, D_1, D_2, D_3; int32 DataLong; D_0=READ_EEPROM(0); D_1=READ_EEPROM(1); D_2=READ_EEPROM(2); D_3=READ_EEPROM(3); DataLong = make32(D_3, D_2, D_1, D_0);
El siguiente es un ejemplo de dos funciones de cómo leer y escribir un número de punto flotante (FLOAT) desde / hacia EEPROM. El mismo concepto se puede utilizar para estructuras, matrices o cualquier otro tipo.
- n es el desplazamiento en la EEPROM para almacenar cada valor flotante.
- Por ejemplo: Si se almacena un flotante en la primera posición, n=0, entonces tenga en cuenta que el segundo flotante debería guardarlo en la cuarta posición, n=4 y el tercer flotante debe guardarlo en la octava posición, n=8. Esto lo debes considerar en tu lógica de programación para evitar sobre escribir datos previos.
//Escribir en la EEPROM
WRITE_FLOAT_EEPROM(long int n, float data) {
int i;
for (i = 0; i < 4; i++)
write_eeprom(i + n, *((int8*)&data + i) ) ;
}
//Leer en la EEPROM
float READ_FLOAT_EEPROM(long int n) {
int i;
float data;
for (i = 0; i < 4; i++)
*((int8*)&data + i) = read_eeprom(i + n);
return(data);
}
Memoria EEPROM PIC
Para entender un poco mejor este concepto de como usar la memoria eeprom del pic 16f877a, pic 18f4550, pic 16f887, etc lo haremos a través de los siguientes ejemplos:
Primero, antes que nada debes saber que al final de este post, se encuentra el código gratuito para que aprendas a usar la memoria EEPROM interna del microcontrolador PIC, el ejemplo está hecho con el PIC16F887, sin embargo si deseas hacerlo con otro PIC, simplemente cambias el encabezado por las siguientes instrucciones
Memoria EEPROM interna pic 18f4550 o familia 18F
#include <18f4550.h> #byte porta = 0xf80 // Identificador para el puerto A. #byte portb = 0xf81 // Identificador para el puerto B. #byte portc = 0xf82 // Identificador para el puerto C. #byte portd = 0xf83 // Identificador para el puerto D. #byte porte = 0xf84 // Identificador para el puerto E.
De esta forma conseguiras almacenar los datos en la memoria eeprom pic 18f4550.
Memoria EEPROM interna pic 16f877a o familia 16F
#include <16f877a.h>;
EEPROM PIC CCS
Para esto Preparé el siguiente video donde te explico la teoria de usar la memoria interna EEPROM del PIC, te explico el código que encontrarás en la parte inferior de la página, y te explico como podemos simularlo para que lo lleves a la práctica. No olvides suscribirte a mi canal de youtube dando click en el siguiente botón, para que puedas recibir toda la información que allí voy publicando.
Como guardar datos en la memoria EEPROM del pic ccs
Modificar el ejemplo visto en la entrada anterior, donde se solicitaba una contraseña por medio del teclado telefónico y se visualizaba en el LCD en forma de asteriscos.
La idea es entonces que el usuario pueda modificar la contraseña de acceso, pero para que haga esto, el programa deberá validar que el usuario conozca la contraseña actual.
La nueva contraseña debe escribir en la memoria EEPROM del PIC con el objetivo de que esta no se borre cuando el microcontrolador es des-energizado. (# Es el enter para la clave y * es la tecla para cambiar la clave)
Nota: Para saber cual es la clave actual dentro del proteus, cargar en el microcontrolador el archivo .cof en lugar del archivo .hex (como se muestra en el video), Luego le dan simular y seguidamente le dan pause. Les debe salir unas ventanas con el codigo del pic y con las variables. Buscar la variable que se llama contra, el valor de dicha variable es la contraseña.
Uso de la memoria EEPROM del PIC
Descargar el código de implementación de como usar la memoria eeprom del pic es muy simple, solo debes compartir el contenido de este POST utilizando uno de los siguientes tres botones que se encuentran aqui abajo.
Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:
👉 Invitar a Sergio a un Café ☕️
Que esten muy bien, nos vemos en la siguiente entrada.