TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: juanes790415 en 11 de Octubre de 2016, 01:25:04

Título: Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes790415 en 11 de Octubre de 2016, 01:25:04

Cordial saludo. Les consulto si es posible almacenar valores por encima de 256 en la memoria EEPROM de un microcontrolador PIC16F1937, el cual posee según su datasheep 256 bytes de memoria eeprom. Necesito almacenar valores de 0 a 999 y solo la memoria eeprom me almacena hasta el numero 256. Estoy utilizando lenguaje C - MPLABX.

Código para memoria eeprom

volatile unsigned char W=0x09;

W=eeprom_read(0x09); solo me almacena hasta 256
cont=W;

Saludos.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: manwenwe en 11 de Octubre de 2016, 04:16:14

Puedes grabar en FLASH en vez de EEPROM, la pega es que el número grabaciones es 10 veces menor (100K en vez de 1M). Mira el capitulo 23 del datasheet.

Saludos.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: KILLERJC en 11 de Octubre de 2016, 08:20:14

La flash posee la desventaja de tener que borrar toda la pagina, asi que no veo por que seria mejor que la EEPROM. Personalmente no lo usaria para un contador, tenes que recordar que se tiene limitados numeros de grabaciones.

Lo que tenes que hacer juanes790415 es usar una union.

Código: C

1. union Data_EE
2. {
3.         unsigned int valor16;
4.         struct Abytes
5.         {
6.                 unsigned char   valor8_1;
7.                 unsigned char   valor8_2;
8.         }
9. }
10.  
11.  
12. // Declaracion de Varaible MyVar
13. union Data_EE MyVar;
14.  
15.  
16. //Uso:
17.  
18. func1(void)
19. {
20.         MyVar.valor16 = 999;
21.         GrabarEEPROM(MyVar.valor8_1, 0x00);
22.         GrabarEEPROM(MyVar.valor8_2, 0x01);
23. }

Espero no haberme equivocado :P

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: manwenwe en 11 de Octubre de 2016, 08:56:36

Perdón, me lié: entendí que querías almacenar más de 256 valores, no que no te cabían numeros más allá del 255. Mejor lo que dice KillerJC.

Saludos.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes790415 en 12 de Octubre de 2016, 01:02:05

Cita de: KILLERJC en 11 de Octubre de 2016, 08:20:14

La flash posee la desventaja de tener que borrar toda la pagina, asi que no veo por que seria mejor que la EEPROM. Personalmente no lo usaria para un contador, tenes que recordar que se tiene limitados numeros de grabaciones.

Lo que tenes que hacer juanes790415 es usar una union.

Código: C

1. union Data_EE
2. {
3.         unsigned int valor16;
4.         struct Abytes
5.         {
6.                 unsigned char   valor8_1;
7.                 unsigned char   valor8_2;
8.         }
9. }
10.  
11.  
12. // Declaracion de Varaible MyVar
13. union Data_EE MyVar;
14.  
15.  
16. //Uso:
17.  
18. func1(void)
19. {
20.         MyVar.valor16 = 999;
21.         GrabarEEPROM(MyVar.valor8_1, 0x00);
22.         GrabarEEPROM(MyVar.valor8_2, 0x01);
23. }

Espero no haberme equivocado :P

Hola amigo. Te consulto como puedo ingresar el código que me recomiendas para unir la eeprom.

Este es el programa donde debo guardar los valores hasta 999.

Este es el código que llevo hasta el momento.

#include "mcc_generated_files/mcc.h"
#include <xc.h>  //se incluye librerias xc8
#include <stdio.h>
#include <stdlib.h>
#include <htc.h>
# define LCD_RS RD6
# define LCD_EN RD7
#define LCD_DATA PORTB

char centenas, decenas, unidades; //defino variables char.solo van de 0 a 9
int cont=-1, aux=0; //defino variable int. van desde 0 hasta 999
int dato=0;



volatile unsigned char W=0x09;

void lcd_init (void); //inicializacion del LCD
void set_lcd (void);  //Configuracion del LCD
void lcd_puts(const char * s); //cadenas de caracteres al LCD
void lcd_putch(char c); //
void lcd_goto(unsigned char pos); // Direcciones en el LCD
void lcd_write(unsigned char c); //Escritura en el LCD
void binbcd ()



{
  centenas=cont/100;
  decenas=(cont%100)/10;
  unidades=cont%10;
}

void main(void)

