chi spiega cosa fanno queste 2 righe di codice

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

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

gingardu:
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

 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

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.

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[x]*pow(2,x-25));

se me la rispieghi come hai fatto prima non la capisco

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è dato1
data[26]pow(2,1) // il 26° dato per 2 elevato 1 cioè dato2
data[27]pow(2,2) // il 27° dato per 2 elevato 2 cioè dato4
ecc ecc..

Nel caso il ciclo for parta da 0 a 24

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

dovrai scrivere

data[x]*pow(2,x)

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

PaoloP:

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è dato1
data[26]pow(2,1) // il 26° dato per 2 elevato 1 cioè dato2
data[27]pow(2,2) // il 27° dato per 2 elevato 2 cioè dato4
ecc ecc..

Nel caso il ciclo for parta da 0 a 24

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

dovrai scrivere

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 :fearful:

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

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?

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

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

ok anche questa e buona 8)
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

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