chi spiega cosa fanno queste 2 righe di codice

[GINGARDU]

 c'è qualche anima pia che spiega meglio che puo  cosa fanno queste righe di codice  sopratutto l'ultima

Code: [Select]

negative=data[47];                            // check for a negative number
    for(x=25; x<48; x++)                         // ingore redundant first 24 bits
     {
  reading=reading+(data[x]*pow(2,x-25));      // add 2^ for each bit

[lestofante]

  c'è qualche anima pia che spiega meglio che puo  cosa fanno queste righe di codice  sopratutto l'ultima

orcalogia metti il codice tra i tag code che non si campisce una bega

Code: [Select]

negative=data[47];                            // check for a negative number
    for(x=25; x<48; x++)                         // ingore redundant first 24 bits
     {
  reading=reading+(data[x]*pow(2,x-25));      // add 2^ for each bit

negative=data[47];
direi che non ha bisongno di spiegazioni

poi dall'elemento 25 al 47 (c'è il <), per ognuno ne prende il valore e lo usa come esponente (ma l'esponente parte da 0 a 47-25) per una potenza in base 2, poi lo somma al risultato dei valori precedenti.

è un modo per compattare i valori di data in una unica variabile, però dando per scontato che data contega solo 1 o 0. in teoria avrebbe fatto molto prima facendo

Code: [Select]


reading = (reading << 1)+(data[x]&0x01)


però partendo dall'elemento 47 fino al 25

poi invece magari data assume altri valori e la cosa è un calcolo che ha un significato differente... senza maggiori informazioni non posso dire altro.

[GINGARDU]

allora ho capito che forse tu  hai capito (e purtroppo solo tu )   =(

ricapitolando:   

reading = 0;
negative=false;

negative=data[47];  // qui in poche parole se il bit 47 e LOW vul dire che negativo e vero  giusto ?

qui invece
for(x=25; x<48; x++)   prende le letture dalla 25 alla 47  oppure 48  ?   confermi?

e se lo modifico

for(x=1; x<25; x++)   prendo solo le letture dei primi 24 bit   giusto?


qui invece e notte fonda  =(   che cosa è  una formula per trasformare un binario in decimale
reading=reading+(data

• *pow(2,x-25));
  
  
  se me la rispieghi come hai fatto prima non la capisco

[PaoloP]

Code: [Select]

data[x]*pow(2,x-25)

Moltiplica il dato contenuto nella cella con indice X per la potenza di 2 elevato (x-25).
Quindi siccome il ciclo va da 25 a 47 sarà:
data[25]*pow(2,0) // il 25° dato per 2 elevato 0 cioè dato*1
data[26]*pow(2,1) // il 26° dato per 2 elevato 1 cioè dato*2
data[27]*pow(2,2) // il 27° dato per 2 elevato 2 cioè dato*4
ecc ecc..

Nel caso il ciclo for parta da 0 a 24

Code: [Select]

for(x=0; x<25; x++)
dovrai scrivere

Code: [Select]

data[x]*pow(2,x)

[lestofante]

non conosco il tipo di dato di data, ma sicurmante NON è un bit, e quindi data[47] NON è un bit. forse è un booleano, che per i nostri fini è come se fosse un bit

le letture dalle 24 alla 47, quando arrivi a 48 NON si esegue ilfor

non prendi le prime 24, perchè salti l'elemento 0 (gli array partono a contare da 0), al massimo for (int i=0;i<24;i++) notare il < e non il <=

sì, se data è boleano allora trasmorma l'accozzaglia di "bit" (i booleani non sono bit ma va be) in un int

[GINGARDU]

Code: [Select]

data[x]*pow(2,x-25)

Moltiplica il dato contenuto nella cella con indice X per la potenza di 2 elevato (x-25).
Quindi siccome il ciclo va da 25 a 47 sarà:
data[25]*pow(2,0) // il 25° dato per 2 elevato 0 cioè dato*1
data[26]*pow(2,1) // il 26° dato per 2 elevato 1 cioè dato*2
data[27]*pow(2,2) // il 27° dato per 2 elevato 2 cioè dato*4
ecc ecc..

Nel caso il ciclo for parta da 0 a 24

Code: [Select]

for(x=0; x<25; x++)
dovrai scrivere

Code: [Select]

data[x]*pow(2,x)

scusa   ma c'è qualcosa che non va (sono 24 bit)   e un bit vale 0 oppure uno,   elevato a 2,  dara sempre o zero, oppure  uno, quindi la somma totale non puo superare 24   che mi sembra una follia 

[lestofante]

guarda che qull'1 o 0 viene MOLTIPLIcATO per il valore della potenza

[GINGARDU]

mi sono perso in un "bicchiere di bit"

le altre cose piu o meno le ho chiarite,  ma la formula non troppo,
alla fine   quella formula deve per forza eseguire una di queste due cose, (oltre al fatto che legge 24 bit)

primo che semplicemente trasforma i bit (classici)  in numero comune  seguendo le vostre formule

secondo che trasforma i bit  in numero comune, ma i bit sono a complemento a due

quale posso escludere con certezza?

Code: [Select]

reading=reading+(data[x]*pow(2,x-25));

[lestofante]

il concetto è semplice: hai un array di bit in fila, lui li prende e te li mette in fila dentro una variabile.però gli inverte: i bit che nell'array sono a sinistra, nella variabile finiscono a destra, e viceversa

[GINGARDU]

ok anche questa e buona   
il bit meno significativo  diventa il piu significativo   

e se per caso ci serve che non viene invertito il senso dei bit  la riga la modifichiamo come, cosi?

leviamo il meno d'avanti al 25 e mettiamo il piu

Code: [Select]

reading=reading+(data[x]*pow(2,x-25));