grava na eeprom do pic

[simone loura]

pessoal estou com dificuldade de grava uma variavel na eeprom do pic e mostra ela no lcd
ja tentei farios ex; e so fiquei mais com duvida se alguem pode me da uma ajuda eu agradeo
segue o cod. a variavel que quero grava e essa " setpoint " que atraveis da teclas eu incremento ou decremento. ja estou a 3 semana tentando e nada ate tirei os codigos sobre gravaçao que coloquei que nem copila

Code: Select all

// LCDsbit LCD_RS at RE2_bit;      //'R
sbit LCD_RS at RE2_bit;      //'RS ligado no RE2
sbit LCD_EN at RE0_bit;      //'RW ligado no RE0
sbit LCD_D4 at RD4_bit;      //'D4 ligado no D4
sbit LCD_D5 at RD5_bit;      //'D5 ligado no D5
sbit LCD_D6 at RD6_bit;      //'D6 ligado no D6
sbit LCD_D7 at RD7_bit;      //'D7 ligado no D7

sbit LCD_RS_Direction at TRISE2_bit;
sbit LCD_EN_Direction at TRISE1_bit;
sbit LCD_D4_Direction at TRISD4_bit;
sbit LCD_D5_Direction at TRISD5_bit;
sbit LCD_D6_Direction at TRISD6_bit;
sbit LCD_D7_Direction at TRISD7_bit;
//

long leitura_ad = 0 ;
char texto[5] = "00.0";
char valor[5] = "00.0";
long setpoint = 0;


void main() {

INTCON2.RBPU = 0;
TRISD = 3;     //configura todos os pinos do portd como saída
TRISE = 0;     //configura todos os pinos do porte como saída
TRISC.RC0 = 0;    //configura  portc como RC0 saída
TRISC.RC1 = 0;   //configura  portc como RC0 saída


trisa.ra0 = 1;    // entrada analógica AN0 configurado como entrada
TRISA.ra1 = 1;
trisa.ra2 = 1;
TRISA.ra3 = 1;
TRISA.ra4 = 1;
ADCON1 = 0b00001110; //configura AN0,COMO analógico e os demais como digital
//*************************************************************************************

PORTC.rc0 = 0;
portc.RC1 = 0;
 
Lcd_Init();
Lcd_Out(1,1,"");
Lcd_Cmd(_LCD_CLEAR);
Lcd_Cmd(_LCD_CURSOR_OFF);
Lcd_Out(1,1,"TEMPERATURA");
Lcd_Out(2,1,"SET_POINT");
Lcd_Out(1,13, texto);
Lcd_Out(2,13, valor);


 while(1){

  leitura_ad = adc_read(0);


  leitura_ad = leitura_ad*5000/1023;
    texto[0] = (leitura_AD%1000)/100 + 48;
    texto[1] = (((leitura_AD%1000)%100)/10) + 48;
    texto[2] = '.';
    texto[3] = (((leitura_AD%1000)%100)%10) + 48;
    Lcd_Out(1,13, texto);

        if (Button(&PORTa, 1, 100 ,0)){ //verifica tecla1.
           if (setpoint <=998)
            setpoint++;
            Delay_ms(100);
        }

         if (Button(&PORTa, 2, 100, 0)){ //verifica se a tecla2.
              if (setpoint>=1)
             setpoint--;
              Delay_ms(100);
         }

           valor[0] = (setpoint%1000)/100 + 48;
           valor[1] = (((setpoint%1000)%100)/10) + 48;
           valor[2] = '.';
           valor[3] = (((setpoint%1000)%100)%10) + 48;
             Lcd_out(2,13, valor);

               if (leitura_ad/2 <= setpoint/2){
                    portc.rc0 = 1; }
                    else portc.rc0 = 0;
                    

      



}
}

[fvgm]

Olá !!

Olha, é o seguinte... Conseguimos armazenar um short na EEPROM do pic, que tem somente 1 byte de tamanho ( 8 bits).
Criei essa função abaixo para armazenar e recuperar INTEIROS:

Na verdade, eu gravo e recupero um valor FLOAT (eu divido o INT por 10, depois quando eu recupero da memória, eu MULTIPLICO por 10! Há uma perda de precisão, mas aceitável para 2 digitos decimais.

Code: Select all

void IntToEeprom(unsigned int intValue, unsigned int addressLSB, unsigned int addressMSB) {
   Eeprom_Write(addressMSB,(intValue >> 0));   // escreve o ADC setado na calibracao
   Delay_ms(40);
   Eeprom_Write(addressLSB,(intValue >> 8));
   Delay_ms(40);
}

unsigned int EepromToInt(unsigned int addressLSB, unsigned int addressMSB) {
   unsigned short dataLSB, dataMSB;
   unsigned int data;

   dataLSB = Eeprom_Read(addressLSB);
   Delay_ms(40);
   dataMSB = Eeprom_Read(addressMSB);
   Delay_ms(40);
   data = dataLSB << 8;
   data = data + dataMSB;

   return data;
}

float getMaxAlarm() {
   unsigned short max_msb, max_lsb;
   unsigned int result;

   max_msb = Eeprom_Read(MAX_ALARM_MSB);
   Delay_ms(40);
   max_lsb = Eeprom_Read(MAX_ALARM_LSB);
   Delay_ms(40);

   result = max_lsb << 8;
   result = result + max_msb;
   return (result/10.0);
}

float getMinAlarm() {
   unsigned short min_msb, min_lsb;
   unsigned int result;

   min_msb = Eeprom_Read(MIN_ALARM_MSB);
   Delay_ms(40);
   min_lsb = Eeprom_Read(MIN_ALARM_LSB);
   Delay_ms(40);

   result = min_lsb << 8;
   result = result + min_msb;
   return (result/10.0);
}

void setMaxAlarm(unsigned int maxValue) {
   Eeprom_Write(MAX_ALARM_MSB,(maxValue >> 0));
   Delay_ms(40);
   Eeprom_Write(MAX_ALARM_LSB,(maxValue >> 8));
   Delay_ms(40);
}

void setMinAlarm(unsigned int minValue) {
   Eeprom_Write(MIN_ALARM_MSB,(minValue >> 0));
   Delay_ms(40);
   Eeprom_Write(MIN_ALARM_LSB,(minValue >> 8));
   Delay_ms(40);
}

É claro, antes temos que definir quais endereços de EEPROM vamos reservar para nossos inteiros:
favor incluir no código principal

Code: Select all

#define MAX_ALARM_MSB 0x0A
#define MAX_ALARM_LSB 0x0B
#define MIN_ALARM_MSB 0x0C
#define MIN_ALARM_LSB 0x0D

Exemplo de gravação / recuperação :

Code: Select all

unsigned int percentInteger = (calibrationPercent * 10);
IntToEeprom(percentInteger, CALIB_PER_LSB, CALIB_PER_MSB);

Code: Select all

   unsigned int adc;
   unsigned int percentInteger; // multiplicado por 10!
   
   adc = EepromToInt(CALIB_ADC_LSB, CALIB_ADC_MSB);
   percentInteger = EepromToInt(CALIB_PER_LSB, CALIB_PER_MSB);

   return ( (percentInteger/10.0)/adc );

Se for algo mais simples que você precisa, favor verificar os exemplos inclusos no próprio compilador do mikroC, ou na ajuda pela função EEPROM_Write ou EEPROM_Read, teclando por F1. Lembrando que, para exibir valores numéricos no LCD, tem que usar as funções de conversão IntToStr, ShortToStr, FloatToStr, sprintf, daí em diante.

att