{
SYSTEM_Initialize();
//__EEPROM_DATA(0X09,0X00,0X00,0X00,0X00,0X00,0X00,0X00);

   {
W=eeprom_read(0x09);
cont=W;
}
lcd_init();  //LLAMO FUNCION DE INICIALIZACION
   while(1) //ciclo  while para no hacer nada.ya mostro el mesaje
      {
   lcd_goto(0);   // selecciono primera línea
   lcd_puts("LA CARGA ES 500 ");
          lcd_goto(0x40);   // Selecciono segunda línea
   lcd_puts("CANTIDAD:   ");  //mensaje para la segunda linea

        while(1)
        {
            while(cont<300)
           {
               if(RD5==0) //SUICHE S2
               {
                   __delay_ms(100);
                   cont=-1;
              binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(100);


               }
               else

               if(RD3==1) //SENSOR S4

          {

                   break;
         }


              RA0=1;
           __delay_ms(100);
              RA0=0;
                cont++;
                eeprom_write(0x09,cont);
                binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(100);    //Incremento cuenta cada 500 ms


            }
        }
}
}
void lcd_init(void) //funcion de inicializacion del LCD
{
LCD_DATA=2; // se manda el dato 2 al puerto para iniciar el LCD
set_lcd(); // se la funcion de configuracion
LCD_DATA=56; // mando el dato 56 al puerto para 8 bits,2 lineas y 5x7
set_lcd();   // llamo funcion de configuracion
LCD_DATA=12; // mando el dato 12 para prender el LCD con cursor
set_lcd();
LCD_DATA=6;
set_lcd();
LCD_DATA=1;
set_lcd();
}

void set_lcd (void) // funcion de configuracion
{
    LCD_RS=0; //RS en cero para indicar al LCD que es configuracion
    LCD_EN=1; // se habilita la operacion
   __delay_ms(2); //retardo necesario para la operacion
    LCD_EN=0; // termina la operacion
}
//Voy a una poscion especifica del LCD
void lcd_goto(unsigned char pos) // funcion de direcciones
{
   LCD_RS = 0; //RS en cero para configuracion
   lcd_write(0x80+pos); //sumo 80H a pos que viene con un dato
}
void lcd_write(unsigned char c) // funcion de escritura en el LCD
{
   LCD_EN=1;//habilito la operacion
   LCD_DATA = ( c );//mando al puerto el dato que hay en C.
   __delay_ms(2); //retardo necesario para la operacion
   LCD_EN=0;// termino la operacion
}
/* Escribo una cadena de caracteres en el LCD */
void lcd_puts(const char * s)
{
   LCD_RS = 1; //habilito operacion
   while(*s) //mientras haya caracteres en la cadena enviada
      lcd_write(*s++); //pase al siguiente
}
/* Escribo un caracter en el LCD */
void lcd_putch(char c)
{
   LCD_RS = 1;   //habilito escritura en LCD
   lcd_write( c );
}

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: KILLERJC en 12 de Octubre de 2016, 01:40:15

Me parece que lo mas simple para vos es que tengas una variable unsigned char para cada digito.

Código: [Seleccionar]

Centenas = 9;
Decenas = 9;
Unidades = 9;
Eso si, cuando incrementes las unidades tendras que preguntar si es igual a 10 e incrementar las decenas y luego las centenas

Código: C

1. Unidades++;
2. if(Unidades == 10) { Decenas++; Unidades = 0;}
3. if(Decenas == 10) { Centenas++; Decenas = 0;}
4. if(Centenas == 10) { Centenas = 0; }

Lo mismo para cuando restas

Código: C

1. Unidades--;
2. if(Unidades == 255) { Decenas--; Unidades = 0;}
3. if(Decenas == 255) { Centenas--; Decenas = 0;}
4. if(Centenas == 255) { Centenas = 0; }

luego para grabar/leer en la EEPROM lo haces 1 por 1, Suponete que la posicion 0x00 pertenece a las unidades, 0x01 a las decenas y 0x02 a las centenas.

Código: C

1. //Lectura:
2.  
3. Unidades = eeprom_read(0x00);
4. Decenas = eeprom_read(0x01);
5. Centenas = eeprom_read(0x02);
6.  
7. //Escritura
8.  
9. eeprom_write(0x00,Unidades);
10. eeprom_write(0x01,Decenas);
11. eeprom_write(0x02,Centenas);

------------------------------------------------------------

Lo mejor es usar la union que comente antes y para leerlo te quedaria asi:

Código: C

1. MyVar.valor8_1 = eeprom_read(0x00);
2. MyVar.valor8_2 = eeprom_read(0x01);

Y para guardarlo asi:

Código: C

1. eeprom_write(0x00,MyVar.valor8_1);
2. eeprom_write(0x01,MyVar.valor8_2);

Lo bueno que para incrementar y decrementar es asi:

Código: C

1. //Incremento
2. MyVar.valor16++;
3.  
4. //Decremento
5. MyVar.valor16--;

Para todo lo demas existe san google para que veas donde tenes que poner cada cosa, a pesar que yo ya lo hice.
Podes crearte una funcion como:

Código: C

1. void GrabarEEPROM16bits (uint16_t Dato, uint8_t Direccion)
2. {
3.         union Data_EE temp;
4.         temp.valor16 = Dato;
5.         eeprom_write(Direccion,temp.valor8_1);
6.         eeprom_write(Direccion + 1,temp.valor8_2);
7. }
8.  
9. uint16_t LeerEEPROM16bits (uint8_t Direccion)
10. {
11.         union Data_EE temp;
12.         temp.valor8_1 = eeprom_read(0x00);
13.         temp.valor8_2 = eeprom_read(0x01);
14.         return temp.valor16;
15. }

Para usarlo:

Código: C

