www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Warten per leere Anweisung


Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,
Ich habe mal wieder ein kleines Problemchen:

Ich möchte Veränderungen an den Eingangspins per UART verschicken. Das 
ganze mache ich über einen Ringpuffer, das senden geschieht dann per 
UDR_Empty Interrupt. Da sich auch mal viele Eingangspins auf einmal 
ändern können und keine Informationen untern den Tisch fallen sollen, 
möchte ich, wenn der Ringpuffer voll ist, einfach so lange warten, bis 
dieser wieder leer ist.
Die Ringpuffer-Geschichte funktioniert auch tadellos, allerdings gibt es 
Probleme, wenn der Puffer tatächlihc voll ist.
Die Funktion sieht so aus:
/*String in Ringpuffer schreiben*/
void put_string_to_ringbuffer(struct t_buffer* buffer, uint8_t* p_start)
{
  do
  {
    /*so lange versuchen, bis kein Fehler mehr zurückkommt*/
    while(put_to_ringbuffer(buffer, *p_start) != NO_ERROR)
    {
                      ; //Hab schon alle Schreibweisen, mit und ohne Klammern versucht
    }
  }
  /*Bis zum Endzeichen inklusive wiederholen*/
  while (*(p_start++) != STR_TERMINATOR);

  /*String freigeben*/
  release_last_frame(buffer);
}

Dabei hängt er sich auf. Als Rückgabewert der put_to_ringbuffer gibt es 
nur NO_ERROR oder BUFFER_FULL.

Ich hatte dann mal zum debuggen eine uart-Sendefunktion in die leere 
Anweisung geschrieben. Diese wurde zwar nie ausgeführt, aber dafür 
hängte er sich auch nicht mehr auf???
Ich weiß, das ist kein lauffähiges Beispiel, mein gesamter Code ist nur 
SEHR groß, daher einfach nur die Frage: kann diese leere Anweisung 
Probleme hervorrufen?

Grüße
Phil

Autor: Alexander v. Grafenstein (avogra)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
da wärs jetzt interessant, was in put_to_ringbuffer steht :) Ob der 
leere Block nur aus {} oder aus {;} oder sogar nur aus ; besteht sollte 
eigentlich wurst sein. Ich kann mir nicht vorstellen, dass hier das 
Problem liegt.

Was mir einfällt: Was passiert, falls sich das Programm gerade in 
put_to_ringbuffer befindet, wenn der Interrupt auslöst? Falls der Puffer 
gerade voll ist, ist das ja quasi ständig der Fall.

Gruß, Alex

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Was mir einfällt: Was passiert, falls sich das Programm gerade in
>put_to_ringbuffer befindet, wenn der Interrupt auslöst? Falls der Puffer
>gerade voll ist, ist das ja quasi ständig der Fall.

Das sollte kein Problem sein. Put to Ringbuffer legt einfach einzelne 
Zeichen in den Puffer. Erst wenn das Terminatorzeichen von 
Put_str_to_ringbuffer gesetzt wurde, wird der Lese-Endzeiger für das 
Interrupt weitergeschoben und der gesamte Frame zum Senden freigegeben.
Wenn der Puffer am Ende voll ist, sendet das Interrupt ja trotzdem vom 
Anfang her die Zeichen raus und gibt den Speicher wieder frei. Einziger 
Abschussfall wäre, wenn ein einzelner Frame länge wäre als der Puffer, 
das kann aber nicht passieren.

