wieder mal USART+Interrup

Siehe:

Beitrag "AVR-GCC: UART mit FIFO"

Fallgrube 2.

Da Deine Indexe 16-bittig sind, trifft auch Fallgrube 3 zu.


Peter

Andre F. wrote:

> Zwei frage habe ich aber noch, warum ist esschlimm wenn ich mit 16 Bit
> Zahlen arbeite?

Warum soll es schlimm sein?
Es ist nur Verschwendung von Flash und SRAM.


> Ich weis zwar das es theoretisch möglich wäre das eine Operation mit der
> Zahl nicht Atomar ist und somit theoretisch unterbrochen werden kann,
> aber warum stellt das ein problem dar?

Nicht nur theoretisch, das passiert auch praktisch.
Und wenn ein Fehler nur einmal am Tag auftritt und die Software 
ausrastet, dann viel Spaß beim Debuggen.
Fehlervermeidung ist 1000-mal effektiver als Fehler debuggen.


> Werden Register nicht vorher
> gesichert bevor sie in anderen Routinen wieder verwendet werden?

Welche Register, es geht um Variablen.
Wenn z.B der Interrupt einen 2-Byte Wert von 0x01FF auf 0x0200 ändert 
und das genau zwischen den 2 Bytezugriffen des Main passiert, dann 
kriegt das Main einen völlig anderen Wert, wie 0x02FF oder 0x0100, je 
nach Lesereihenfolge.



> Meine Zweite Frage wäre, aus welchem Grund werden die Zugriffe
> (puffer_schreiben++) weg optimiert?

Woher weißt Du das, auf welche Codezeile bezieht sich das?


Peter

@ Peter Dannegger:

>> Meine Zweite Frage wäre, aus welchem Grund werden die Zugriffe
>> (puffer_schreiben++) weg optimiert?
>
> Woher weißt Du das, auf welche Codezeile bezieht sich das?

Ich vermute, er bezieht sich auf diesen Satz:
> Fallgrube 2:
> Da hier Interrupts mit main-Funktionen kommunizieren, müßten die Indexe
> als volatile definiert werden, damit sie der AVR-GCC nicht wegoptimiert.
und hat als Beispiel eine Codezeile, wo auf den Index zugegriffen wird, 
rausgesucht.


@ Andre F.:

Es geht dabei nicht darum, dass Code wegoptimiert wird, sondern dass 
Speicherzugriffe wegoptimiert werden. Eine kritische Zeile in deinem 
Code ist z.B. diese:

1

while(puffer_schreiben==puffer_lesen) {}

puffer_schreiben wird nur einmal am Anfang der Schleife aus dem Speicher 
gelesen, und danach werden nur noch Registerinhalte verglichen. Mit 
"volatile" sagst du dem Compiler, dass sich der Inhalt von 
puffer_schreiben auch zwischendurch ändern kann, und er erzeugt dann 
Code, der den Wert in jedem Schleifendurchlauf neu aus dem Speicher 
liest.