1. //Variable de 16bits que usamos para mantener el contador
2.         uint16_t Contador=500;
3.  
4.         //Grabado
5.         GrabarEEPROM16bits(Contador,0x00);      // Graba en la EEPROM ocupando los espacios 0x00 y 0x01
6.  
7.         //Lectura
8.         Contador = LeerEEPROM16bits(0x00);      //Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: delirio en 12 de Octubre de 2016, 12:18:00

Buenas gente, leyendo la respuesta de KILLERJC me surge una duda...
cuando restas, no debería ser
Saludos

 

Código: [Seleccionar]

Unidades--;
if(Unidades == 255) { Decenas--; Unidades = 9;}
if(Decenas == 255) { Centenas--; Decenas = 9;}
if(Centenas == 255) { Centenas = 9; }


Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: KILLERJC en 12 de Octubre de 2016, 12:33:25

Tenes razon, el copy & paste me hizo mal. Es correcto lo que decis.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes79 en 12 de Octubre de 2016, 16:56:03

Gracias amigo KLLERJC por tus respuestas tan oportunas y significativas. También le doy gracias a los otros usuarios que me han colaborado con sus respuestas.

Adicionando el código que me recomiendas para unir la eeprom, obtengo el siguiente código.

Las dos lineas que aparecen en rojo tienen algún error, porque las omito en el compilador y no me sale ningún error.





#include "mcc_generated_files/mcc.h"
#include <xc.h>  //se incluye librerias xc8
#include <stdio.h>
#include <stdlib.h>
#include <htc.h>
# define LCD_RS RD6
# define LCD_EN RD7
#define LCD_DATA PORTB
#define Lib_Int_EEProm.c
char centenas, decenas, unidades; //defino variables char.solo van de 0 a 9


unsigned char   valor8_1;
unsigned char   valor8_2;
unsigned char centenas = 9;
unsigned char decenas = 9;
unsigned char unidades = 9;
uint16_t cont = 0;


void lcd_init (void); //inicializacion del LCD
void set_lcd (void);  //Configuracion del LCD
void lcd_puts(const char * s); //cadenas de caracteres al LCD
void lcd_putch(char c); //
void lcd_goto(unsigned char pos); // Direcciones en el LCD
void lcd_write(unsigned char c); //Escritura en el LCD
void binbcd ()



{
  centenas=cont/100;
  decenas=(cont%100)/10;
  unidades=cont%10;
}

void main(void)
{
   
unidades = eeprom_read(0x00);
decenas =  eeprom_read(0x01);
centenas = eeprom_read(0x02);

cont = read_16bits_eeprom(0x00);      //Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador

SYSTEM_Initialize();

lcd_init();  //LLAMO FUNCION DE INICIALIZACION
   while(1) //ciclo  while para no hacer nada.ya mostro el mesaje
      {
   lcd_goto(0);   // selecciono primera línea
   lcd_puts("LA CARGA ES 1000 ");
          lcd_goto(0x40);   // Selecciono segunda línea
   lcd_puts("CANTIDAD:   ");  //mensaje para la segunda linea

        while(1)
        {
            while(cont<1000)
           {
               if(RD5==0) //Suciche para poner el contador a cero
               {
                   __delay_ms(10);
                   cont=-1;
              binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(10);


               }
               else

               if(RD3==1) //S4 simula un sensor para activar el conteo

          { break;}


              RA0=1;
           __delay_ms(100);
              RA0=0;
                cont++;
               // eeprom_write(0x09,cont);

                 if(unidades == 10)
                 { decenas++; unidades = 0;}

                 else if(decenas == 10)
                 { centenas++; decenas = 0;}

                 else if (centenas == 10)
                 { centenas = 0; }

                eeprom_write(0x00,unidades);
                eeprom_write(0x01,decenas);
                eeprom_write(0x02,centenas);
                binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(100);    //Incremento cuenta cada 500 ms

               
      write_16bits_eeprom(cont,0x00);       //Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador
            }
        }
    }
}
void lcd_init(void) //funcion de inicializacion del LCD
{
LCD_DATA=2; // se manda el dato 2 al puerto para iniciar el LCD
set_lcd(); // se la funcion de configuracion
LCD_DATA=56; // mando el dato 56 al puerto para 8 bits,2 lineas y 5x7
set_lcd();   // llamo funcion de configuracion
LCD_DATA=12; // mando el dato 12 para prender el LCD con cursor
set_lcd();
LCD_DATA=6;
set_lcd();
LCD_DATA=1;
set_lcd();
}

void set_lcd (void) // funcion de configuracion
{
    LCD_RS=0; //RS en cero para indicar al LCD que es configuracion
    LCD_EN=1; // se habilita la operacion
   __delay_ms(2); //retardo necesario para la operacion
    LCD_EN=0; // termina la operacion
}
//Voy a una poscion especifica del LCD
void lcd_goto(unsigned char pos) // funcion de direcciones
{
   LCD_RS = 0; //RS en cero para configuracion
   lcd_write(0x80+pos); //sumo 80H a pos que viene con un dato
}
void lcd_write(unsigned char c) // funcion de escritura en el LCD
{
   LCD_EN=1;//habilito la operacion
   LCD_DATA = ( c );//mando al puerto el dato que hay en C.
   __delay_ms(2); //retardo necesario para la operacion
   LCD_EN=0;// termino la operacion
}
/* Escribo una cadena de caracteres en el LCD */
void lcd_puts(const char * s)
{
   LCD_RS = 1; //habilito operacion
   while(*s) //mientras haya caracteres en la cadena enviada
      lcd_write(*s++); //pase al siguiente
}
/* Escribo un caracter en el LCD */
void lcd_putch(char c)
{
   LCD_RS = 1;   //habilito escritura en LCD
   lcd_write( c );
}

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: KILLERJC en 12 de Octubre de 2016, 23:06:43