Hier die Put to Ringbuffer
/*Ein Byte in Ringpuffer schreiben*/
uint8_t put_to_ringbuffer(struct t_buffer* buffer, uint8_t data)
{
  /*Aktuelles Schreibeende an Prüfzeiger übergeben*/
  uint8_t* p_check = buffer->p_next_write;
  /*Prüfzeiger erhöhen*/  
  if(++p_check > (buffer->p_buffer_start + buffer->size)) p_check = buffer->p_buffer_start;

  /*Prüfen, ob das Schreibeende auf dem nächsten Zeichen liegt*/
  /*Schreibeende = Das erste Zeichen daß NICHT mehr geschrieben werden soll*/
  if(p_check == buffer->p_end_write)
  {
    /*Buffer Full zurückgeben*/
    return BUFFER_FULL;
  }

  /*Wenn nächstes Zeichen nicht das Schreibeende ist*/
  else
  {
    /*Schreibezeiger auf nächste Stelle*/
    buffer->p_next_write = p_check;

    /*An diese Stelle schreiben*/
    *(buffer->p_next_write) = data;

    /*NO ERROR Zurückgeben*/
    return NO_ERROR;
  }
}

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Und in welchem Kontext wird put_string_to_ringbuffer aufgerufen? Dir ist 
schon klar, dass wenn dort Interrupts gerade abgeschaltet sind (z.B. in 
einer ISR), dass dann das "Warten per leere Anweisung" bei vollem Puffer 
zur Endlosschleife wird, oder?

Autor: Alexander v. Grafenstein (avogra)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok, ich versuch mal zu rekapitulieren, was der Code macht.
p_check ist ne zwischenvariable, mit der überprüft wird, ob der nächste 
platz im puffer frei zum schreiben ist.
p_next_write ist der nächste platz, an dem daten in den puffer 
geschrieben werden sollen.
p_end_write versteh ich nicht zu 100%. Ist das der Zeiger, dessen Daten 
als nächstes vom UART übertragen werden sollen? Siehe dazu nächster 
Absatz.
Du lässt jetzt p_check auf den nächsten zu beschreibenden Platz zeigen. 
Wenn der noch belegt ist, wird mit BUFFER_FULL abgebrochen. Wenn nicht, 
wird p_next_write auf diesen Platz gebogen und die anstehenden Daten auf 
diesen Platz geschrieben.
Ich würde nochmal ganz genau schaun, was passiert, wenn eine beliebige 
dieser Anweisungen von der Sende-Routine unterbrochen wird. Ich kann mir 
gut vorstellen, dass es hier Probleme geben könnte. Bedenke dabei, dass 
das auch mitten in einer Zeile sein kann! Ganz einfach umgehen kannst du 
das, wenn du die gesamte Routine atomar machst, also während der Routine 
keine Interrupts erlaubst mit cli() am Anfang und sei() am Ende. Sollte 
während dessen ein Interrupt aufgetreten sein, wird der sofort nach 
sei() nachgeholt.
Grundsätzlich würde ich deine Routine ein kleines bisschen umbauen. 
Konkret: Ich finde es sinnvoller, wenn p_next_write nicht auf den 
zuletzt beschriebenen Platz zeigt, sondern auf den nächsten zu 
beschreibenden. Damit sparst du dir die ganze Geschichte mit p_check.
Also:
- ist p_next_write == p_end_write ? -> ja: dann Abbruch mit Buffer_full
   -> nein: dann ist der Platz frei
- Daten an diesen Platz schreiben
- p_next_write erhöhen (mit Umbruch wie bisher für p_check)


 Du schreibst, dass ein Frame erst komplett im Puffer liegen muss, bevor 
er übertragen wird.
Das kann ich nirgends finden. Und dann frag ich mich noch, warum du 
darauf wartest? Wenn Daten im Puffer liegen, dann würde ich die von der 
Sende-Routine auch so schnell wie möglich übertragen. Ob das ein 
kompletter Datensatz ist, wäre mir egal. Falls die Daten gemeinsam 
ankommen müssen, würde ich evtl. ein Magic-Byte für "Start frame" 
reservieren oder alternativ ein "End frame". Alles was danach kommt, 
gehört dann zu diesem Frame, bis das nächste "Start frame" kommt. Evtl. 
könnte man stattdessen auch eine Hardware-Handshake Leitung zum selben 
Zweck missbrauchen.

Dann ist mir noch was aus deinem ersten Post aufgefallen, an dem dein 
Problem liegen könnte:

