unsigned char -> unsigned int und zurück

[Joe (Gast)]

Hallo zusammen,

habe folgendes Problem. Ich habe insgesamt 3 unsigned int. Werte (16
BIT) und will diese in einem char. (Byte) organisierten Speicher
ablegen.

Wie kann ich z.B. aus 0xFFEE 2 char. mit jeweils 0xFF sowie 0xEE
erzeugen und umgekehrt. Wenn ich den Speicherinhalt zurück lese erhalte
ich ja wieder 2 char. und möchte diese wieder in ein unsigned int. Wert
überführen.

Jetzt das Problem, ich kann es mir nicht leisten das ganze mit einer
Bibliotheks Funktion zu realisieren. Will sagen, kein Programmspeicher
mehr für weitere Includes.

Hoffe irgendwer hat ne einfache Lösung.

Dank im vorraus.

[johnny.m (Gast)]

unsigned char c_array[3][2]; //3*2 character
unsigned int i_array[3]; //3 integer
//...
//3 int -> 3*2 char:
for(i = 0; i < 3; i++)
{
    //Low Byte speichern:
    c_array[i][0] = (unsigned char) i_array[i];
    //High-Byte speichern:
    c_array[i][1] = (unsigned char) (i_array[i] >> 8);
}

//...

//3*2 char -> 3 int:
for(i = 0; i < 3; i++)
{
    i_array[i] = ((unsigned int)c_array[i][1] << 8) | c_array[i][0];
}

[Joe (Gast)]

Hi Johnny,

wenn ich solche Lösungen sehe dann komm ich mir echt unterbelichtet
vor, super, danke, ich werds ausprobieren, hast du noch ein paar
erklärende Worte ?

[johnny.m (Gast)]

[Rahmenbedingungen]
Du hast am Anfang drei int-Werte, die Du sinnvollerweise in einem Array
speicherst (hab ich mal i_array gennant, weil mir nix besseres
eingefallen ist). Daraus sollen drei mal zwei char-Werte (jeweils High-
und Low-Byte) werden, die dann in irgendeinen nicht näher spezifizierten
(vermutlich externen) Byte-organisierten Speicher geschrieben werden
sollen.
[/Rahmenbedingungen]

Für die zu erzeugenden char-Werte wird ebenfalls ein Array angelegt
(zweidimensional, sind ja zu jedem Index zwei Werte zu speichern), das
ich mal c_array genannt habe. Die erste for-Schleife fängt beim int mit
dem Index 0 an, speichert das Low-Byte (wird bei der Typkonversion
automatisch extrahiert) im char c_array[0][0]. Dann wird das High-Byte
(um 8 Stellen nach rechts, also auf die Position des Low-Bytes
verschoben) in c_array[0][1] gesichert. Das ganze drei mal, dann sind
die Integer umgewandelt. Das char-Array kann man jetzt in den externen
Speicher schieben.

Der umgekehrte Fall: Die char-Werte werden (in der richtigen
Reihenfolge) aus dem externen Speicher geholt und im c_array abgelegt.
Dann werden mit einer Schiebe-Operation und einem bitweisen ODER (man
kann an der Stelle auch ein '+' schreiben, aber mir ist es so lieber,
weil man besser sieht, was da passiert) die int-Werte wieder
zusammengepuzzelt. Wichtig ist die Reihenfolge der Typkonversionen
(erst den char nach int casten, dann schieben, sonst kommt Null raus).
Gleiches gilt natürlich oben in der ersten for-Schleife.

[Joe (Gast)]

super Erklärung, vielen Dank, ich hoffe das ich irgendwann auch mal C
derart beherrsche.

[thkais (Gast)]

Man könnte es auch mit einer union machen...

[Karl heinz B. (kbucheg)]

Man könnte aber auch einfach nur die Adresse an
der die int's gespeichert sind, in einen Pointer
auf unsigned char umcasten und so auf die Bytes
zugreifen.

  int Werte[3];

diese Werte muessen irgendwo gespeichert werden, ich geh
mal davon aus, dass es eine Funktion gibt, die die
Werte speichert (ala: Eprom Write)

  int i;

  for( i = 0; i < sizeof( Werte ); ++i )
    EEpromWrite( Adresse, ((unsigned char*)Werte) + i );

und zum zurücklesen:

  for( i = 0; i < sizeof( Werte ); ++i )
    *((unsigned char*)Werte) + i ) = EEpromRead( Adresse );

Was dann einfacher ist, hängt vom konkreten Anwendungsfall
ab.

[Joe (Gast)]

Hallo Karl Heinz,

habs heute erst gelesen, tolle Idee, danke dafür.