Variablengröße 10-Bit-Integer gesucht

die 2 High-Bytes liest du ja getrennt aus, also würde ich diese extra 
abspeichern. Immer 4 in einem Byte. Berechnung über MOD 4 aus der 
Speicherstelle.

Das ist jetzt aber nicht dein Ernst?

Eine 10 Bit Variable wird gespeichert indem du 4 Bytes
dafür verbrätst ?!?

Da bist du ja noch besser drann, wenn du

uint16_t messwerte[1024];

benutzt.


>      if(temp_i16_adc>765)
>      {
>        messwerte[messwert_nr][0]=255;
>        messwerte[messwert_nr][1]=255;
>        messwerte[messwert_nr][2]=255;
>        messwerte[messwert_nr][3]=temp_i16_adc-765;
>      }

>  temp_i16_1 = messwerte[messwert_nr][0] +
>               messwerte[messwert_nr][1] +
>               messwerte[messwert_nr][2] +
>               messwerte[messwert_nr][3];

So irgendwie hast du noch nicht durchschaut was es mit
einem Stellenwert-System so auf sich hat.

Bei 1456  haben die einzelnen Stellen unterschiedliche
Wertigkeiten! Um die Zahl zu erhalten rechnest du ja
auch nicht   1 + 4 + 5 + 6
sondern   6 + 10 * 5 + 100 * 4 + 1000 * 1

Das ist jetzt im 10-er System. Mit Bytes hast du halt ein
256-er System.

Bei deinem ersten Posting

uint16_t messwerte[1024][3];

Woher sind die 3 gekommen?
Wieviele Messwerte musst du denn wirklich speichern?

>> Bei 1456  haben die einzelnen Stellen unterschiedliche
>> Wertigkeiten! Um die Zahl zu erhalten rechnest du ja
>> auch nicht   1 + 4 + 5 + 6
>> sondern   6 + 10 * 5 + 100 * 4 + 1000 * 1
>
> Ich glaube nicht, dass du das System der Funktion verstanden hast.

Ich glaube nicht, dass du das binäre System oder
Zahlensystem im Allgemeinen verstanden hast.

> Teile ich die max. 1023 auf 4 Variablen (8-Bit) auf

1023 kann mit 10 Bit dargestellt werden.
4 Variablen zu je 8 Bit macht aber in Summe 32 Bit.

Du willst mir doch jetzt nicht erzählen, dass es effizienter
ist, 10 Bit in insgesammt 32 Bit zu speichern anstatt in
einer Variable die 16 Bit gross ist.

Wenn du

uint16_t messwert[1024]

als Speichermedium benutzt, 'verschenkst' du bei jedem
Messwert 6 Bit

Wenn du

uint8_t messwert[1024][4]

als Speichermedium benutzt, 'verschenkst' du bei jedem
Messwert 22 Bits

Was ist also effizienter?

> Für die Abspeicherung der 10-Bit Messwerte benötigt man somit 4*8-Bit
> Variablen und nicht eine mit 16-Bit.

Den Satz solltest du dir nochmal auf der Zunge zergehen
lassen.
Um 10 Bit abzuspeichern kann ich jeden Datentyp nehmen
der größer oder gleich 10 Bit ist. Und dann nehme ich
vorzugsweise den Datentyp der möglichst wenig über den
10 Bit liegt.

> und die 1024 Messwerte 'vertikal' zu speichern

Bring ihn nicht durcheinander :-)
Er hat so schon grosse Schwierigkeiten zu verstehen
wie ein Zahlensystem im Allgemeinen funktioniert.

@Timo

Das was du gemacht hast, ist equivalent zu:

Du musst dir merken wieviele Schafe auf der Weide sind.
Dazu sperrst du sie immer in 255-er Gruppen in eine
Koppel. Anschliessend sagst du: Um rauszukriegen wieviele
Schafe das sind, gehe ich alle Koppeln durch und addiere
die Anzahl der Schafe in jeder Koppel.