Du schreibst, dass du UDR_empty zum verschicken benutzt. Was passiert, 
wenn gerade keine Daten zu verschicken sind? Dann wird UDR_empty nicht 
mehr aufgerufen (es wurde ja nichts verschickt) und es werden nie wieder 
Daten verschickt, außer, du überträgst irgendwo nochmal was per Hand -> 
deine Debug-routine? Bist du ganz sicher, dass die nicht aufgerufen 
wurde?

So, ich hoffe, mein Roman hilft dir^^

Gruß, Alex

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
put_string_to_ringbuffer wird aus der Main heraus aufgerufen (es wird 
gecheckt, ob sich Pinzustände geändert haben, wenn ja dann wird ein 
String gebaut und in den Ringpuffer geschoben.) Wird der Frame 
freigegeben, wird das UDRE-ISR aktiviert und es fängt an, den Puffer 
rauszusenden. Dabei wird der Speicher jedes Zeichens nachdem es in den 
UDR geladen wurde wieder freigegeben. Kommt es also beim Versuch, den 
String zu schreiben zu einem Fehler (Buffer full), so wird die Main so 
lange versuchen, dieses Zeichen zu senden, bis es geklappt hat. Das 
UDRE_Intrerrupt läuft ja "nebenher" und schaufelt den Ringpuffer wieder 
leer, somit kommt es natürlich an dieser Stelle zu einem Flaschenhals 
wenn sehr viel gesendet werden soll, aber der UART ist ja aufgrund 
seiner Baudrate sowieso der Flaschenhals, und es interessiert mich 
eigentlich nicht, ob die Pins weiter ausgelesen würden, wenn ich davon 
eh noch nichts erfahre, darum darf der Controller an der Stelle ruhig 
etwas im Stau stehen, das ganze kommt in der Regel sowieso nur nach der 
Initialisierung vor, bis alle Anfangszustände ienmal gelesen sind. 
Danach ändert sich nicht mehr so viel auf einmal.
Was ich halt nicht verstehe, ist daß er sich mit der leeren Anweisung 
aufhängt, mit der Debuganweisung in der Block aber nicht...

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Alexander v. Grafenstein schrieb:
> Ob der
> leere Block nur aus {} oder aus {;} oder sogar nur aus ; besteht sollte
> eigentlich wurst sein. Ich kann mir nicht vorstellen, dass hier das
> Problem liegt.

Nicht 'sollte wurst sein', sondern es ist einfach definitiv egal.


Wie ist NO_ERROR und BUFFER_FULL definiert?

Sind die Pointer, die von der ISR verändert werden als volatile 
deklariert?

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Grundsätzlich würde ich deine Routine ein kleines bisschen umbauen.
>Konkret: Ich finde es sinnvoller, wenn p_next_write nicht auf den
>zuletzt beschriebenen Platz zeigt, sondern auf den nächsten zu
>beschreibenden. Damit sparst du dir die ganze Geschichte mit p_check.
>Also:
>- ist p_next_write == p_end_write ? -> ja: dann Abbruch mit Buffer_full
>   -> nein: dann ist der Platz frei
>- Daten an diesen Platz schreiben
>- p_next_write erhöhen (mit Umbruch wie bisher für p_check)

Das hatte ich am Anfang auch so, da ergeben sich aber einige Probleme, 
da ich z.B. nicht unterscheiden kann, wenn beide Zeiger auf einander 
liegen, ob ich am Anfang eines leeren oder am Ende eines vollen 
Speichers stehe. Habe da in der Peter Fleury Lib ein bisschen abgeguckt 
;)

>Du schreibst, dass du UDR_empty zum verschicken benutzt. Was passiert,
>wenn gerade keine Daten zu verschicken sind? Dann wird UDR_empty nicht
>mehr aufgerufen (es wurde ja nichts verschickt) und es werden nie wieder
>Daten verschickt, außer, du überträgst irgendwo nochmal was per Hand ->
>deine Debug-routine? Bist du ganz sicher, dass die nicht aufgerufen
>wurde?

