16-bit int in 2 8-bit int zerlegen

[Christoph2]

Hallo!

Ich muss einen 16 Bit int-werte in 2 8-Bit werte zerlegen, damit ich diese über I2C an meinen motorcontroller schicken kann.

Gibt es dazu in avr-gcc eine funktion?

Ich hab mir auch schon selber ein programm überlegt, nur weiß ich nicht wie die vorzeichen sein müssen. Sollen die dann zum höherwertigen byte oder zum niederwertigeren?

int8_t int16to8_high(uint16_t variable)
{	variable=variable/128;

	//vorzeichen??

	return(uint8_t) variable;
}

int8_t int16to8_low(uint16_t variable)
{	variable=variable & 0b1000000001111111;
	return (uint8_t) variable;
}

Also hier ist mein programm, gibt es von avr-gcc auch eins?

lg christoph

[Dirk]

Wahrscheinlich stellt sich deine Frage so gar nicht. Wenn du einen Integer-Wert (var) in 2 Bytes verschicken must, kannst du das einfach so machen:
LByte = var;
HByte = (var >> 8 );

Auf der anderen Seite wird der Wert wieder hergestellt:
var = ((HByte << 8 ) | LByte);

Oder habe ich deine Frage nicht verstanden?

Gruß Dirk

[Christoph2]

Nein du hast das richtig verstanden, danke.
Ich hab an das verschieben garnicht gedacht, immer nur an dividieren... aber eigentlich ist das ja das selbe...

wenn ich so mache:

variable8bit = (uint8_t) variable16bit;

Dann fallen einfach die höheren 8 bit der 16-bit variable weg oder?


lg Christoph

[Dirk]

Ja genau.

Gruß Dirk

[Besserwessi]

Man kann auch direkt auf die einzelnen Bytes zugreifen, wenn man die Variable als union definiert.

Es könnte sein dass GCC das per Optimierung auch so hinkriegt. Manchmal geht die Optimierung ja sehr weit, einige einfach aushende Dinge klappen aber auch nicht.

[Christoph2]

Hi!

Danke, ich hab jetzt ein programm zum umwandeln von 16 bit in zwei 8 Bit werte, es funktioniert super.

Jetzt brauche ich einens, dass es umgekehrt macht, von zwei 8 bit werten in eine 16 bit variable.

Ich wollte das so machen:

int16_t int8to16(int8_t high, int8_t low)
{	uint16_t out;

	out = (high<<8);
	out = out | low;

	return out;
}

Es funktioniert aber leider nicht. Es kommen irgendwelche zufallszahlen heraus, ich vermute einen vorzeichenfehler. aber ich kann nicht erkennen wo da ein fehler sein soll.

Könnt ihr euch das mal ansehen?

lg christoph

[McJenso]

Hallo,

hast du mal Beispielzahlen. low darf natürlich nur unsigned sein. Was soll sonst z.B. high = 16 und low -5 ergeben?
Was meinst du mit Zufallszahlen? Bei gleichen Parametern verschiedene Ergebnisse?

Gruß

Jens

[Dirk]

Hallo Christoph2,

in deiner Funktion müssen die 8-Bit-Variablen uint8_t sein und die out-Variable natürlich int16_t.

Gruß Dirk

[Christoph2]

ahhh danke!!
Es funktioiert!!

Ich hab aber nur die low variable uint8_t gemacht, die high hab ich int8_t gemacht, sonst hab ich keine vorzeichen bei der int16_t.

lg und danke
Christoph

[Peter(TOO)]

Hallo Christoph,

ahhh danke!!
Ich hab aber nur die low variable uint8_t gemacht, die high hab ich int8_t gemacht, sonst hab ich keine vorzeichen bei der int16_t.

Ich denke du hast das mit signed und unsigned noch nicht wirklich verstanden.

Der 8-Bit-Wert 0b11111111 hat unsigned den Wert 255 und signed -1.
Das höchstwertige Bit ist das Vorzeichen 0 = "+" und 1 = "-" (zumindest beim üblichen 2er Komplement)

Wird nun unsigned auf 16-Bit erweitert ergibt dies 0b00000000'11111111, bei signed wird es 0b11111111'11111111

Der 8-Bit-Wert 0b01111111 ist unsigned und signed = 127.
Entsprechend wird unsigned und signed als 16-Bit 0b00000000'01111111

Bei der Erweiterung werden die zusätzlichen Bits bei unsigned immer mit 0en gefüllt.
Bei signed, entsprechend dem Vorzeichen-Bit mit 0en oder 1ern.

MfG Peter(TOO)