Decompor um numero float

[LEOPUENA]

Olá pessoal,,,

Preciso fazer uma decomposição/conversão de um numero do tipo float em factores do tipo inteiro, e fazer o processo inverso. Mas estou com algumas dificuldades com os valores depois da virgula. Criei duas funções para fazer cada operação e gostaria que dessem uma olhada:

int16 valor1=0,valor2=0,valor3=0,valor4=0;      
int16 aux,float1000,float100,float10,decimal=0;


////////////////////////////////////////////////////////////////////////////////
float comporNumero(int16 num1,int16 num2,int16 num3,int16 num4,int16 decima){
      //FUNÇÃO PARA COMPOR UM NUMERO FLOAT A PARTIR DE FACTORES INTEIROS

      float floatnum=0,ponto;

      ponto = decima/100;
      floatnum=(num1*1000)+(num2*100)+(num3*10)+(num4)+ponto;

      return(floatnum);


}

////////////////////////////////////////////////////////////////////////////////
void converteFloatToInt(float numero){
      //FUNÇÃO PARA DECOMPOR UM NUMERO FLOAT EM FACTORES INTEIROS


      aux=numero;     
      decimal=(numero-aux)*100; 

      valor1=aux/1000;
      float1000=(valor1*1000);

      aux=aux-float1000;
      valor2=aux/100;
      float100=(valor2*100);

      aux=numero;      
      aux=aux-(float1000+float100);

      valor3=aux/10;
      float10=(valor3*10);


      aux=numero;      
      aux=aux-(float1000+float100+float10);

      valor4=aux;



      puts("");
      printf("%f --> %li %li %li %li , %li",numero, valor1,valor2,valor3,valor4,decimal);



}

De momento a função disso é guardar um certo valor na EEPROM.

[Projetos_afg]

Para que tanta complicação? Os números de ponto flutuante podem ser gravados na eeprom na sua forma original, basta acessar byte a byte da memória RAM:

http://www.ccsinfo.com/faq.php?page=write_eeprom_not_byte

[Fervolt]

Boa noite,

Caso isso seja CCS que eu acredito que seja.

Para decompor, você pode multiplicar o float por 10 ou 100 como já está fazendo para transforma-lo em um numero inteiro e para separar em bytes para gravar na eeprom use a função de compilador make8 cuja sintaxe é: make8(var, posic) onde var = variavel de 16 ou 32 bits e posic = posição do byte no numero, pode variar de 0 a 3 onde 0 é o LSB e 3 o MSB se a variável for de 32 bits.

Para juntar use make16 ou make32 conforme o caso e depois divida por 10 ou 100.

Att,

[LEOPUENA]

Ok,

Eu não conhecia esses "MAKERS"

Para que tanta complicação? Os números de ponto flutuante podem ser gravados na eeprom na sua forma original, basta acessar byte a byte da memória RAM:

Eu pensei nisso mas não sabia bem como fazer, então optei por uma solução mais generalizada que pode até ser usada em outros casos. mas make() pode resolver o meu problema. Vou testar e depois digo algo.

[vtrx]

Make não é genérico,vai ficar com código dependente do CCS...

[felipefpt]

Olha a minha lógica, que já fiz uma vez pra mostrar float em um LCD no MSP430

quando você coloca int x=425,3, o int pega somente o valor inteiro.

Então fazer,

float x = 425,3

int y = x //primeira parte do numero

int z = (x*1000)-y*(1000) // a segunda parte, que é 425300-425000=300

como eu sei que estou usando 3 digitos depois da virgula, na hora de colocar o ponto novamente eu conto 3 casas de tras pra frente...

[LEOPUENA]

usei a solução dada pelo colega Projetos_afg, e resolveu o problema (o mesmo com a função make), mas continuo sem perceber a logica usada, alguem pode esclarecer? "*((int8*)&data + i"

void main(){
      .....
      consumo =  READ_FLOAT_EEPROM(10);
      .....
      .....
      WRITE_FLOAT_EEPROM(10,consumo);
}

////////////////////////////////////////////////////////////////////////////////
void WRITE_FLOAT_EEPROM(long int n, float data) { 
   int i;

   for (i = 0; i < 4; i++) 
      [B]write_eeprom(i + n, *((int8*)&data + i) ) ; [/B]
}

////////////////////////////////////////////////////////////////////////////////
float READ_FLOAT_EEPROM(long int n) { 
   int i; 
   float data;

   for (i = 0; i < 4; i++) 
      [B]*((int8*)&data + i) = read_eeprom(i + n);[/B]

   return(data); 
}

Dando umas voltas pelos sites da microsoft (forum do visual studio) encontrei algo interessante, precisava de uma solução para converter float em string (para usar no mesmo projecto), a solução mais simples é usar a função sprintf().

      strcpy(string1,"kWh :");
      strcpy(string3,"Kz:  ");

      sprintf(string2,"%f ",consumo);
      sprintf(string4,"%f ",consumo*taxa);

      printf(lcd_putc,"\f%s%s \n%s%s",string1,string2,string3,string4);   

[Projetos_afg]

A expressão "*((int8*)&data + i" serve para endereçar byte a byte do número de ponto flutuante (total de 4 bytes) de forma indireta (através da variável 'i').

O &data faz referência ao endereço do primeiro byte da variável de ponto flutuante.

O int8* serve para indicar ao compilador que estamos endereçando bytes, e não word ou dword.

[LEOPUENA]

Não tinha percebido isso até dar conta que se trata de ponteiros, algo que não domino. Vou estudar um pouco mais sobre isso.

Obrigado por todas as respostas. O topico pode fechar.

[BCP]

Caso o autor do tópico necessite, o mesmo será reaberto, para isso deverá entrar em contato com a moderação solicitando o desbloqueio.