Código: C

1. #define Lib_Int_EEProm.c

Mas un Include, no un define.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: spaiderman80 en 12 de Octubre de 2016, 23:50:47

Cita de: KILLERJC en 12 de Octubre de 2016, 23:06:43

Código: C

1. #define Lib_Int_EEProm.c

Mas un Include, no un define.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes79 en 12 de Octubre de 2016, 23:54:26

Cita de: KILLERJC en 12 de Octubre de 2016, 23:06:43

Código: C

1. #define Lib_Int_EEProm.c

Mas un Include, no un define.

Gracias amigo KILLERJC

tengo problemas con estas dos instrucciones:

GrabarEEPROM16bits(Contador,0x00); //instruccion recomendada. Tiene errores
cont = read_16bits_eeprom(0x00); //instruccion cambiada. sigue con errores

Contador = LeerEEPROM16bits(0x00); //instruccion recomendada
cont = read_16bits_eeprom(0x00);   // sigue con errores

Te consulto cual puede ser el error que me sale y no me deja compilar el programa.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: KILLERJC en 12 de Octubre de 2016, 23:57:35

Citar

Te consulto cual puede ser el error que me sale y no me deja compilar el programa.

Mas que consultarme a mi, deberiamos consultarte a vos, ya que deberias:

- Copiar el error que te da aca, para saber DONDE esta el error.
- Copiar las funciones que hiciste, porque no sabemos el codigo de las mismas.

Para poder determinar que esta fallando.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes79 en 13 de Octubre de 2016, 00:00:15

Cita de: juanes79 en 12 de Octubre de 2016, 23:54:26

Cita de: KILLERJC en 12 de Octubre de 2016, 23:06:43

Código: C

1. #define Lib_Int_EEProm.c

Mas un Include, no un define.

Gracias amigo KILLERJC

tengo problemas con estas dos instrucciones:

GrabarEEPROM16bits(Contador,0x00); //instruccion recomendada. Tiene errores
cont = read_16bits_eeprom(0x00); //instruccion cambiada. sigue con errores

Contador = LeerEEPROM16bits(0x00); //instruccion recomendada
cont = read_16bits_eeprom(0x00);   // sigue con errores

Te consulto cual puede ser el error que me sale y no me deja compilar el programa.

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes79 en 13 de Octubre de 2016, 00:02:22

Cita de: juanes79 en 13 de Octubre de 2016, 00:00:15

Cita de: juanes79 en 12 de Octubre de 2016, 23:54:26

Cita de: KILLERJC en 12 de Octubre de 2016, 23:06:43

Código: C

1. #define Lib_Int_EEProm.c

Mas un Include, no un define.

Gracias amigo KILLERJC

tengo problemas con estas dos instrucciones:

1. GrabarEEPROM16bits(Contador,0x00); //instruccion recomendada. Tiene errores
    cont = read_16bits_eeprom(0x00); //instruccion cambiada. sigue con errores

2. Contador = LeerEEPROM16bits(0x00); //instruccion recomendada
    cont = read_16bits_eeprom(0x00);   // sigue con errores

Te consulto cual puede ser el error que me sale y no me deja compilar el programa.

También me sale error al agregar estas dos instrucciones

1. MyVar.valor8_1 = eeprom_read(0x00);
2. MyVar.valor8_2 = eeprom_read(0x01);

Este es el programa actual en MPLABX

// librerias
#include "mcc_generated_files/mcc.h"
#include <xc.h>  //se incluye librerias xc8
#include <stdio.h>
#include <stdlib.h>
#include <htc.h>
# define LCD_RS RD6
# define LCD_EN RD7
#define LCD_DATA PORTB
#define Lib_Int_EEProm.c
char centenas, decenas, unidades; //defino variables char.solo van de 0 a 9

// declaracion de variables
union Data_EE MyVar; //main.c:15: error: (1442) type used in variable definition is incomplete
                    //main.c:15: warning: (374) missing basic type; int assumed




unsigned int valor16;
unsigned char   valor8_1;
unsigned char   valor8_2;
unsigned char centenas = 9;
unsigned char decenas = 9;
unsigned char unidades = 9;
uint16_t cont = 0;

// funciones
void lcd_init (void); //inicializacion del LCD
void set_lcd (void);  //Configuracion del LCD
void lcd_puts(const char * s); //cadenas de caracteres al LCD
void lcd_putch(char c); //
void lcd_goto(unsigned char pos); // Direcciones en el LCD
void lcd_write(unsigned char c); //Escritura en el LCD
void binbcd ()



{
  centenas=cont/100;
  decenas=(cont%100)/10;
  unidades=cont%10;
}