So funktionieren Zahlensysteme aber nicht. Ein Stellenwert-
system funktioniert anders. Es sagt: Wieviele Koppeln
sind denn mit 255 Schafen voll? Aha. Ich habe insgesammt
3 volle Koppeln und 1 Koppel mit 12 Schafen. Insgesamt
habe ich also: 3 * 255 + 12 gleich 777 Schafe. Um mir
das merken zu können brauche ich mir aber nur die Zahlen
3 und 12 zu merken. Nicht: 255, 255, 255, 12

Dieser Übergang vom:
  In einem Beutel mit Steinen repräsentiert jeder Stein ein
  Schaf. Wenn die Schafe auf die Weide gehen wird ein Stein
  in den Beutel geworfen; wenn das Schaf nach Hause kommt
  wird ein Stein aus dem Beutel genommen. Ist der Beutel
  leer, so sind wieder alle Schafe zu Hause

zu
  Für jeweils 10 Schafe wird ein Stein aus dem Beutel genommen
  und dafür ein Stein in einen anderen Beutel getan (der
  dann jeweils 10 Schafe repräsentiert). Ansonsten bleibt
  alles andere gleich

..., dieser Übergang ist die Geburtsstunde der Mathematik
in der Menschheitsgeschichte. Ohne ihn würden wir heute
nicht dort sein, wo wir heute sind. Das ist die Geburtsstunde
eines Stellenwertsystems wo die gleichen Ziffern unterschiedliche
Dinge bedeuten, jenachdem an welcher Stelle einer Zahl sie
eingesetzt werden. Und es unterscheidet sich fundemental von
simplen Abzählsystemen.

Falk wrote:
> @Karl heinz Buchegger
>
>> ..., dieser Übergang ist die Geburtsstunde der Mathematik
>> in der Menschheitsgeschichte. Ohne ihn würden wir heute
>> nicht dort sein, wo wir heute sind.
>
> Kurz vor dem Abgrund?
>
> ;-)

Wie ich immer sage:
Diesem Planeten kann nichts besseres passieren,
als dass wir uns selbst ausrotten.

Sagt ein Planet zum anderen
"Mir gehts gar nicht gut. Ich hab Homo Sapiens."
Sagt der andere
"Das geht vorbei"

:-)

Ich habe mir dazu folgendes ausgedacht 3x10bit in eine 32bit Variable, 
man Verliert jeweils 2 Bits bei 1024 werten sind das also ca. 85.5byte 
verlust.
Man brauxht also 1024/3=341.3 ~ 342x32bit Variablen: uint32_t temp[342]
und das macht 1368Byte anstatt 2048 wenn man einfach ein uint16_t Array 
verwendet.
Hier beispiel:

1

#include <stdio.h>

2

#include <inttypes.h>

3

4

int main()

5

{

6

7

    uint32_t temp, var32;

8

    /*es werden hoestens 10bit verwendet*/

9

    uint16_t a=342 , b=1023, c=987;

10

11

    /*3 10Bit a,b,c Variablen in eine 32Bit Variable codieren*/

12

    var32 = 0;

13

14

    temp = a;

15

    temp = temp<<20;

16

    var32 |= temp;

17

18

    temp = b;

19

    temp = temp<<10;

20

    var32 |= temp;

21

22

    temp = c;

23

    temp = temp<<0;

24

    var32 |= temp;

25

    printf("a:%u  b:%u  c:%u\n", a, b, c);

26

27

    /*3 10Bit Variablen aus einer 32Bit Variable decodiern*/

28

    temp = var32;

29

    temp = temp>>20;

30

    a = temp & 0x3ff;

31

32

    temp = var32;

33

    temp = temp>>10;

34

    b = temp & 0x3ff;

35

36

    temp = var32;

37

    temp = temp>>0;

38

    c = temp & 0x3ff;

39

    printf("a:%u  b:%u  c:%u\n", a, b, c);

40

41

    return 0;

42

}

Das funktioiert vorausgesetzt der Compiler trimmt die Arrays nicht auf 
Werte 2^N.

> sollte das noch kein Grund sein sich über die
> betreffene Person(diesmal leider Ich) lustig zu machen!

Ich mach mich doch nicht über dich lustig.
Das würde dann etwas anders aussehen.