Das ist nicht ganz richtig: Das interrupt "poppt" nicht auf, sondern ist 
immer gesetzt, wenn der leer IST (nicht leer WIRD). Aktiviere ich das 
Interrupt, so wird es durch den zu diesem Zeitpunkt leeren UDR auch 
gleich ausgelöst. Senden stoppen tue ich per Interrupt disable. Das 
ganze ist auch nicht das Problem, die Sende-Geschichte tut anstandslos, 
sendet durchaus mal ne Stunde nicht und ist dann sofort wieder da wenn 
an den Pins was passiert, da sollte das Problem nicht liegen. Das 
Problem trat wirklich erst auf, wenn der Puffer mal wirklich voll läuft.

>p_end_write versteh ich nicht zu 100%. Ist das der Zeiger, dessen Daten
>als nächstes vom UART übertragen werden sollen? Siehe dazu nächster
>Absatz.

End Write markiert das Ende des Schreibe-Bereiches (Man könnte es auch 
gleichsetzen mit dem Anfang des Lesebereiches, damit noch nicht 
gesendete Zeichen nicht überschrieben werden) Ich habe mich hier für 
bessere Übersicht (empfand ich so) und Flexibilität dazu entschieden, 
Schreibebereich und Lesebereich "separat" zu verwalten. So wandert zb 
der Schreibezeiger beim reinschreiben weiter, das Leseende bleibt aber 
erst einmal stehen, bis der Frame freigegeben wird.

>Du schreibst, dass ein Frame erst komplett im Puffer liegen muss, bevor
>er übertragen wird.
>Das kann ich nirgends finden.

Das steht in
     release_last_frame(buffer);
>Und dann frag ich mich noch, warum du
>darauf wartest? Wenn Daten im Puffer liegen, dann würde ich die von der
>Sende-Routine auch so schnell wie möglich übertragen. Ob das ein
>kompletter Datensatz ist, wäre mir egal.

Das gibt mir die Möglichkeit, einen Frame bei dem ein Fehler aufgetreten 
ist (mach ich z.B. beim Empfangen über den UART, die Funktionen sind für 
beide Richtungen da) zu verwerfen, damit kein ungültiger Quatsch in die 
Auswertung kommt, indem ich dann anstatt das Leseende weiter zu ziehen 
einfach den Schreibezeiger zurück ziehe.
Aber es stimmt, ich könnte beim senden, da dort sowieso keine 
Fehlerbehandlung stattfindet, nach jedem Zeichen die release_last_frame 
aufrufen und jedes Zeichen sofort freigeben. Das macht das ganze asber 
im Zweifel lediglich minimal schneller und sollte doch eigentlich nichts 
mit meinem Problem zu tun haben oder?

Zu guter Letzt
>Ich würde nochmal ganz genau schaun, was passiert, wenn eine beliebige
>dieser Anweisungen von der Sende-Routine unterbrochen wird. Ich kann mir
>gut vorstellen, dass es hier Probleme geben könnte. Bedenke dabei, dass
>das auch mitten in einer Zeile sein kann!

Sollte eigentlich auch kein Problem sein, das interrupt liest ja nur aus 
dem Puffer, und zwar so lange, bis der Lesezeiger das Leseende erreicht 
hat. Bevor das Leseende überhaupt neu geschrieben wird, ist alles andere 
(Zeichen schreiben...) geschehen. Das Leseende ist ein Byte, daher 
eigentlich ja auch interruptfest. Entweder ist das dann bereits 
aktualisiert, oder eben noch nicht. Wenni ich hier jetzt Stuss erzähle 
dann gebt bitte bescheid ;)

>Wie ist NO_ERROR und BUFFER_FULL definiert?
NO_ERROR 0
BUFFER_FULL irgendne Zahl non Zero

>Sind die Pointer, die von der ISR verändert werden als volatile
>deklariert?
Logisch

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Phillip Hommel schrieb:
>>Sind die Pointer, die von der ISR verändert werden als volatile
>>deklariert?
> Logisch