void main(void)
{
   
unidades = eeprom_read(0x00);
decenas =  eeprom_read(0x01);
centenas = eeprom_read(0x02);
MyVar.valor8_1 = eeprom_read(0x00); //tengo duda si esta instruccion va aqui
MyVar.valor8_2 = eeprom_read(0x01); //tengo duda si esta instruccion va aqui


cont = read_16bits_eeprom(0x00);//Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador
// me sale el siguiente error




SYSTEM_Initialize(); //inicia el sistema

lcd_init();  //LLAMO FUNCION DE INICIALIZACION
   while(1) //ciclo  while para no hacer nada.ya mostro el mesaje
      {
   lcd_goto(0);   // selecciono primera línea
   lcd_puts("LA CARGA ES 1000 ");
          lcd_goto(0x40);   // Selecciono segunda línea
   lcd_puts("CANTIDAD:   ");  //mensaje para la segunda linea

        while(1)
        {
            while(cont<1000)
           {
               if(RD5==0) //Suciche para poner el contador a cero
               {
                   __delay_ms(10);
                   cont=-1;
              binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(10);


               }
               else

               if(RD3==1) //S4 simula un sensor para activar el conteo

          { break;}


              RA0=1;
           __delay_ms(100);
              RA0=0;
                cont++;
               // eeprom_write(0x09,cont);

                 if(unidades == 10)
                 { decenas++; unidades = 0;}

                 else if(decenas == 10)
                 { centenas++; decenas = 0;}

                 else if (centenas == 10)
                 { centenas = 0; }

                eeprom_write(0x00,unidades);
                eeprom_write(0x01,decenas);
                eeprom_write(0x02,centenas);
                eeprom_write(0x00,MyVar.valor8_1);
                eeprom_write(0x01,MyVar.valor8_2);
                binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(100);    //Incremento cuenta cada 500 ms

               
       write_16bits_eeprom(cont,0x00);       //Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador
            }
        }
    }
}
void lcd_init(void) //funcion de inicializacion del LCD
{
LCD_DATA=2; // se manda el dato 2 al puerto para iniciar el LCD
set_lcd(); // se la funcion de configuracion
LCD_DATA=56; // mando el dato 56 al puerto para 8 bits,2 lineas y 5x7
set_lcd();   // llamo funcion de configuracion
LCD_DATA=12; // mando el dato 12 para prender el LCD con cursor
set_lcd();
LCD_DATA=6;
set_lcd();
LCD_DATA=1;
set_lcd();
}

void set_lcd (void) // funcion de configuracion
{
    LCD_RS=0; //RS en cero para indicar al LCD que es configuracion
    LCD_EN=1; // se habilita la operacion
   __delay_ms(2); //retardo necesario para la operacion
    LCD_EN=0; // termina la operacion
}
//Voy a una poscion especifica del LCD
void lcd_goto(unsigned char pos) // funcion de direcciones
{
   LCD_RS = 0; //RS en cero para configuracion
   lcd_write(0x80+pos); //sumo 80H a pos que viene con un dato
}
void lcd_write(unsigned char c) // funcion de escritura en el LCD
{
   LCD_EN=1;//habilito la operacion
   LCD_DATA = ( c );//mando al puerto el dato que hay en C.
   __delay_ms(2); //retardo necesario para la operacion
   LCD_EN=0;// termino la operacion
}
/* Escribo una cadena de caracteres en el LCD */
void lcd_puts(const char * s)
{
   LCD_RS = 1; //habilito operacion
   while(*s) //mientras haya caracteres en la cadena enviada
      lcd_write(*s++); //pase al siguiente
}
/* Escribo un caracter en el LCD */
void lcd_putch(char c)
{
   LCD_RS = 1;   //habilito escritura en LCD
   lcd_write( c );
}

Errores que me salen en el programa:

main.c:15: error: (1442) type used in variable definition is incomplete
main.c:52: error: (198) undefined struct/union "Data_EE"
main.c:52: error: (182) illegal conversion between types
unsigned char -> union Data_EE
main.c:53: error: (198) undefined struct/union "Data_EE"
main.c:53: error: (182) illegal conversion between types
unsigned char -> union Data_EE
main.c:56: warning: (361) function declared implicit int
main.c:116: error: (198) undefined struct/union "Data_EE"
main.c:116: error: (182) illegal conversion between types
union Data_EE -> unsigned char
main.c:116: error: (181) non-scalar types can't be converted to other types
main.c:117: error: (198) undefined struct/union "Data_EE"
main.c:117: error: (182) illegal conversion between types
union Data_EE -> unsigned char
main.c:117: error: (181) non-scalar types can't be converted to other types
main.c:128: warning: (361) function declared implicit int
(908) exit status = 1
make[2]: *** [build/default/production/main.p1] Error 1
make[1]: *** [.build-conf] Error 2
make: *** [.build-impl] Error 2

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes79 en 13 de Octubre de 2016, 11:12:37

Nuevamente gracias por guiarme en este proceso de aprendizaje con ustedes. Especialmente al usuario KILLERJC

Este es el programa que tengo en el momento para tratar de almacenar en la memoria EEPROM el valor del contador, el cual va de 0 a 999.

Programa en MPLABX

