wie bekomme ich von

global_fnav_lookup.subframe[_subFrm_].page[_page_].part[0..9]

den pointer auf die parts [0..9]? Da ich einen crc berechnen muss und die funktion ein ganzen stream verlangt brauche ich den Zugriff als Pointer. Weis jemand Rat?

zugriff:

global_fnav_lookup.subframe[_subFrm_].page[_page_]++;

geht nich!

Pointerarithmetik:

&global_fnav_lookup.subframe[_subFrm_].page[_page_].part[0]

Übrigens: Ich würde Variablennamen nicht mit '_' beginnen lassen - da kommst Du Dir schnell mit Compilerausdrücken in die Quere.

Gruß,

Simon2.

also ein part ist ein INT32 und 25 Bit länge wenn ich jetzt den pointer in part[0] inkrementiere bekomme ich dann das msb von part[1] oder sind da die stopfbits von part[1]? Weisst du wie ich mir einen 10x25Bits container aufbauen kann?

also ein part ist ein INT32 und 25 Bit länge wenn ich jetzt den pointer in part[0] inkrementiere

Wäre part ein INT32, wäre part[0] wohl nicht möglich. Es handelt sich wohl eher um ein INT32* oder irgendwas in der Richtung.
part[0] ist wohl kein Zeiger, sondern dann ein INT32- Und den wert wirst du wohl kaum inkrementieren wollen.

Wenn ich davon ausgehe, dass part ein Zeiger auf INT32 ist, dann ist part[1] das selbe, wie *(part+1).
Das du von dem INT32, der wohl 32 Bit hat, nur 25Bit benutzt, weiß doch niemand.

Dein 10x25-Bit-Container ist nicht ganz so einfach. Da musst du dann viel rumschiften und Bits maskieren. Ist es denn tatsächlich wichtig, das die 10x25 Bit direkt hintereinander liegen, oder können auch Padding-Bits dazwischen sein. Denn die vorgehensweise mit dem Feld von INT32 dürfte deutlich schneller und vor allem deutlich leichter umzusetzen sein, als der andere Kram.

...INT32 und 25 Bit länge ... msb von part[1] ...stopfbits ...

Das sind alles Dinge, die von Deiner jeweiligen Plattform (und Compiler/-version/-einstellung) abhängen - deswegen kann sie Dir niemand allgemeingültig beantworten !
Wenn Du eine feste Repräsentation brauchst, solltest Du sie Dir selbst erzeugen (z.B. in strings fester Länge und Orientierung kopieren) und über dieses Format Deinen CRC rechnen...

Gruß,

Simon2.

Ist es denn tatsächlich wichtig, das die 10x25 Bit direkt hintereinander liegen, oder können auch Padding-Bits dazwischen sein.

Ich denke schon das der crc computer die datenhineinander will weil ich eben die checksum brauche von dem ganzen stream. Wie will er dann denn den Rest zusammen bringen? Ich verwende jetzt eigentlich einen CRC Computer der Datei CRC berechnet der kann in meinen Fall eben auch die Größe verarbeiten.

Am leichtesten wäre es natürlich wie du sagst das ich einen durchgehenden String hätte (aber so einen großen Datentyp gibts halt nicht). Aber im Prinzip müsse ich doch alle Daten von den 25 belegten Bits nach links schieben das wären dann jeweils pro part i {1..10} mal 7 stellen rüberschieben dann bleiben hinten noch 70 Stellen frei also 2 parts kann ich dann vergessen . Wenn ich das dann hab dann schau ich das ich die Daten hintereiander als pointer bekomme...also mach ich einen INT32 *pointer auf und kopiere 32 Bits rein dann inkrementiere ich und dann die nächsten 32 Bits. Dann hab ich doch dalle Daten hintereinander. Oder liegen die Daten bereits oben als feld hintereinander? Kann es sein das Part[0] und Part[1] im Speicher ganz wo anders liegen? (Cpp Basics )

PS: Ja, die Elemente eines Arrays liegen hintereinander im Speicher

und je einen 25-Bit-Wert in einem int unterbringen

kannst du mir das noch genauer erklären?

Gruss
Sebastian

PS: Aber 25 Bit ist eine etwas ungewönhliche Größe Was genau hast du mit den Daten vor?

Am einfachsten ist da wohl fast ein:

struct Foo {
   int part0 : 25;
   int part1 : 25;
   int part2 : 25;
   ...
   int part9 : 25;
};

...Ich denke schon das der crc computer die datenhineinander will ...

Ach so - Du willst ein vorgegebenes Protokoll umsetzen ! Wusste ich nicht - ich dachte, Du wolltest Dir selbst einen crc schreiben (rechnen und prüfen in Deiner Hand). Dann wird Dir vermutlich nichts Anderes übrigbleiben, als mit Deiner Plattform rumzuprobieren.

Gruß,

Simon2.

C/C++ Code:
struct Foo {
int part0 : 25;
int part1 : 25;
int part2 : 25;
...
int part9 : 25;
};

Achso du meinst Bitfelder? Nagut, dann kann ich mir das ganze schieben sparen und hab die daten direkt auf 25 Bit beschränkt, nur diese benötige ich eben als pointer.

@CStoll: Was genau hast du mit den Daten vor?

Die Daten repräsentieren eine GALILEO Navigationsmitteilung also die Daten die ein Satellit zur Erde sendet. Im SIS ICD (Signal in Space Interface Control Document) ist diese mit 250 Bit festgelegt. Der eigentliche Payload ist aber nur 208 Bit groß. Diese 208 Bit Daten müssen aber jetzt erst durch den CRC laufen und dieser Rest (=24 Bit lang)wird dann an die 208 Bit angefügt. Ich habe mir eben überlegt alle Daten auf 10 Parts aufzuteilen (10x250 Bit). Ich brauch aber jetzt erstmal die 208 Bit die in der NavMsg in der Mitte stehen (muss ich noch rausgreifen aus den 250 Bit)
Der CRC Computer benötigt einen Stream der durch 4 Teilbar ist. Passt also: 208/4 = 26.
Naja aber das Problem ist jetzt erst nochmal das der CRC Computer welcher auch immer einen Pointer auf die 208 Daten benötigt.

@Simon2: (...)ich dachte, Du wolltest Dir selbst einen crc schreiben (...)

am anfang hatte ich es schon vor bloss ich hab einfach keine Erfahrung wie man einen crc von einem 250Bit großen Datenstrom bestimmt. Vielleicht jeweils byteweise die polydivisoin durchführen und dann den rest irgendwie zusammenfassen. Aber egal. Ich glaub ich verwende jetzt lieber eine vorgegebenen weil bis ich einen selbstgeschriebenen wieder gedebugt und getestet habe geht brauchts einfach zu viel zeit

@CStoll: (...) wäre aber ein bitset<250> oder vector<bool> geeignet(...)

das ist doch genau das was ich suche ich muss mir dann aber gedanken machen wie ich daraus dann einen UINT8 *data_array mache