AD-Wandler LSB verwerfen

[Michael S. (apotheose)]

Hi,

ich lese einen 16Bit AD-Wandler via I2C aus.

   byte1 = i2c_readAck();
   byte2 = i2c_readAck();
   byte3 = i2c_readNak();
   i2c_stop();
   byte1 = byte1 << 1;
   byte1 = byte1 | (byte2 >> 7);
   byte2 = byte2 << 1;
   byte2 = byte2 | (byte3 >> 7);
   value = byte1*256+byte2;
   return value;

klappt auch alles ganz wunderbar, nur zuckeln mir die Werte zu viel 
herum. Deshalb wollte ich das niederwertigste, oder die 2 
niederwertigsten Bits einfach verwerfen. Ich verstehe die Berechnung des 
"value" nicht ganz, vielleicht kann mir jemand beim "wegwerfen" helfen ?

Vielen Dank

[Rainer U. (r-u)]

Wenn Dein "value" ein 16-Bit-Wert ist, dann machst Du einfach eine 
UND-Verknüpfung mit FFFC (1111111111111100) als Maske und schon sind die 
beiden letzten Bits "weg" (=0)

Die Schiebeoperationen vorher dienen nur dazu, die Messbits an die 
richtige Stelle zu rücken. Mehr dazu im Datenblat vom AD.

[Tilo (Gast)]

Wie willst du die den "wegwerfen"?
Es gibt da verschiedene Lösungne, das hängt davon ab, wie du die Daten 
weiter verwenden willst. Stört es dich, wenn die unteren beiden Bits 
wackeln? Welche Genauigkeit brauchst du? Ich hatte einen Fall da konnte 
ich die Bits noch gut brauchen. Ich habe dann Oversampling um x4 
gemacht. Danach hat nichts mehr gewackelt.


Die Berechnung von Value ist einfach. Die Daten werden in zwei Bytes 
(high und low) abgerufen. Bei der Berechnung von value werden die beiden 
Bytes zu einem Word zusammengefasst. Damit die Position des High-Bytes 
stimmt, muss mit 256 mutlipliziert bzw. um 8 geschoben werden.

[Rolf Magnus (Gast)]

Michael S. schrieb:
> Ich verstehe die Berechnung des "value" nicht ganz

Die ist auch arg umständlich geschrieben.

Statt:

Michael S. schrieb:
> byte1 = byte1 << 1;
>    byte1 = byte1 | (byte2 >> 7);
>    byte2 = byte2 << 1;
>    byte2 = byte2 | (byte3 >> 7);
>    value = byte1*256+byte2;

Hätte man auch einfach schreiben können:

value = byte1 << 9 | byte2 << 1 | byte3 >> 7;

Es wird das oberste Bit von byte3 als unterestes Bit für value genommen, 
die nächsten 8 Bits kommen aus byte2 und die oberen 7 Bits dann aus 
byte1.

[Karl H. (kbuchegg)]

Rolf Magnus schrieb:

> Es wird das oberste Bit von byte3 als unterestes Bit für value genommen,
> die nächsten 8 Bits kommen aus byte2 und die oberen 7 Bits dann aus
> byte1.

Wobei ich mich allerdings ernsthaft frage, was das für ein IC ist, der 
seine Ergebnisse so dermassen seltsam rausgibt (in Wirklichkeit 
eigentlich schon ein 24Bit ADC, bei dem der Originalautor sowieso schon 
die untersten 7 BIt weggeworfen hat?)

[chris (Gast)]

Rolf Magnus schrieb:
> Die ist auch arg umständlich geschrieben.

außerdem sind die Variablenbezeichnungen recht irreführend.
Wenn es sich bei byte1, byte2 und byte3 wirklich um Bytes handeln würde, 
würde das ganze natürlich überhaupt nicht funktionieren.

[Karl H. (kbuchegg)]

chris schrieb:
> Rolf Magnus schrieb:
>> Die ist auch arg umständlich geschrieben.
>
> außerdem sind die Variablenbezeichnungen recht irreführend.
> Wenn es sich bei byte1, byte2 und byte3 wirklich um Bytes handeln würde,
> würde das ganze natürlich überhaupt nicht funktionieren.

Deiner Meinung nach: warum nicht?

[Michael R. (Firma: Brainit GmbH) (fisa)]

Michael S. schrieb:
> zuckeln mir die Werte zu viel
> herum. Deshalb wollte ich das niederwertigste, oder die 2
> niederwertigsten Bits einfach verwerfen.

Das geht so einfach nicht.

Beispiel: Dein Wert "zappelt" zwischen 127 und 128. Jetzt schreib mal 
die beiden Werte binär hin, und überleg dir was du gewinnst, wenn du 
eins oder zwei der niederwertigsten Bits verwirfst...

Funktionierende Lösungsansätze sind:  entweder ein einfacher digitaler 
Filter (PT1-Glied) oder, noch besser, eine Glättung mit Hysterese, und, 
am besten, die Kombination der beiden.

[chris (Gast)]

Karl Heinz schrieb:
> Deiner Meinung nach: warum nicht?

ok hatte da wohl kurz nen Denkfehler ;)
Nach nochmaligem Nachdenken gehts natürlich schon, sorry für die 
Verwirrung.