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

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 :p

DANKE

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) );

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++;
}
+++++++++++++++++++++++++++++++

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

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.

Ich hab das grade so ausprobiert mit 4 Bytes,

Code:

---


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

Hi Siro,
danke für Deine Mühen :-)

Was Du gerade zugeschikt hast - vom Register ins Array - funktioniert bei mir auch - siehe oben um 20:38

Ich stecke fest bei Übertragung der Daten vom Array ins Register . . . :( siehe oben um 20:38

Code:

---

struct  // hier habe ich eine 8 Byte Struktur
{
  unsigned int a;  // 4 Bytes
  unsigned int b;  // nochmal 4 Bytes
} value;

char* pRegister;

unsigned char Data[8];

int main(void)
{int i;

    // 8 Bytes initialisieren
    value.a = 0x11223344;
    value.b = 0x55667788;

    pRegister = (char*)&value;  // Zeiger setzen

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

  // !!!!! den Pointer wieder richtig setzen !!!! hatte ich eben auch vergessen.....
    pRegister = (char*)&value;  // Zeiger wieder auf Start setzen

    for (i=0; i<8; i++)    // alle 8 Bytes zurück kopieren
    {
      *pRegister++=Data[i];
    }

---

. . glaube es siet bei mir ziemlich änlich aus ausser das ich CAN Register mit bestimmten Adresse anspreche.

Aber das ist ja auch NUR Speicher . . .

++++++++++++++++++++
char Data[8] = "11223344";

volatile char *pTxRegister = (char *)(CAN1_BASE + CAN_TDL0R_OFFSET);

for (unsigned char i = 0; i < 8; i++){
*pTxRegister = Data[i ];
pTxRegister++;
}

Müsste doch gehen, ABER
jedes Zeichen wird nicht nur in das adressierte Byte sondern in jedes der 4 Bytes des Registers übertragen.

- - - Aktualisiert - - -

. . ok hab es erst mal so gelöst:
pTxReg1 = Data[i+3] << 24 | Data[i+2] << 16 | Data[i+1] << 8 | Data[i+0];
pTxReg2 = Data[i+7] << 24 | Data[i+6] << 16 | Data[i+5] << 8 | Data[i+4];

i - ist die Verschiebung durch das Data Array.

Ist nicht so elegant wie ne Schleife aber erfüllt den Zweck.

Trotzdem würde mich interessieren wieso es mit der Schleife nicht tut ???
Wo ist da der Fehler ??

Zitat:

---

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

---

memcpy ist Teil der Bibliothek <cstring> bzw. <string.h> , wieso kannst du die nicht #includen? Das ist schließlich eine C99 Standardbibliothek, die jeder C Compiler einbinden kann.