Dúvida eeprom 16f628a

fabio fg · 20 de março de 2016

Boa tarde caro amigos, estou com um pequeno problema com EEPROM de um 16f628a. Bem vamos lá...estou desenvolvendo um cronômetro mas com incremento de 10 em 10 minutos mas com leds...que já está funcionando por sinal mas estou querendo deixá-lo mais redondo podendo salvar os minutos restantes e a sua atual posição em relação ao sistema em uma eventual falta de energia.

Pelo que já fiz simplesmente não funciona no Proteus e muito menos na prática.

Utilizando o CCS compiler gostaria de saber poderia estar acontecendo ....

#include <16f628a.h>
#include <internal_eeprom.c>
#use delay(clock=4000000)
#fuses xt,put,NOwdt,protect,NOLVP,NOCPD,INTRC_IO,BROWNOUT,NOMCLR  //atual
//#fuses XT,INTRC_IO,NOWDT,PUT,BROWNOUT,NOMCLR,NOLVP,PROTECT
#DEFINE pulso PIN_A0 //coin
#DEFINE ciclo_1 PIN_A1 //led 1
#DEFINE ciclo_2 PIN_A3 //led 2
#DEFINE ciclo_3 PIN_B7 //led 3
#DEFINE ciclo_4 PIN_B0 //led 4
#DEFINE ciclo_5 PIN_B1 //led 5
#DEFINE buzzer PIN_B5
#DEFINE RELE PIN_A2 // relê 
#DEFINE PILOTO PIN_B4 //led piloto
//#include "lcd_FLEX.c"
#rom 0x2100 = {0x08,0x07}

int16 h,m,s,ms,op,es,AUX,ini,pos_save;
int adress;
char estado;

void main(VOID){

   //DELAY_MS(500);
   es = 1 ;
 //  lcd_init();
  // lcd_putc("\fDIVIRTA-xx");
//   lcd_putc("\nR$ 0,50 - 10 Min");
   estado = 'e';
   h=00;
   m=00;
   s=00;
   ms=00;
   
   OUTPUT_low(rele);
   
   OUTPUT_high(ciclo_1);
   delay_ms(1000);
   OUTPUT_high(ciclo_2);
   delay_ms(1000);
   OUTPUT_high(ciclo_3);
   delay_ms(1000);
   OUTPUT_high(ciclo_4);
   delay_ms(1000);
   OUTPUT_high(ciclo_5);
   delay_ms(1000);
   OUTPUT_high(piloto);
   
   OUTPUT_low(ciclo_1);
   OUTPUT_low(ciclo_2);
   OUTPUT_low(ciclo_3);
   OUTPUT_low(ciclo_4);
   OUTPUT_low(ciclo_5);
   
   ini=1;
   
   pos_save = read_int16_eeprom(1); // lê a memória eeprom
   
   // habilita interrupções
   SETUP_CCP1(CCP_CAPTURE_RE);      
   enable_interrupts(INt_CCP1);   
   enable_interrupts(global);  
      
   
switch(pos_save) // verifica se há memória alocada 
{
case 1: {OUTPUT_high(ciclo_1);
        break;}
case 2: {OUTPUT_high(ciclo_2);
        break;}
case 3: {OUTPUT_high(ciclo_3);
        break;}
case 4: {OUTPUT_high(ciclo_4);
        break;}
case 5: {OUTPUT_high(ciclo_5);
        break;}
}
   
   
while(TRUE)
{

if (input(pulso)==0)
{
OUTPUT_high(rele);
delay_ms(10);
OUTPUT_low(piloto);

m = m + 10; // incremento em 10 minutos

if (ms == 00)
{
ms=10;
}
estado='t';
if (m > 60)
{
h++;
m=0;
m=m+5-1;
}
}

if (estado=='t')
{
ms=ms-1;
if (ms == 0)
{
s--;
ms=10;
if (s == -1)
{
s=59;
m--;
if ((m == -1) && (h > 0))
{
m=59;
h--;
}else
{
s=59;
}
}
}
}
//if ((s == 0) && (m == 0) && (h == 0))
if ((m <= 0))
{
estado = 'i';

OUTPUT_low(ciclo_1);
OUTPUT_low(ciclo_2);
OUTPUT_low(ciclo_3);
OUTPUT_low(ciclo_4);
OUTPUT_low(ciclo_5);
OUTPUT_high(piloto);
m = 00;
}

if (estado=='t')
{
//lcd_gotoxy(1,1);
//lcd_putc("\fTEMPO RESTANTE:");
//lcd_gotoxy(1,2);
//printf (lcd_putc,"%02d:%02d:%02d\n", h, m, s);
/*
switch (m){
case 2: { //delay_ms(50);
          OUTPUT_low(ciclo_2);
        }
case 4: { //delay_ms(50);
          OUTPUT_low(ciclo_3);
        }
case 6: { //delay_ms(50);
          OUTPUT_low(ciclo_4);
        }
case 8: { //delay_ms(50);
          OUTPUT_low(ciclo_5);
        }
}*/
if (m > 0)
{
delay_ms(20);
OUTPUT_high(ciclo_1);
write_int16_eeprom(0,1);

}
if (m > 10)
{
delay_ms(20);
OUTPUT_high(ciclo_2);
write_int16_eeprom(0,2);
}else
{
OUTPUT_low(ciclo_2);
}
if (m > 20)
{
delay_ms(20);
OUTPUT_high(ciclo_3);
write_int16_eeprom(1,3);
}else
{
OUTPUT_low(ciclo_3);
}
if (m > 30)
{
delay_ms(10);
OUTPUT_high(ciclo_4);
write_int16_eeprom(0,4);
}else
{
OUTPUT_low(ciclo_4);
}
if (m > 40)
{
//delay_ms(10);
OUTPUT_high(ciclo_5);
write_int16_eeprom(0,5);
}else
{
OUTPUT_low(ciclo_5);
}
if (m > 50)
{
m = 50;
OUTPUT_high(piloto);
}
delay_ms(90);
}else
{
//lcd_putc("\f");
op=2;
//lcd_putc("\fDIVIRTA-xx");
//lcd_putc("\nR$ 0,50 - 10 Min");
OUTPUT_low(rele);
//OUTPUT_low(buzzer);
OUTPUT_low(ciclo_1);
OUTPUT_low(ciclo_2);
OUTPUT_low(ciclo_3);
OUTPUT_low(ciclo_4);
OUTPUT_low(ciclo_5);
OUTPUT_high(piloto);
m = 00;
estado='e';
delay_ms(50);
ES = 0;
}
}
}

