word -> 2 bytes

"und weiss auch nicht wie ich das ohne großen aufwand testen könnte."
mit einem x beliebigen pc c compiler

word w;
byte bl,bh;

bl = w & 0xFF;
bh = w >> 8;

Danke für deine schnelle antwort.

für was ist bei "bl = w & 0xFF;" die verknüpfung mit 0xFF ?
ist die nicht sinnlos ?

MfG Dani

Noch eine Möglichkeit, die zwar kompliziert aussieht aber
meist kürzer codiert und dadurch schneller ist:

typedef struct  {
  union  {
    struct  {
      unsigned char ucLow;
      unsigned char ucHigh;
    } bytes;
    struct  {
      unsigned int wWort;
    } word;
  } u;
} WTOB;

WTOB sWort;
unsigned char ucByte1,ucByte2;


sWort.u.word.wWort = 0x0FF0; // Beispiel

ucByte1 = sMerkBestCS.u.bytes.ucLow;
ucByte2 = sMerkBestCS.u.bytes.ucHigh;

Es entfällt dabei das ausmaskieren mit FFh und das Schieben
eventuell muss noch dir Reihenfolge ucLow/ucHigh angepaßt werden

Gruss

Sorry: ich gehe davon aus das unsigned int == 16Bit
solltest du eventuell noch in unsigned short umändern.

Gruss

@T.Stütz: kannst du deine variante mal ein bisschen erklähren ?
was bedeutet das union ?
und wiso ist bytes und word nicht getrennt im speicher ?

hab in meinem C++ buch nix zu union gefunden ;(

MfG Dani

unsigned int sind doch auch 16 bit.
(zumindes bei 16 bit systemen)

in einem union sind alle elemente im gleichen speicherbereich
unterbracht, überschneiden sich also

heisst das, dass wenn ich

      unsigned char ucLow;
      unsigned char ucHigh;

vertauschen würde, würde auch ucLow das andere byte bekommen ?

ja, dann wäre low und highbyte vertauscht

Also mit "union" werden in meinem Falle 2 Speicherbereiche quasi
übereinandergelegt:
 1xword (16Bit) und
 2xbyte (jeweils 8Bit)

Ich übertrage also ein Wort in ein 16Bit speicher
und kann dann danach BYTEweise zugreifen. Ein guter Compiler mach aus
der C-Source in Assembler ein laden eines 16Bit-Register mit
nachfolgendem Transfer der Byte(Hälften) in den neuen Speichern

Bei C++ wirst du das vermutlich nicht finden,
ist schon bei C möglich (K&R-C)

Hoffe das Hilft , Gruss

OK, ich glaub ich habs verstanden. Hab doch was über union in meinem
buch gefunden.
Noch eine letzte frage:
würde das auch so gehen:?

  union WTOB
    {
      unsigned short w_word;
      struct
      {
        char byte1;
        char byte2;
      } bytes
    };

char byte_1;
WTOB a;
a.w_word = 0x0FF0;
byte_1 = a.bytes.byte1;


MfG

Geht natürlich auch.
Gruss

Ok, vielen dank nochmals !!!
Gruß

Noch mal ein Problem:
hab nun meine structur so definiert:

union WordADR
{
  unsigned short W_Adr;
  struct
  {
  char byte1;
  char byte2;
  } bytes
};

jetzt will ich die structur überladen:

char Read_F(WordADR.W_adr AdressA, uint8_t Select_byte);

so gehts nicht. kann ich das irgendwie anders machen ?
Ich weiss ich kann einfach ein word übergeben und dann dem WordADR
zuweisen aber geht das nicht irgendwie eleganter ?

MfG

WordADR.W_adr ist kein Datentyp sondern eine Variable.
Nimm mal WordADR.

Was soll Read_F machen ?

Eine Funktion überladen heißt ja, das es mehr als eine
GLEICHNAMIGEFunktion gibt mit unterschiedlichen Parametern oder
eine Klasse die von einer anderen Klasse abgeleitet wurde und dort
einer (virtuellen) Funktion ein anderes Verhalten beigebracht wird.

Gruss

Mit WordADR gehts auch nicht. Ich kann nichtmal in einer funktion ein
solches Object erstellen. Da kommt immer der fehler: WordADR
undeclared, first use in this function.
Dieser fehler tritt auch bei folgendem code auf:

union WordADR
{
  unsigned short W_Adr;
  struct
  {
  char byte1;
  char byte2;
  } bytes
};

void main()
{
WordADR a;
}

(ich benutze den WINAVR)
PS: die funktion liest daten aus dem eeprom und legt die userdaten in
den entsprechenden variablen ab.

MfG

Probiers mal so:

  typedef union
  {
    unsigned short W_Adr;
    struct
    {
    char byte1;
    char byte2;
    } bytes
  } WordADR;

  void main()
  {
  WordADR a;
  }

oder so:

  union WordADR
  {
    unsigned short W_Adr;
    struct
    {
    char byte1;
    char byte2;
    } bytes
  };

  void main()
  {
  union WordADR a;
  }

Derlei Details sind übrigens im Buch "Programmieren in C*" (Kernighan
& Ritchie, zweite Auflage, Hanser Verlag) gar nicht so schlecht
beschrieben.


*) Ja, Textbaustein. Und Kommission einfordern. Sollte ich jetzt
wirklich mal.

schäm
@ Rufus T. Firefly
Du hast natürlich Recht !

noch eine kleine bemerkung am rande:

die methode mit schieben und maskieren ist unabhängig von der
endianness der target cpu, die variante mit der union dagegen nicht.

Ja, hab ich auch gestern bemerkt.
Danke nochmal!