Daten aus 2 hintereinander liegenden Registern in ein char[8] Array einlesen

[arwar52]

Hallo Kollegen,

hat jemad ne Lösung zu so einem Fall ???
- Daten aus 2 hintereinander liegenden 32 bit Registern (insgesamt 2 x 4 = 8 Bytes) in ein char[8] Array einlesen

Theoretisch sollte man es mit Pointer erledigen können

- 1. Pointer auf den Anfang des 1. Register setzen.
- 2. Pointer auf den Anfang des char Arrays setzen

- in einer "for" Schleife bis 8
- - Byte vom Register ins char Array einlesen
- - beide Pointer incrementieren
- und so 8x

Kann das so funktionieren ???
. . . komm irgendwie nicht zu Recht.

Über eine Lösung freue ich mich jetzt schon

DANKE

[HaWe]

hallo,
ja, das geht mit memcpy:
http://www.cplusplus.com/reference/cstring/memcpy/

void * memcpy ( void * destination, const void * source, size_t num );


der char array ist ja bereits ein pointer,
für die Variable reg musst du dann ihre Adresse &reg einsetzen.


wenn destination der array ist, und du an pos. 0 des arrays einfügen willst, hieße es
uint32_t reg;
char destination[8];

memcpy ( destination, &reg , sizeof(reg) );

willst du dies 4 Stellen weiter machen, dann

memcpy ( destination+4*sizeof(char), &reg , sizeof(reg) );
da sizeof(char) = 1 ist, vereinfacht
memcpy ( destination+4, &reg , sizeof(reg) );



oder wenn dein array noch größer als 8 wäre, z.B. für 20 Stellen weiter:

char destination[100];
memcpy ( destination+20, &reg , sizeof(reg) );


oder allgemein

memcpy ( destination+charpos, &reg , sizeof(reg) );

[arwar52]

DANKE HaWe.
Werde es mal versuchen

- - - Aktualisiert - - -

... leider arbeite ich in einer ganz bestimmten Umgebung die KEINEN memcpy hat

Konnte es erstmal so lösen:
+++++++++++++++
for (i=0; i < 8; i++){
Data[i] = *pRegister;
pRegister++;
}

++++++++++++++++

Leider frunktioniert es NICHT in die andere Richtung - vom Array ins Register.
Egal in welchen Byte des Registers man den char schreibt - alle 4 Bytes des Registers werden mit dem selben char beschrieben ???
Das andere Register bleibt unberührt.
Sobald i > 3, passiert das gleiche mit dem 2. Register.

Also man sieht
- beide Zeiger bewegen sich Byte für Byte entlang der beiden Registers und Array.
- es werden die richtigen char's geschrieben

NUR diese char's befüllen nicht ein Byte des Registers sondern ALLE Bytes - und das ist nicht gewünscht . . .

Wo könnte da der Fehler liegen?
+++++++++++++++++++++++++++++++
for( i = 0; i < 8; i++ ){
*pTxRegister = Data[i];
pTxRegister++;
}
+++++++++++++++++++++++++++++++

[Siro]

Ich vermute hier gibt es eine Vermischung zwischen 2 verschiedenen Pointern
Da es sich anscheinend um eine 32 Bit ARM Prozessor handelt, hat ein Register 4 Bytes.
Bei deinem Dein Array hat jeder index nur ein Byte.
Das Problem tritt nun auf, wenn Du den Register Pointer mit ++ erhöhst.
Da der Pointer auf einen 4 Byte Wert zeigt, wird die Adresse auch gleich um 4 Bytes erhöht.

Du benötigst einen char* also einen Character Pointer auf dein Register

char *pRegister; // ein Byte Zeiger auf irgendwas

pRegister = (char*)&DeinRegister; // Der Zeiger setzt Du auf die Adresse des Registers

Data[i]=*pRegister++; // nun werden die Bytes kopiert uind der Zeiger wird Byteweise erhöht.

Siro

[arwar52]

Hallo Siro.

- eigentlich habe ich den pointer als char *pTxRegister deklariert.
Und im Debag modus siet man auch - nach ++ erhoht sich der Pointer um 1 Byte , nicht um 4.

[Siro]

Ich hab das grade so ausprobiert mit 4 Bytes,

char Data[8];
volatile unsigned int value;                      
volatile char* pRegister;   // muss ein byte Zeiger sein

int main(void)
{ int i;

    value = 0xAABBCCDD;         // Testweise einen Wert ins register bzw. Speicher schreiben
    pRegister = (char*)&value;   // hier setze ich die Adresse 

    for (i=0; i<4; i++)
    {
      Data[i]=*pRegister++;   // alle Bytes kopieren

    }
}

ich hab jetzt nur mal 4 Bytes kopiert. Wenn deine anderen 4 bytes genau dahinter stehen, kannst Du natürlich alle 8 kopieren