.if · 20 de março de 2016

permita-me não analisar o fonte (eu me autopermiti).

A essência de gravar valor na eeprom se acabar luz ou desligar é:

-programe o compadador

-programe interrupção pra ele

-use a referência interna numa entrada

-noutra ligue na entrada do regulador (geralmente 7805). Claro com resitores divisores de tensão.

-ao desligar, a V de entrada vai cair (claro)

-quando a V- de uma entrada for menor que a V+ da outra, será gerada um interrupção

-nesta rotina, grave na eeprom o valor que desejar. Mas antes...

-detalhe - I: grave apenas se valor alterou pra não gastar a cota de gravações da eeprom. Mas antes...

-detalhe - II: na interrupt, desligue tudo que está consumindo primeiro. O tempo de descarga do capacitor de entrada (geralmente > 1000uF) deve ser suficiente para gravar na eeprom

-Detalhe - III: ideia 100% original que até há agum tempo você não achava na net

fabio fg · 20 de março de 2016

1 hora atrás, Isadora Ferraz disse:

Obrigado pela dica...vou seguir aqui para alcançar o sucesso. Sou programador que arrisco na eletrônica, rs mas ei de conseguir !

Obrigado pelo elogio referente a ideia.

aphawk · 21 de março de 2016

@fabio fg ,

Creio que usar um real-time clock ( tipo DS1307 ou melhores ) te ajudaria muito, pois eles possuem uma memória interna, e você pode armazenar a sua contagem do tempo dentro dele ( e outras informações que sejam necessárias ), pois possui 56 bytes de memória não volátil. Ele usa uma pequena bateria de backup que mantêm os dados por anos e também permite que o relógio continue funcionando em tempo real, mesmo na falta da energia principal.

Assim, você até pode saber quanto tempo ficou sem energia, e pode tomar alguma atitude necessária.

Paulo

.if · 21 de março de 2016

Da excelente dica do amigo Paulo me veio outra um pouco inferior mas hardwaremente minimalista. Alimente o mc também com bateria e o faça dormir - comando sleep (#asm) - quando sem Vac. Isso deve ...