Sehen wollen.
Wie oft schon haben wir in solchen Fällen so was gesehen:
volatile uint8_t *ptr;

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hmm, das is wenn man ne große Klappe hat, danke für den Hinweis ;)
Da könntest mir glaube ich gerne mal auf die Sprünge helfen...

Das is die ISR
/*USART Sende Interrupt*/
ISR(USART_UDRE_vect)
{
  /*Wenn keine Daten zum senden mehr vorhanden sind*/
  if(number_tx_frames == 0)
  {
    /*Senden deaktivieren*/
    end_tx();  
    return;
  }

  /*Zeichen aus Ringpuffer lesen*/
  uint8_t buffer = get_from_ringbuffer(&tx_buffer);

  /*Wenn das Terminatorzeichen gelesen wurde*/
  if(buffer == STR_TERMINATOR)
  {
    /*Frame-End-Zeichen senden*/
    UDR = TX_TERMINATOR;

    /*Framezähler dekrementieren*/
    number_tx_frames--;
  }

  /*Alle anderen Zeichen einfach senden*/
  else 
  {
    UDR = buffer;
  }

  return;
}

Das hier sind meine Puffer
struct  t_buffer{          
  
  uint8_t size;
  uint8_t* p_buffer_start;
  uint8_t* p_next_read;
  uint8_t* p_end_read;
  uint8_t* p_next_write;
  uint8_t* p_end_write;
};

//Empfangs- und Sendepuffer reservieren
uint8_t tx_buffer_data[TX_BUFFERSIZE];
uint8_t rx_buffer_data[RX_BUFFERSIZE];
struct t_buffer tx_buffer = {(TX_BUFFERSIZE - 1), tx_buffer_data, tx_buffer_data, tx_buffer_data, tx_buffer_data, tx_buffer_data};
struct t_buffer rx_buffer = {(RX_BUFFERSIZE - 1), rx_buffer_data,  rx_buffer_data, rx_buffer_data, rx_buffer_data, rx_buffer_data};

Jetzt häng ich grade etwas. Ich übergebe doch sowieso die Adresse, 
speichere also doch alles direkt an der jeweiligen Speicheradresse ab, 
wozu dann volatile?

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Oh man, disregard. ;)
Also nochal richtig, hoffe ich jedenfalls.

Typzuweisung:
struct  t_buffer{          
  
  uint8_t size;
  uint8_t* p_buffer_start;
  uint8_t* p_next_read;
  uint8_t* p_end_read;        //first adress NOT to read
  uint8_t* p_next_write;
  uint8_t* p_end_write;        //first adress NOT to write
};

//Empfangs- und Sendepuffer reservieren
uint8_t tx_buffer_data[TX_BUFFERSIZE];
uint8_t rx_buffer_data[RX_BUFFERSIZE];
//               //Size            //start         //next read     //end read    //next write  //end write
volatile struct t_buffer tx_buffer = {(TX_BUFFERSIZE - 1), tx_buffer_data,  tx_buffer_data, tx_buffer_data, tx_buffer_data, tx_buffer_data};
volatile struct t_buffer rx_buffer = {(RX_BUFFERSIZE - 1), rx_buffer_data,  rx_buffer_data, rx_buffer_data, rx_buffer_data, rx_buffer_data}

und Funktion
/*String in Ringpuffer schreiben*/
void put_string_to_ringbuffer(volatile struct t_buffer* buffer, uint8_t* p_start)
{
  do
  {
    /*so lange versuchen, bis kein Fehler mehr zurückkommt*/
    while(put_to_ringbuffer(buffer, *p_start) != NO_ERROR)
    {

    }
  }
  /*Bis zum Endzeichen inklusive wiederholen*/
  while (*(p_start++) != STR_TERMINATOR);

  /*String freigeben*/
  release_last_frame(buffer);
}
Damit der Check auf wirklich jedes mal ausgeführt wird und nicht zu 
einmal gemacht und dann in nem Register unverändert abgelegt 
wird...Richtig?

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So, jetzt schwimm ich richtig. Was muss denn da nun alles volatile 
deklariert werden? Ich verändere ja sowohl die Pointer, als am Ende auch 
die Zeichen auf die die Pointer zeigen...

