Hallo, ich habe zwei Hex Werte, gibts eine Möglichkeit wenn der eine Wert über 0xFF drüber is, das er den andern auf 0x01 erhöht? ich mein mit einer if schleife gehts ja ohne weiteres, gibts da eine elegantere Lösung??? Danke
Gast
#285779
nimm doch gleich ein integer :-)
Was soviel heißt wie? ;-) Wie bau ich den dass so auf das er mir dann den zweiten hex wert erhöht? Also mit einer if Abfrage bekomm ich das schon hin, wollt nur wissen obs irgendwie eleganter geht! Beispiele wären super. Danke
Gast
#285781
Erhöhe i um eins wenn j = 42 ist: i += (j == 42); Das geht so m.W. aber nur in C.
Gast
#285782
"Was soviel heißt wie? ;-)" Zähle mit einer Variable und teile sie erst bei Bedarf in Low- und High-Byte: unsigned int val; ... val++; ... unsigned char low = val; unsigned char high = val / 256; Peter
Gast
#285783
Hallo Peter
Bei Deiner Lösung muss aber immer noch gerechnet bzw. geshiftet werden
um die Bytes aufzuteilen. Da ist die Variante mit einem "if"" immer
noch schneller und effizienter!
Am effizientesten lösst man die Sache mit einer UNION.
// -----------------------------------------------
// definiere ein UNION, zum Beispiel:
// -----------------------------------------------
union {unsigned int u16; unsigned char u08[1];} val;
// -----------------------------------------------
// d.h. val.u08[0..1] (2 Byte Array) nutzt den
// selben Speicherplatz wie val.u16 (16 Bit Integer)
// -----------------------------------------------
unsigned char temp; // eine weitere Temp-Variable
// -----------------------------------------------
// einige Bespiel Anweisungen
// -----------------------------------------------
val.u16=0x12AB; // 16-Bit Wert setzen
temp = val.u08[0]; // Low Byte => temp = 0xAB
temp = val.u08[1]; // Hi Byte => temp = 0x12
val.u08[0] = 0xFF; // nun ist val.u16 = 0x12FF
val.u16++; // +1 => val.u16 = 0x1300
temp = val.u08[0]; // Low Byte => temp = 0x00
temp = val.u08[1]; // Hi Byte => temp = 0x13
// -----------------------------------------------
Ich hoffe das Beispiel reicht aus, um es zu verstehen...?
Gruss Peter
Gast
#285784
@Peter Sager Da ich mit verschiedenen CPUs arbeite, vermeide ich Compiler- und CPU-abhängigen Code, wenn immer es geht. Siehe: http://www.mikrocontroller.net/forum/read-1-297451.html#new Peter
Gast
#285785
...Und da ich auf "kleinen" CPU's arbeite vermeide ich alles, was mein Program gross und langsam macht. "unsigned char" ist immer 8 Bit. Doch wer nicht weiss ob der "int" für seinen Compiler+CPU 16-Bit oder 32-Bit hat, der sollte lieber die Finger von Hardwarenaher SW für Embedded-Systems lassen. Oder für Porttierbarkeit noch besser: C99 bzw. GNU99 Integer-Typen verwenden, die sind nämlich eindeutig! Bei AVR-GCC zum Beispiel: // Integer types having exactly the specified width typedef signed char int8_t typedef unsigned char uint8_t typedef signed int int16_t typedef unsigned int uint16_t typedef signed long int int32_t typedef unsigned long int uint32_t typedef signed long long int int64_t typedef unsigned long long int uint64_t Gruzzo Peter
Gast
#285786
@Peter "...Und da ich auf "kleinen" CPU's arbeite vermeide ich alles, was mein Program gross und langsam macht." Ehe Du solche unsinnigen Behauptungen aufstellst, probiers doch erstmal aus. Für die Division /256 kriegt der Compiler nämlich mit, daß er einfach nur das High-Byte nehmen muß. Geschiftet wird da absolut nichts. Die Größen- und Laufzeitunterschiede dürften unter 0,1% bezogen auf ein komplettes Programm liegen. Ich will mich nicht dafür interessieren müssen, welche Byteorder nun welcher Compiler intern verwendet. Und deshalb lege ich mir solche faulen Eier nicht ins Nest. Peter
Danke vielmals für die Antworten, ich werd Peters Vorschlag mal ausprobieren! PS: Eine Frage an Peter Danneger, wegen dem Bootloader, ich weiß es gehört da nicht wirklich hin! Wäre super wenn du dich melden könntest, der Bootloader lief bei mir mit einem Max232 aber seit ich nenn FTDI verwende will er nicht mehr... Danke michi