// librerias
#include "mcc_generated_files/mcc.h"
#include <xc.h>  //se incluye librerias xc8
#include <stdio.h>
#include <stdlib.h>
#include <htc.h>
# define LCD_RS RD6
# define LCD_EN RD7
#define LCD_DATA PORTB
#define Lib_Int_EEProm.c
char centenas, decenas, unidades; //defino variables char.solo van de 0 a 9

// declaracion de variables
union Data_EE MyVar; //main.c:15: error: (1442) type used in variable definition is incomplete
                    //main.c:15: warning: (374) missing basic type; int assumed




unsigned int valor16;
unsigned char   valor8_1;
unsigned char   valor8_2;
unsigned char centenas = 9;
unsigned char decenas = 9;
unsigned char unidades = 9;
uint16_t cont = 0;

// funciones
void lcd_init (void); //inicializacion del LCD
void set_lcd (void);  //Configuracion del LCD
void lcd_puts(const char * s); //cadenas de caracteres al LCD
void lcd_putch(char c); //
void lcd_goto(unsigned char pos); // Direcciones en el LCD
void lcd_write(unsigned char c); //Escritura en el LCD
void binbcd ()



{
  centenas=cont/100;
  decenas=(cont%100)/10;
  unidades=cont%10;
}

void main(void)
{
   
unidades = eeprom_read(0x00);
decenas =  eeprom_read(0x01);
centenas = eeprom_read(0x02);
MyVar.valor8_1 = eeprom_read(0x00); //tengo duda si esta instruccion va aqui
MyVar.valor8_2 = eeprom_read(0x01); //tengo duda si esta instruccion va aqui


cont = read_16bits_eeprom(0x00);//Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador
// me sale el siguiente error




SYSTEM_Initialize(); //inicia el sistema

lcd_init();  //LLAMO FUNCION DE INICIALIZACION
   while(1) //ciclo  while para no hacer nada.ya mostro el mesaje
      {
   lcd_goto(0);   // selecciono primera línea
   lcd_puts("LA CARGA ES 1000 ");
          lcd_goto(0x40);   // Selecciono segunda línea
   lcd_puts("CANTIDAD:   ");  //mensaje para la segunda linea

        while(1)
        {
            while(cont<1000)
           {
               if(RD5==0) //Suciche para poner el contador a cero
               {
                   __delay_ms(10);
                   cont=-1;
              binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(10);


               }
               else

               if(RD3==1) //S4 simula un sensor para activar el conteo

          { break;}


              RA0=1;
           __delay_ms(100);
              RA0=0;
                cont++;
               // eeprom_write(0x09,cont);

                 if(unidades == 10)
                 { decenas++; unidades = 0;}

                 else if(decenas == 10)
                 { centenas++; decenas = 0;}

                 else if (centenas == 10)
                 { centenas = 0; }

                eeprom_write(0x00,unidades);
                eeprom_write(0x01,decenas);
                eeprom_write(0x02,centenas);
                eeprom_write(0x00,MyVar.valor8_1);
                eeprom_write(0x01,MyVar.valor8_2);
                binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(100);    //Incremento cuenta cada 500 ms

               
       write_16bits_eeprom(cont,0x00);       //Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador
            }
        }
    }
}
void lcd_init(void) //funcion de inicializacion del LCD
{
LCD_DATA=2; // se manda el dato 2 al puerto para iniciar el LCD
set_lcd(); // se la funcion de configuracion
LCD_DATA=56; // mando el dato 56 al puerto para 8 bits,2 lineas y 5x7
set_lcd();   // llamo funcion de configuracion
LCD_DATA=12; // mando el dato 12 para prender el LCD con cursor
set_lcd();
LCD_DATA=6;
set_lcd();
LCD_DATA=1;
set_lcd();
}

void set_lcd (void) // funcion de configuracion
{
    LCD_RS=0; //RS en cero para indicar al LCD que es configuracion
    LCD_EN=1; // se habilita la operacion
   __delay_ms(2); //retardo necesario para la operacion
    LCD_EN=0; // termina la operacion
}
//Voy a una poscion especifica del LCD
void lcd_goto(unsigned char pos) // funcion de direcciones
{
   LCD_RS = 0; //RS en cero para configuracion
   lcd_write(0x80+pos); //sumo 80H a pos que viene con un dato
}
void lcd_write(unsigned char c) // funcion de escritura en el LCD
{
   LCD_EN=1;//habilito la operacion
   LCD_DATA = ( c );//mando al puerto el dato que hay en C.
   __delay_ms(2); //retardo necesario para la operacion
   LCD_EN=0;// termino la operacion
}
/* Escribo una cadena de caracteres en el LCD */
void lcd_puts(const char * s)
{
   LCD_RS = 1; //habilito operacion
   while(*s) //mientras haya caracteres en la cadena enviada
      lcd_write(*s++); //pase al siguiente
}
/* Escribo un caracter en el LCD */
void lcd_putch(char c)
{
   LCD_RS = 1;   //habilito escritura en LCD
   lcd_write( c );
}


Errores que salen después de  compilar este programa.

