Auf ein Byte zugreifen

Oktoberfestbesucher schrieb:
> Hallo,
> Ich sammle so meine ersten Programmiererfahrungen mit dem ATtiny25 und
> AVRStudio4.
> es geht mir um die Frage, wie ich auf ein einzelnes der 4 Byte einer
> unsigned long int variable zugreifen kann.
> ...

Dazu gibt es mehrere Varianten (je nach persönlicher Vorliebe)
hier schon etliche Threads:
- Adresse der Variable in eine uint8_t* casten und darüber mit
  einem Index auf dei Byte zugreifen (mein Favorit)
- Mit einer union (Liebling der meisten anderen)
- Shiften so wie du es machst (portabel, aber ansonsten
  uneffizient und unschön m.E.)
- ...

> Ich weiss jetzt nicht ob der GCC (AVRWIN) meine Absicht durchschaut und
> das obtimieren kann, oder ob der jetzt beigeht und tatsächlich 24 mal
> schieben läßt.

Ich fürchte nein; genaueres sieht man am erzeugten Code.

Jo, genau so meinte ich das.

(Danke, habe in der Zwischenzeit nett gegrillt und ein leckeres 
Rauchbier getrunken...)

Wobei es auch ohne Zeigervariable geht; nicht unbedingt besser oder 
übersichtlicher, aber geiziger:

1

  uint32_t Value;

2

3

  for( i = 0; i < sizeof( Value ); ++i )

4

    output( ((uint8_t*)&Value)[i] );

Mit dem output hatte ich ja nur die Version von KHB aufgegriffen.

Original hast du ja direkte Zuweisungen.
Das würde etwa so aussehen:

1

    // eine Richtung:

2

    mybyte_mostsignificant = ((uint8_t*)&Value)[3];

3

    mybyte3                = ((uint8_t*)&Value)[2];

4

    mybyte2                = ((uint8_t*)&Value)[1];

5

    mybyteleastsignificant = ((uint8_t*)&Value)[0];

6

7

    // andere Richtung:

8

    ((uint8_t*)&Value)[3] = mybyte_mostsignificant;

9

    ((uint8_t*)&Value)[2] = mybyte3;

10

    ((uint8_t*)&Value)[1] = mybyte2;

11

    ((uint8_t*)&Value)[0] = mybyteleastsignificant;

"most" und least" bezieht sich auf einen Rechner mit Little 
Endian-Architektur, bei einem BE-System müsste man die Bytes andersrum 
interpretieren.

Oktoberfestbesucher schrieb:
> Ich versteh es noch nicht ganz 100%,

&Value liefert dir die Adresse deiner Variable value (von der
ich ausgehen, daß sie 32 Bit groß ist).

(uint8_t*)&Value ist immer noch dieselbe Adresse, allerdings
zu interpretieren als Zeiger auf uint8_t, also Zeiger auf Byte.
Das könnte jetzt ein Zeiger auf ein Byte sein, oder auf das erste
eines ganzen Felds von Byte.
(Siehe C-Buch: Analogie zwischen Zeigern und Feldern...)

Mit ((uint8_t*)&Value)[0] etc. nimmt man jetzt das
soundsovielte Element des vermeintlichen Feldes, als das
soundsovielte Byte von Value.
Solange man im Bereich [0] bis [3] bleibt, greift man damit
auf die entsprechenden Byte von Value zu.