Autor: Alexander v. Grafenstein (avogra)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok, hast ja alles, was mir eingefallen ist, stichhaltig widerlegt :-P

Stefan Ernst schrieb:
> Und in welchem Kontext wird put_string_to_ringbuffer aufgerufen? Dir ist
> schon klar, dass wenn dort Interrupts gerade abgeschaltet sind (z.B. in
> einer ISR), dass dann das "Warten per leere Anweisung" bei vollem Puffer
> zur Endlosschleife wird, oder?

Das hast du aber noch nicht ausgeschlossen :-P
Wenn noch Daten im Puffer sind, und es wird ein neuer String 
reingeschrieben, der aber nicht mehr reinpasst, wird dann während dessen 
der alte Frame weiter übertragen? Ich nehm aber mal an, daran hast du 
auch gedacht.

wegen volatile:
Phillip Hommel schrieb:
> void put_string_to_ringbuffer(volatile struct t_buffer* buffer, uint8_t* 
p_start)
hier sollte doch das volatile überflüssig sein. die adresse des buffers 
ändert sich ja nicht plötzlich, besser gesagt nie.

Phillip Hommel schrieb:
> uint8_t buffer = get_from_ringbuffer(&tx_buffer);

bist du dir sicher mit dem "&" ? tx_buffer müsste doch schon ein pointer 
sein. Obwohl, der zeigt ja aufs erste Element oder? Puh!
Bei der Definition von t_buffer würde bei mir wahrscheinlich ein typedef 
davorstehen. Aber bin auch schon ganz schön am schwimmen. Soweit ists 
mit meinen C-Kenntnissen nicht her und ich weiß schon, warum ich lieber 
in Assembler programmier :-P

Aber ehrlich gesagt seh ich genau 1 Stelle, wo du auf 
tx_buffer/rx_buffer als globale Variable zugreifst. Das ist in der ISR

> uint8_t buffer = get_from_ringbuffer(&tx_buffer);

Hier sollte der Compiler ja nichts zum weg-optimieren haben. Ansonsten 
übergibst du die Puffer-Adresse ja immer als Funktionsargument und 
greifst dann auf den übergebenen Puffer zu.