CLEAN SUCCESSFUL (total time: 295ms)
make -f nbproject/Makefile-default.mk SUBPROJECTS= .build-conf
make[1]: Entering directory `C:/Users/juan/MPLABXProjects/LCD.X'
make  -f nbproject/Makefile-default.mk dist/default/production/LCD.X.production.hex
make[2]: Entering directory `C:/Users/juan/MPLABXProjects/LCD.X'
"C:\Program Files\Microchip\xc8\v1.38\bin\xc8.exe" --pass1  --chip=16F1937 -Q -G  --double=24 --float=24 --opt=default,+asm,+asmfile,-speed,+space,-debug --addrqual=ignore --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf:multilocs --stack=compiled:auto:auto "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s"    -obuild/default/production/mcc_generated_files/pin_manager.p1  mcc_generated_files/pin_manager.c
"C:\Program Files\Microchip\xc8\v1.38\bin\xc8.exe" --pass1  --chip=16F1937 -Q -G  --double=24 --float=24 --opt=default,+asm,+asmfile,-speed,+space,-debug --addrqual=ignore --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf:multilocs --stack=compiled:auto:auto "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s"    -obuild/default/production/mcc_generated_files/mcc.p1  mcc_generated_files/mcc.c
"C:\Program Files\Microchip\xc8\v1.38\bin\xc8.exe" --pass1  --chip=16F1937 -Q -G  --double=24 --float=24 --opt=default,+asm,+asmfile,-speed,+space,-debug --addrqual=ignore --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf:multilocs --stack=compiled:auto:auto "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s"    -obuild/default/production/main.p1  main.c
main.c:15: error: (1442) type used in variable definition is incomplete
main.c:52: error: (198) undefined struct/union "Data_EE"
main.c:52: error: (182) illegal conversion between types
unsigned char -> union Data_EE
main.c:53: error: (198) undefined struct/union "Data_EE"
main.c:53: error: (182) illegal conversion between types
unsigned char -> union Data_EE
main.c:56: warning: (361) function declared implicit int
main.c:116: error: (198) undefined struct/union "Data_EE"
main.c:116: error: (182) illegal conversion between types
union Data_EE -> unsigned char
main.c:116: error: (181) non-scalar types can't be converted to other types
main.c:117: error: (198) undefined struct/union "Data_EE"
main.c:117: error: (182) illegal conversion between types
union Data_EE -> unsigned char
main.c:117: error: (181) non-scalar types can't be converted to other types
main.c:128: warning: (361) function declared implicit int
make[2]: *** [build/default/production/main.p1] Error 1
make[1]: *** [.build-conf] Error 2
(908) exit status = 1
make[2]: Leaving directory `C:/Users/juan/MPLABXProjects/LCD.X'
make[1]: Leaving directory `C:/Users/juan/MPLABXProjects/LCD.X'
make: *** [.build-impl] Error 2

BUILD FAILED (exit value 2, total time: 4s)

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: juanes79 en 13 de Octubre de 2016, 11:23:06

Gracias amigo KILLERJC por tus sabias respuestas.

Este es el código que tengo en el momento:

// librerias
#include "mcc_generated_files/mcc.h"
#include <xc.h>  //se incluye librerias xc8
#include <stdio.h>
#include <stdlib.h>
#include <htc.h>
# define LCD_RS RD6
# define LCD_EN RD7
#define LCD_DATA PORTB
#define Lib_Int_EEProm.c
char centenas, decenas, unidades; //defino variables char.solo van de 0 a 9

// declaracion de variables
union Data_EE MyVar; //main.c:15: error: (1442) type used in variable definition is incomplete
                    //main.c:15: warning: (374) missing basic type; int assumed




unsigned int valor16;
unsigned char   valor8_1;
unsigned char   valor8_2;
unsigned char centenas = 9;
unsigned char decenas = 9;
unsigned char unidades = 9;
uint16_t cont = 0;

// funciones
void lcd_init (void); //inicializacion del LCD
void set_lcd (void);  //Configuracion del LCD
void lcd_puts(const char * s); //cadenas de caracteres al LCD
void lcd_putch(char c); //
void lcd_goto(unsigned char pos); // Direcciones en el LCD
void lcd_write(unsigned char c); //Escritura en el LCD
void binbcd ()



{
  centenas=cont/100;
  decenas=(cont%100)/10;
  unidades=cont%10;
}

