Pointer auf die nächsten 8 Bit?

[Klaus (Gast)]

Hallo,

Ich habe eine 16Bit Variable (uint16_t x) und einen 8bit Pointer 
(uint8_t * *test ). Mit dem Pointer würde ich gerne erst auf denn Anfang 
der Varable X zeigen und als nächstes auf die Mitte, also die nächsten 8 
Bit, aber ich bekomm es einfach nicht hin. Kann Mir jemand mit etwas C 
code Aushelfen?

Noch etwas: Es ist ein 16 Bit Controller und wenn ich den Pointer um 
eins hochzähle springt der immer 16 Bit weiter und nicht 8. :(

[(prx) A. K. (prx)]

So soll es auch sein. Aber es klingt etwas nach verkorkstem Ansatz. Wäre 
vielleicht zielführender, wenn du sagst, was du damit zu erreichen 
gedenkst.

Ansonsten: Erst zu uint8_t * konvertieren, dann hochzählen.

[Karl H. (kbuchegg)]

Klaus schrieb:
> Hallo,
>
> Ich habe eine 16Bit Variable (uint16_t x) und einen 8bit Pointer
> (uint8_t * *test ).

Wenn das kein Tippfehler ist, dann ist das falsch

> Noch etwas: Es ist ein 16 Bit Controller und wenn ich den Pointer um
> eins hochzähle springt der immer 16 Bit weiter und nicht 8. :(

Das hat damit nichts zu tun, dass du einen 16 Bit Controller hast.
Dein Pointer Datentyp ist einfach falsch. Das ist alles.

[Floh (Gast)]

Klaus schrieb:
> Ich habe eine 16Bit Variable (uint16_t x) und einen 8bit Pointer
> (uint8_t * *test ). Mit dem Pointer würde ich gerne erst auf denn Anfang
> der Varable X zeigen und als nächstes auf die Mitte, also die nächsten 8
> Bit, aber ich bekomm es einfach nicht hin. Kann Mir jemand mit etwas C
> code Aushelfen?

Das ist ungeschickt, Stichwort Endianess :-)

Was hindert dich daran, die Variable einzulesen und dann zu maskieren?
z.B. so:

uint16_t x = 2323 //irgendwas
uint8_t lowbyte, highbyte;

lowbyte = x & 0x00FF;

highbyte = (x & 0xFF00) >> 8;

[Klaus (Gast)]

Karl heinz Buchegger schrieb:
> Das hat damit nichts zu tun, dass du einen 16 Bit Controller hast.
> Dein Pointer Datentyp ist einfach falsch. Das ist alles.

Das habe ich mir schon gedacht, aber ich hab keine Ahnung wieso, bzw wie 
es hinbekomme. Ich hab schon alles mögliche versucht einen 8 bit Pointer 
hinzubekommen, klappt aber nicht

Karl heinz Buchegger schrieb:
> Wenn das kein Tippfehler ist, dann ist das falsch

War ein Tippfehler. uint8_t *test, so hab ich's gemacht.

[Karl H. (kbuchegg)]

Klaus schrieb:

> Das habe ich mir schon gedacht, aber ich hab keine Ahnung wieso, bzw wie
> es hinbekomme. Ich hab schon alles mögliche versucht einen 8 bit Pointer
> hinzubekommen, klappt aber nicht

Meine Kristallkugel ist schon im Wochenende.
Vielleicht kannst du dich zufällig noch daran erinnern, was 'alles 
mögliche' gewesen sein könnte?

[Karl H. (kbuchegg)]

In der Zwischenzeit

  uint16_t x;
  uint8_t* test;

  test = (uint8_t*) &x;

  wert1 = *test;
  test++;
  wert2 = *test;

aber eigentlich ist die Lösung von Floh besser, als da mittels 
Pointercasting auf die Bytes zuzugreifen.

[U.R. Schmitt (Gast)]

Wenns eher C-liks sein darf:
Eine Union definieren mit einmal dem uint16_t und twei uint_8t, bzw 
einem Array mit 2 uint8_t.

[Detlev T. (detlevt)]

@kbuchegg
Du setzt damit aber voraus, dass der Compiler die Bytes "packt". Also 
jeweils 2 Bytes in ein 16-Bit-Wort. Das ist nicht selbstverständlich, 
insbesondere da du ja gar nicht weißt, welcher Compiler mit welchen 
Einstellungen hier verwendet wird.

[Klaus (Gast)]

Karl heinz Buchegger schrieb:
> Vielleicht kannst du dich zufällig noch daran erinnern, was 'alles
> mögliche' gewesen sein könnte?

Da ich schon den ganzen morgen daran rumpfusche hab ich das meiste auch 
schon wieder vergessen.

So sieht mein lezter ansatz aus:

uint16_t string;
uint8_t zeichen;

zeichen = (*(uint8_t *) &string)   //erste 8bit
zeichen = (*(uint8_t *) &string+1) //letzte 8bit

[Antwort (Gast)]

uint16_t x=0xBBAA;
uint8_t* ptr;

ptr = (uint8_t*)&x;

*ptr = 0xFF;
ptr++;
*ptr = 0x00;

//ergebniss: x = 0x00FF;

[Antwort (Gast)]

Karl Heinz Buchegger war schneller.

[eklige Tunke (Gast)]

Detlev T. schrieb:
> @kbuchegg
> Du setzt damit aber voraus, dass der Compiler die Bytes "packt". Also
> jeweils 2 Bytes in ein 16-Bit-Wort.
Worauf beziehst du dich?

[Hc Z. (mizch)]

Klaus schrieb:
> zeichen = (*(uint8_t *) &string+1) //letzte 8bit

Hier solltest Du Dir mal die Rangfolge der Operatoren klar machen. 
Dadurch. dass Du manche Elemente näher zusammenschreibst, ändert die 
sich ja nicht.

Deine Setzung von Leerzeichen suggeriert eine Rangfolge, die der Sprache 
C fremd ist.  Zunächst mal ist das, was Du schreibst, dasselbe wie

zeichen = *(uint8_t *) &string+1

denn die erste und letzte Klammer sind überflüssig.  Und das ist nach 
den C-Rangregeln

zeichen = (*(uint8_t *)&string) + 1

oder, ohne überflüssige Klammern, aber auch ohne falsche Zusammenhänge 
suggerierende Leerzeichen,

zeichen = *(uint8_t *)&string + 1

Ich denke, das zeigt, was passiert.  Du bekommst das erste Byte und 
zählst 1 zum Byte dazu.

Wie Du die Klammern jetzt setzst, dass Du die 1 zum Pointer statt zum 
Byte hinzuzählst, sei Dir zur Übung überlassen.

[Karl H. (kbuchegg)]

Detlev T. schrieb:
> @kbuchegg
> Du setzt damit aber voraus, dass der Compiler die Bytes "packt". Also
> jeweils 2 Bytes in ein 16-Bit-Wort. Das ist nicht selbstverständlich

?
Ich denke bei einem uint16_t kann man schon davon ausgehen, dass die 
beiden Bytes hintereinander im Speicher liegen, auch wenn ich im Moment 
keine Stelle aus dem Standard parat habe, die das fordert bzw. offen 
lässt. Die Reihenfolge ist allerdings nicht festgelegt.

Aber ich sagte ja auch, dass die Lösung vom Floh besser ist.

[Klaus (Gast)]

Also zunächst mal Danke! Denn es geht jetzt endlich was ich wollte.

Karl heinz Buchegger schrieb:
> Ich denke bei einem uint16_t kann man schon davon ausgehen, dass die
> beiden Bytes hintereinander im Speicher liegen,

Sollte ich auch meinen, wie sonst kann mann sicher mit einem 16Bit 
Pointer einzelne 16 Bitvariablen ansprechen? Wenn dem nicht so wäre geht 
ja jeders Programm mit Pointer in die Binsen, oder nicht?

Karl heinz Buchegger schrieb:
> Aber ich sagte ja auch, dass die Lösung vom Floh besser ist.
Wieso das besser ist leuchtet mir noch nicht ein. Ich finde das 
Codebeispiel von floh nicht gut, zumal ich dann immer noch mit einer 16 
Bitvariable rum kämpfe während meine Funktion welcher ich die jetzt 
gewonnenen Werte übergebe einen Pointer auf eine 8 Bit Variable 
erwartet.

[Klaus (Gast)]

Sorry vergesst das was ich über Flohs Code gesagt habe. hab nicht gut 
genug hingekuckt! schäm

[eklige Tunke (Gast)]

eklige Tunke schrieb:
> Detlev T. schrieb:
>> @kbuchegg
>> Du setzt damit aber voraus, dass der Compiler die Bytes "packt". Also
>> jeweils 2 Bytes in ein 16-Bit-Wort.
> Worauf beziehst du dich?
Ah, habs gefunden... ;-)