AVR: größe der Variablen

Du sagst mit uint16_t dem Compiler, dass in die Zahl 16-Bit passen 
müssen. Ob er die dann in Registern vorhält oder im RAM zwischenlagert 
ist dem überlassen.
Auf einem 8-Bit System muss er halt 2 Speicherplätze verwenden und bei 
jeder Rechenoperation das Carry zwischen den Zellen mitnehmen.

Du kannst auch uint16_t und uint32_t usw. verwenden, allerdings bremst 
das natürlich den Fluss je nach Operation aus, weil der Compiler 
nacheinander die einzelnen Bytes bearbeiten muss.

Auf einem ATMega1284 könntest Du eine uint131072_t-Variable verwenden 
wenn Du ohne Stack usw. auskommst.

Sebastian T. schrieb:
> Ich beschäftige mich seit einiger Zeit mit der AVR Programmierung.

Anscheinend mit der Programmierung in C. Das ist wichtig zu erwähnen. 
Denn natürlich gibt es auch noch andere Programmiersprachen für den AVR 
oder man kann ihn in Assembler programmieren.

> Wenn ich uint8_t benutze, erstelle ich doch eine 8bit große Variable.

uint8_t ist - wie der Name schon sagt - ein Typ für vorzeichenlose 
Ganzzahlen mit (mindestens) 8 Bit Breite. Beim AVR sind es sogar genau 8 
Bit Breite, weil das seine natürliche Datenbreite ist.

> Darf man aber auf einem 8bit AVR einfach größere Variablen wie z.B.
> uint16_t, uint32_t oder gar uint64_t benutzen??

Ja. Genauer gesagt darfst du alle Typen nutzen, die der C Compiler für 
den AVR kennt. Die genannten gehören alle dazu.

> Und falls doch, wie funktioniert das? Werden bei uint16_t zwei
> Speicherregister verwendet?

Im Prinzip ja. Wobei der C-Compiler nicht zwangsweise die komplette 
Variable auf einmal in Registern halten muß. Beim AVR würde das gehen, 
aber C gibt es ja auch für Architekturen wie den 6502 oder STM8. Die 
haben nur einen 8-Bit Akku. Die können also die z.B. 8 Bytes eines 
uint64_t gar nicht auf einmal in Registern halten. Sondern müssen die 
Variable byteweise aus dem Speicher in den Akku laden, bearbeiten und 
wieder wegspeichern.

Dieser Komfort ist ein Grund, warum C sich gegenüber Assembler 
durchgesetzt hat.

Axel S. schrieb:
> uint8_t ist - wie der Name schon sagt - ein Typ für vorzeichenlose
> Ganzzahlen mit (mindestens) 8 Bit Breite.

Mit exakt 8 Bits. Mindestens 8 Bits gibts bei int_least8_t.

Sebastian T. schrieb:
> Darf man aber auf einem 8bit AVR einfach größere Variablen wie z.B.
> uint16_t, uint32_t oder gar uint64_t benutzen?

Darf man, kann man. Ist kein Problem. Dass die AVRs 8 Bit µCs sind hat 
nichts mit der Größe der Variablen zu tun sondern, grob gesagt, wie sie 
Befehle und Daten verarbeiten. Das passiert idR immer nur in 8 Bit 
Blöcken.
Ist jetzt mega oberflächlich aber ich denke es genügt zur Beantwortung 
deiner Frage. Für Genaueres empfehle ich dir das Studium entsprechender 
Literatur wenn du mehr darüber erfahren willst, was 8 Bit Prozessor 
bedeutet.

Sebastian T. schrieb:
> Wenn ich uint8_t benutze, erstelle ich doch eine 8bit große Variable.

Bitte beachten, dass Operationen in C auch dann mit mindestens der 
Breite von "int" oder "unsigned" gerechnet werden, wenn die darin 
vorkommenden Datentypen kleiner sind. Da "int" und "unsigned" mindestens 
16 Bits breit sein müssen, gibt es in C formell keine 8-Bit Operationen. 
Zumindest muss das Ergebnis dieser Vorschrift entsprechen, real kommen 
8-Bit Operationen also vor.

Die Berechnungen in C werden mindestens als int durchgeführt.

Ein int hat laut C-Standard mindestens den Wertebereich von -32767 bis 
32767.

Dirk B. schrieb:
> Die Berechnungen in C werden mindestens als int durchgeführt.
>
> Ein int hat laut C-Standard mindestens den Wertebereich von -32767 bis
> 32767.

Das mag sein aber wenn man int8_t schreibt für einen Mikrocontroller 
dann kann es einem recht egal sein wie das in C gerechnet wird, auf dem 
µC wird es von -127 bis 128 gehen (Übrigens: dein int geht bis 32768, 
nicht 32767 ;)).

Sebastian T. schrieb:
> Darf man aber auf einem 8bit AVR einfach größere Variablen wie z.B.
> uint16_t, uint32_t oder gar uint64_t benutzen??

Du darfst sogar float und double benutzen, obwohl der AVR keine FPU hat. 
Beides ist auf dem AVR-GCC 4 Byte groß.

Nicht nativ unterstütze Rechenarten werden emuliert, d.h. es werden 
Bibliotheksfunktionen aufgerufen.