Mir ist nur wichtig, dass du auch verstehst wo und
vor allen Dingen warum du falsch liegst und ev.
noch ein paar Dinge zum drüber nachdenken dazuzumixen.
Man kann sehr viele Dinge lernen wenn man die ganz
banalen Dinge im Leben beobachtet wie zb. wie sind
eigentlich unsere Zahlen aufgebaut, welche Eigenschaften
liegen da zugrunde. Diese Dinge sind ganz banal und einfach,
nur entdecken muss man sie erst mal.
Genauso wie ich ein eifriger Verfechter des 'gesunden
Hausverstandes' bin. Und der Hausverstand muss Alarm schlagen
wenn ich die Idee verteidige 10 bit in 32 bit zu speichern.

Aber hey. Ich verenne mich auch manchmal in Ideen bis jemand
kommt und sagt: Geh mal 2 Schritte zurück und schau dir das
nochmal an. Das kann so nicht sein, weil ...

Woher willst du wissen, dass da so ein riesen Rauschen gibt, dass bei 
10Bit Auflösung 1 oder 2 bits unbrauchbar sein sollen?
Wenn der Messbereich z.B 0-2V liegt, dann beträgt die Auflösung etwa 
2mV, meistens ist doch das Rauschen erheblich kleiner.

Super, wie sich hier gefetzt wird.


Ich habs jedenfalls gleich verstanden, was er meinte:

10 Bit in 16 Bit ergibt 37% Verlust
3 Worte a 10 Bit in 32 Bit aber nur 6%.


Ich denke aber eher, die Optimierung sollte besser an anderer Stelle 
ansetzen:

Warum müssen unbedingt 3 * 1024 Meßwerte gespeichert werden ?

Wenn man diese Zahl verringert (Vorverarbeitung, Differenzspeicherung), 
dann spart man wirklich was.


Peter

> Warum speicherst du denn die kompletten 10 bit ?
> Wenn du die oberen 8 Bit speicherst, hast du eine Genauigkeit
> die in den meisten Fällen wohl ausreichen wird.

Sehr pessimistisch. Was aber wohl richtig ist: in den meisten 
Anwendungen wird keine so hohe relative Auflösung gebraucht, d.h. bei 
Werten über 100 interessiert das letzte Bit nicht mehr usw.

In solchen Fällen kann man mit sehr wenig Aufwand eine 10-Bit-Zahl in 6 
Bit plus 2 Bit Exponent umwandeln, die dann in einem Byte gespeichert 
wird. Dann hat man bei kleinen Signalen noch einen Wert, bei größeren 
Werten sinkt die absolute Genauigkeit, aber die relative Auflösung 
bleibt.

Habe ich nie verstanden, weshalb das z.B. bei der Audio-CD nicht so 
gemacht wurde (z.B. 12 Bit Mantisse + 4 Bit Exponent statt 16 
Bit-Integer). Im Fortissimo werden Bits verplempert für Feinheiten, die 
für das Ohr nicht wahrnehmbar sind, dafür hört man im Pianissimo das 
Quantisierungsrauschen. Ist doch doof! Unser Ohr funktioniert relativ!

Zurück zum Thema: die Mantisse/Exponent-Codierung trägt auch dem Umstand 
Rechnung, daß eine der größten Fehlerquellen die Nichtlinearität ist, 
bei großen Werten ist die letzte Stelle also noch deutlich weniger wert.

> Ich habs jedenfalls gleich verstanden, was er meinte:
>
> 10 Bit in 16 Bit ergibt 37% Verlust
> 3 Worte a 10 Bit in 32 Bit aber nur 6%.

Nur hat er das nicht implementiert :-)
Er hat 1 Wort a 10 Bit in 32 Bit

> Ich denke aber eher, die Optimierung sollte besser an anderer Stelle
> ansetzen:
>
> Warum müssen unbedingt 3 * 1024 Meßwerte gespeichert werden ?

Jetzt kommt der Clou.
Es sind gar nicht 3*1024 Messwerte.
Es sind nur 1024 Messwerte. Aber er hatte jeden Messwert auf 3
uint16 verteilt.