ASM51

Como eu faço para gravar um dado do tipo float em uma memória i2c. Na verdade, meu problema é como quebrar um float de 32bits em bytes para gravar na memória...

Grato

David Henrique escreveu:Como eu faço para gravar um dado do tipo float em uma memória i2c. Na verdade, meu problema é como quebrar um float de 32bits em bytes para gravar na memória...

Grato

Union?

MAS COMO EU FARIA USANDO UNION?

David Henrique escreveu:Como eu faço para gravar um dado do tipo float em uma memória i2c. Na verdade, meu problema é como quebrar um float de 32bits em bytes para gravar na memória...

Grato

da uma olhada e vê se é isso....


http://asm51.eng.br/phpBB/viewtopic.php ... ght=make32


amboni

Código: Selecionar todos

union {
    float f;
    unsigned char c[4];
   } fc;

pra guardar fc.f na eeprom guardar fc.c[3],fc.c[2],fc.c[1],fc.c[0]
char e float não se dão muito bem. pode ser que esteja certo ou errado ou talvez sim ou não funcione ou os dois.
Agora só com os gurus de verdade...
abs...

hmm... pq guardar na ordem inversa ?

Salve, David.

Por ponteiros tb dá.
Experimente este código. Ele separa o tipo float em 4 bytes.

Código: Selecionar todos

void salva_E2PROM ( unsigned char dado )
{
   
}

void main ( void )
{
   unsigned char contador = 0;
   float num_flut = 3.141516
   
   void *ptr_void;
   char *ptr_char;
   
   ptr_void = ( void * ) &num_flut;
   ptr_char = ( char * ) ptr_void;
   
   for ( contador = 0; contador < 4; contador++ )
   {
      salva_E2PROM ( * ( ptr_char + contador ) );
   }
}

[]'s

Marcelo Samsoniuk escreveu:hmm... pq guardar na ordem inversa ?

hmm... pq guardar na ordem "correta" ?

nao sei, mas as funcoes genericas write e read trabalham com bytes em ordem normal em qq dispositivo, nao seria logico seguir a mesma ideia ?

eu implementaria uma funcao generica eeprom_write e eeprom_read, da seguinte forma:

Código: Selecionar todos

int eeprom_write(char *p, int size)
{
   int i;

   for(i=0;i<size;i++)
   {
      if(eeprom_write_byte(p[i])==-1)
      {
         break;
      }
   }
   return i;
}

int eeprom_read(char *p, int size)
{
   int i;

   for(i=0;i<size;i++)
   {
      if((p[i]=eeprom_read_byte())==-1)
      {
         break;
      }
   }
   return i;
}


assim conseguiria ler e escrever qq tipo de estrutura de dados. em particular:

Código: Selecionar todos

float f;

eeprom_write((char *)&f,sizeof(f));
eeprom_read((char *)&f,sizeof(f));


eventualmente, no futuro, vc pode definir eeprom_write e eeprom_read como funcoes ativadas a partir de write e read mais genericas, assim mudando apenas o nome do dispositivo na funcao open, write e read passam a operar em qq outro dispositivo:

Código: Selecionar todos

float f;
int i;

i = open("eeprom:",O_RDWR);
write(i,(char *)&f,sizeof(f));
read(i,(char *)&f,sizeof(f));


de acordo com o nome do device, open retorna um descritor e, de acordo com o descritor, write e read usam rotinas diferentes, para o device aberto em open.

se depois vc tiver alem da eeprom uma nvram, eh soh trocar a string do device para "nvram:", o resto do codigo continua igual. com isso vc vai criando codigo em bibliotecas de alto nivel que tornam as aplicacoes mais portaveis e mais isentas de erros, com maior reaproveitamento de codigo para futuros projetos.