void main(void)
{
   
unidades = eeprom_read(0x00);
decenas =  eeprom_read(0x01);
centenas = eeprom_read(0x02);
MyVar.valor8_1 = eeprom_read(0x00); //tengo duda si esta instruccion va aqui
MyVar.valor8_2 = eeprom_read(0x01); //tengo duda si esta instruccion va aqui


cont = read_16bits_eeprom(0x00);//Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador
// me sale el siguiente error




SYSTEM_Initialize(); //inicia el sistema

lcd_init();  //LLAMO FUNCION DE INICIALIZACION
   while(1) //ciclo  while para no hacer nada.ya mostro el mesaje
      {
   lcd_goto(0);   // selecciono primera línea
   lcd_puts("LA CARGA ES 1000 ");
          lcd_goto(0x40);   // Selecciono segunda línea
   lcd_puts("CANTIDAD:   ");  //mensaje para la segunda linea

        while(1)
        {
            while(cont<1000)
           {
               if(RD5==0) //Suciche para poner el contador a cero
               {
                   __delay_ms(10);
                   cont=-1;
              binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(10);


               }
               else

               if(RD3==1) //S4 simula un sensor para activar el conteo

          { break;}


              RA0=1;
           __delay_ms(100);
              RA0=0;
                cont++;
               // eeprom_write(0x09,cont);

                 if(unidades == 10)
                 { decenas++; unidades = 0;}

                 else if(decenas == 10)
                 { centenas++; decenas = 0;}

                 else if (centenas == 10)
                 { centenas = 0; }

                eeprom_write(0x00,unidades);
                eeprom_write(0x01,decenas);
                eeprom_write(0x02,centenas);
                eeprom_write(0x00,MyVar.valor8_1);
                eeprom_write(0x01,MyVar.valor8_2);
                binbcd();
                lcd_goto(0X4B); // Ubico centenas en poscion CB del LCD
                lcd_putch(centenas+48); // sumo 48 para pasar a ASCLL
                lcd_goto(0X4C);        //Ubico decenas en posicion CC del LCD
                lcd_putch(decenas+48); //sumo 48 para pasar a ASCLL
                lcd_goto(0X4D);     //Ubico unidades en posicion CE DEL LCD
                lcd_putch(unidades+48); //Sumo 48 para pasar a Ascll
                __delay_ms(100);    //Incremento cuenta cada 500 ms

               
       write_16bits_eeprom(cont,0x00);       //Lee lo de la posicion 0x00 y 0x01, lo junta y lo pone en contador
            }
        }
    }
}
void lcd_init(void) //funcion de inicializacion del LCD
{
LCD_DATA=2; // se manda el dato 2 al puerto para iniciar el LCD
set_lcd(); // se la funcion de configuracion
LCD_DATA=56; // mando el dato 56 al puerto para 8 bits,2 lineas y 5x7
set_lcd();   // llamo funcion de configuracion
LCD_DATA=12; // mando el dato 12 para prender el LCD con cursor
set_lcd();
LCD_DATA=6;
set_lcd();
LCD_DATA=1;
set_lcd();
}

void set_lcd (void) // funcion de configuracion
{
    LCD_RS=0; //RS en cero para indicar al LCD que es configuracion
    LCD_EN=1; // se habilita la operacion
   __delay_ms(2); //retardo necesario para la operacion
    LCD_EN=0; // termina la operacion
}
//Voy a una poscion especifica del LCD
void lcd_goto(unsigned char pos) // funcion de direcciones
{
   LCD_RS = 0; //RS en cero para configuracion
   lcd_write(0x80+pos); //sumo 80H a pos que viene con un dato
}
void lcd_write(unsigned char c) // funcion de escritura en el LCD
{
   LCD_EN=1;//habilito la operacion
   LCD_DATA = ( c );//mando al puerto el dato que hay en C.
   __delay_ms(2); //retardo necesario para la operacion
   LCD_EN=0;// termino la operacion
}
/* Escribo una cadena de caracteres en el LCD */
void lcd_puts(const char * s)
{
   LCD_RS = 1; //habilito operacion
   while(*s) //mientras haya caracteres en la cadena enviada
      lcd_write(*s++); //pase al siguiente
}
/* Escribo un caracter en el LCD */
void lcd_putch(char c)
{
   LCD_RS = 1;   //habilito escritura en LCD
   lcd_write( c );
}

Errores que me salen al compilar el programa

main.c:15: error: (1442) type used in variable definition is incomplete
main.c:52: error: (198) undefined struct/union "Data_EE"
main.c:52: error: (182) illegal conversion between types
unsigned char -> union Data_EE
main.c:53: error: (198) undefined struct/union "Data_EE"
main.c:53: error: (182) illegal conversion between types
unsigned char -> union Data_EE
main.c:56: warning: (361) function declared implicit int
main.c:116: error: (198) undefined struct/union "Data_EE"
main.c:116: error: (182) illegal conversion between types
union Data_EE -> unsigned char
main.c:116: error: (181) non-scalar types can't be converted to other types
main.c:117: error: (198) undefined struct/union "Data_EE"
main.c:117: error: (182) illegal conversion between types
union Data_EE -> unsigned char
main.c:117: error: (181) non-scalar types can't be converted to other types
main.c:128: warning: (361) function declared implicit int
(908) exit status = 1
make[2]: Leaving directory `C:/Users/juan/MPLABXProjects/LCD.X'
make[1]: Leaving directory `C:/Users/juan/MPLABXProjects/LCD.X'
make[2]: *** [build/default/production/main.p1] Error 1
make[1]: *** [.build-conf] Error 2
make: *** [.build-impl] Error 2

Título: Re:Guardar valores de contador 0-999 en memoria EEPROM
Publicado por: KILLERJC en 13 de Octubre de 2016, 12:34:39

Bien los errores son esos y veo correctamente que son,

A lo que me refiero del codigo es que pongas donde tenes definido las funciones:

       write_16bits_eeprom(cont,0x00);

Quedebo imaginar que es el archivo Lib_Int_EEProm.c

Nuevamente pusiste en el codigo un DEFINE, cuando tal ves era un INCLUDE.