Tja, ein munteres herum-gestocher ist das hier :(

Vllt. kannst du dein Programm einfach mal im Simulator laufen lassen. 
Musst halt nach Programmstart den Puffer per Hand befüllen und die 
entsprechenden Pointer eintragen. Geht das auch in C?

Autor: Läubi .. (laeubi) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Elemente des Structs müssen auch volatile sein, zumindest gab es 
hier mal einen Thread wo das ein Problem war...

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Wenn noch Daten im Puffer sind, und es wird ein neuer String
>reingeschrieben, der aber nicht mehr reinpasst, wird dann während dessen
>der alte Frame weiter übertragen? Ich nehm aber mal an, daran hast du
>auch gedacht

Klar, das ist ja die Idee bei der Sache. Darum soll das reinlegen eines 
neuen (nicht mehr reinpassenden) Strings(bzw des nächsten Zeichens) so 
lange warten, bis per ISR wieder Platz gemacht wurde.

>hier sollte doch das volatile überflüssig sein. die adresse des buffers
>ändert sich ja nicht plötzlich, besser gesagt nie.

Da bin ich mir eben nicht mehr so ganz sicher. Denn der Pointer zeigt ja 
auf immer neue Stellen des Arrays. Und wenn die UDRE ISR ein Zeichen 
gesendet hat, dann ändert sie ja den Pointer auf das nächste Zeichen. 
Allerdings wird ja auch das Zeichen selbst von der UDR geändert 
(zumindest in der Empfangsrichtung, dann vom RXC ISR). Und wie man das 
dann deklariert bin ich mir eben unsicher.

>Die Elemente des Structs müssen auch volatile sein, zumindest gab es
>hier mal einen Thread wo das ein Problem war...

Ich werde es heute wohl nicht mehr probieren können, werde aber bald 
möglichste berichten.
Hab das jetzt mal so gemacht, daß ich in der Strukturdefinition alle 
Pointer Volatile deklariert habe, dann sollten die schnmal nicht mehr 
der Opt. zum Opfer fallen...
/*Typzuweisung*/
struct  t_buffer{          
  
  uint8_t size;
  volatile uint8_t* p_buffer_start;
  volatile uint8_t* volatile p_next_read;
  volatile uint8_t* p_end_read;
  volatile uint8_t* volatile p_next_write;
  volatile uint8_t* p_end_write;
};

/*Empfangs- und Sendepuffer reservieren*/
uint8_t tx_buffer_data[TX_BUFFERSIZE];
uint8_t rx_buffer_data[RX_BUFFERSIZE];

struct t_buffer tx_buffer = {(TX_BUFFERSIZE - 1), tx_buffer_data,  tx_buffer_data, tx_buffer_data, tx_buffer_data, tx_buffer_data};
struct t_buffer rx_buffer = {(RX_BUFFERSIZE - 1), rx_buffer_data,  rx_buffer_data, rx_buffer_data, rx_buffer_data, rx_buffer_data};

Oder müssen die eigentlichen Pufferspeicher an sich auch Volatile sein 
(volatile uint8_t tx_buffer_data[TX_BUFFERSIZE];)?

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hast du das Programm mal ohne Optimierung übersetzt? Damit sollten ja 
Fehler, die von fehlenden volatiles herrühren, erst mal nicht 
zuschlagen. Wenns also ohne Optimierung nicht läuft, ist woanders noch 
was falsch.

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Hast du das Programm mal ohne Optimierung übersetzt? Damit sollten ja
>Fehler, die von fehlenden volatiles herrühren, erst mal nicht
>zuschlagen. Wenns also ohne Optimierung nicht läuft, ist woanders noch
>was falsch.

Daran habe ich noch gar nicht gedacht, ist das soweit zu empfehlen? Hab 
ich noch nie versucht, danke für den Tipp!

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Es ist zu empfehlen, um zu prüfen, ob die volatiles der Fehler sind. Das 
Abschalten der Optimierung ist natürlich nicht als alternative zu 
korrekten volatiles gedacht ;)

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok super, ich werde das alles baldmöglichst mal ausprobieren und 
berichten. Vielen Danke erstmal an alle für Eure Hilfe!

Autor: Phillip Hommel (philharmony)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
SO, habs getestet und: Es funktioniert! Lag tatsächlich am vergessenen 
Volatile. Was bei genauerem Hinsehen ja auch total Sinn macht: Das 
Abbruchkriterium der while-Schleife kann sich ja aus Sicht des Compilers 
nicht ändern (da er ja nichts von Interrupts etc weiß sondern nud 
straight-forward "denkt") während diese ausgeführt wird, darum wird 
diese Abfrage Laufzeitoptimiert, aus
while(funktion(a,b) == 0)  //funktion wird nach jedem Schleifendurchlauf ausgeführt
{
}

wird
int c = funktion(a,b)  //funktion wird einmal vor der Schleife ausgeführt

while(c == 0)  //Leider ändert sich c nie wieder und schon hängt das ganze
{
}
Und schon knallts. Da sich aber die Funktion bei mir durch das interrupt 
eben doch in der Zeit ändern kann, müssen eben die entsprechende 
Variablen als volatile deklariert werden, die dem Compiler diese 
Optimierung dann verbieten.
Soviel der Erklärung mal für alle, die mit dem selben Problem über 
diesen Beitrag stolpern.
Nochmals vielen Dank an alle!

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.