ASM51

BOm dia a Todos;

Alguém teria alguma rotina de escreita e leitura em C de como gravar na eeprom do atmega 8 com o compilador Code Vison ? Gostaria de algo simples e funcional.

Obrigados a todos


T+

Experimenta isto:

Código: Selecionar todos

#include <mega8.h>

eeprom char var;

void main ( void )
{
    char var_local;

    var = 0xFF;
    var_local = var;
    var_local = 0;
    var = var_local;
    while ( 1 );
}

xau.

Está rotina seria de escrita ou leitura ?

Se possível me passe as duas, estou bem leigo neste assunto de memória, escrever, ler.


Muito grato pela ajuda;

Estou terminado de montar meu kit, e testarei a rotina


ABraço

Código: Selecionar todos

#include <mega8.h>

eeprom char var;

void main ( void )
{
    char var_local;

    var = 0xFF;    // ESCRITA
    var_local = var;    // LEITURA
    var_local = 0;
    var = var_local;    // ESCRITA
    while ( 1 );
}

[]'s

Ei, tmarchesi2.

Valeu a dica, hein?!?!

Deu tudo certo aqui!

Tou te mandando essa mensagem, só como um feedback, mesmo!

Tudo certinho!!

[]'s

Boa tarde Mauricio;

A placa do meu Kit chegou esta semana,

Estou curioso pra testar a rotina !


Vou compilar no AVR Studio, e posto os resultados


Abraço

Ops!

Descurpem a nossa fáia! eheheheheheh

Mas é só isso, mesmo! AVR e CodeVision tornam as coisas tão simples, que chega a dar raiva!

Não sei de qual outro MCU vc veio, mas, vai ver que AVRs são OS CARAS! ehehehehehe

Boa sorte!

[]'s

Desculpem reabrir um tópico tão antigo, mas nesse exemplo mostrado não entendi como fazer para gravar num endereço específico da eeprom.

No meu caso por exemplo, quero gravar um byte qualquer no endereço 0x03, e ler um byte do endereço 0x09. Como fazer isso no CodeVision?

No Mikroc é assim:
EEPROM_Write(adress, data);
data=EEPROM_Read(adress);

Parece que no Codevision não tem como fazer isso, alguém saberia dizer?

Código: Selecionar todos

// EEPROM access example

// CodeVisionAVR C Compiler

// Chip: ATmega8515

flash char f[] = "This is a test";
#pragma warn-
eeprom char e[16];  // aqui define um vetor na eeprom
#pragma warn+
char r[16];

void main(void)
{
    char flash *ptr_to_flash; // ponteiro para flash
    char eeprom *ptr_to_eeprom; // ponteiro para eeprom
    char *ptr_to_ram; // ponterio para ram

    // copy the string f from FLASH to
    // the string e in EEPROM
    ptr_to_flash = f;
    ptr_to_eeprom = e;
    while (*ptr_to_flash) // lembre que no final da string fica falso (NULL).
        *ptr_to_eeprom++ = *ptr_to_flash++;
    // NULL terminate the string in EEPROM
    *ptr_to_eeprom = 0;

    // copy the string e from EEPROM to
    // the string r in RAM
    ptr_to_eeprom = e;
    ptr_to_ram = r;
    while (*ptr_to_eeprom)
        *ptr_to_ram++ = *ptr_to_eeprom++;
    // NULL terminate the string in RAM
    *ptr_to_ram = 0;

    // stop here
    while (1);
}


Note que precisa definir "eeprom tipo nomevar". O compilador coloca automaticamente os endereços. Basta ler usando as variáveis definidas para escrever.
Não é necessário escrever em determinado endereço, como 0x03, vai ficar bagunçado, use um nome para uma var, conforme acima.
Nota: Não uso codevision, portanto ...

RobL, obrigado pela informação.

Mas realmente eu preciso ler e gravar num endereço específico, indicando o endereço através de uma variável.

Inclui essas funções abaixo, e consegui resolver meu problema. Gravo o endereço na variável "adress" e o dado na variável "data", e chamo a função para gravar. Para ler coloco o endereço em address, e o resultado da leitura coloco em data. Na verdade copiei essas funções do próprio datasheet do componente.

Valeu,



void EEPROM_Write()
{
/* Wait for completion of previous write */
while(EECR & (1<<EEPE))
;
/* Set Programming mode */
EECR = (0<<EEPM1)|(0<<EEPM0);
/* Set up address and data registers */
EEARL = adress;
EEDR = data;
/* Write logical one to EEMPE */
EECR |= (1<<EEMPE);
/* Start eeprom write by setting EEPE */
EECR |= (1<<EEPE);
}


unsigned char EEPROM_Read()
{
/* Wait for completion of previous write */
while(EECR & (1<<EEPE))
;
/* Set up address register */
EEARL = adress;
/* Start eeprom read by writing EERE */
EECR |= (1<<EERE);
/* Return data from data register */
return EEDR;
}

Boas!

Nik. Esse código que vc postou é a maneira mais bruta de acessar EEPROM com endereço específico. Isso é do mais baixo nível pra poder acessar a memória.
Acho que isso daqui é mais prático, experimenta ai:

Código: Selecionar todos

#include <mega16.h>

eeprom unsigned char x @0x03;
eeprom unsigned char y @0x09;

void main ( void )
{
    unsigned char var = 0;

    // pra ler:
    var = y;

   // pra escrever na EEPROM:
   x = 0xBC;

   while ( 1 );
}

[]'s

Vlw Mauricio,

Realmente sua solução é melhor, e dá bem certo com minha necessidade.

Abçs