Mikrocontroller: Ringpuffer für UART-Kommunikation

[leo (Gast)]

Hallo,

auf der jetzigen Firmware läuft die UART ohne einen Ringpuffer.
Zwischen der Applikation und der UART Implementierung soll ein 
Ringpuffer
für die Senderichtung eingesetzt werden. Der Ringpuffer soll so 
gestaltet sein, dass dieser insgesamt 10 Frames mit jeweils einer 
maximalen Länge von 300 Bytes aufnehmen kann. Gibt es hier in dem Forum 
Personen die mir eventuell bei der Umsetzung helfen könnten?

[Frank M. (ukw) (Moderator)]

Welcher µC?

[leo (Gast)]

Es handelt sich hierbei um einen XMC4700 Mikrocontroller von Infineon

[Patrick B. (p51d)]

https://github.com/andygock/avr-uart/blob/master/uart.c

vielleicht so was? Musst halt das Prinzip portieren
2. Treffer auf google

[Falk B. (falk)]

https://www.mikrocontroller.net/articles/FIFO#FIFO_als_Bibliothek

[S. R. (svenska)]

Du hast ein Array aus Frames, einen Read-Index und einen Write-Index.

Wer in den Puffer schreiben möchte, schreibt in das Array an die Stelle, 
auf die der Write-Index zeigt und incrementiert diesen dann (zeigt er 
hinter das letzte Element, wird er auf das erste Element gesetzt). 
Lesezugriffe nutzen den Read-Index.

Es gibt eine Mehrdeutigkeit zu beachten, wenn Read- und Write-Index 
gleich sind. Dann ist der Ringpuffer entweder voll oder leer, abhängig 
davon, ob der letzte Zugriff ein Schreib- oder ein Lesezugriff war.

Diese Mehrdeutigkeit kann man vermeiden, indem man das Array ein Element 
größer macht als notwendig und immer einen Frame frei lässt.

So, jetzt bist du dran.

[Hauspapa (Gast)]

Darf ich fragen wo du für dich ein Problem siehst? Auf den ersten Blick 
ist das doch etwas Speicher plus ein kleiner Zustandsautomat.

Woher weis dein Puffer in einem seriellen Datenstrom was ein Frame ist?
Muss er das überhaupt wissen?

Viel Erfolg & halt uns auf dem laufenden
Hauspapa

[leo (Gast)]

Erstmal vielen Dank für die zahlreichen Beiträge.

Folgende Link habe ich bei mir im Code versucht umzusetzen:
https://www.google.de/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwigkJO_s_zVAhVJaxQKHVR5DrwQFggoMAA&url=http%3A%2F%2Fwww.informatik.uni-bremen.de%2Fagbs%2Flehre%2Fws0203%2Fgdi1%2Fhintergrund-info%2Fringbuffer.c&usg=AFQjCNGCzskq31fiHUxFs-iKQv10tn6cnQ

Hier wird für die Speicherreservierung malloc eingesetzt. Auf meinem 
Mikrocontroller funktioniert das leider nicht mit dem malloc.

[leo (Gast)]

Problem:

In der Zeit wo die UART noch beschäftigt ist die Daten zu versenden, 
kann möglicherweise wieder ein neues Frame von der 
Ethernet-Schnittstelle ankommen. Somit muss dann dieses Frames in einen 
Ringpuffer kopiert werden. Wenn die UART wieder bereit ist soll der 
Inhalt vom Ringpuffer über die UART gesendet werden.

[Cyblord -. (cyblord)]

leo schrieb:
> Erstmal vielen Dank für die zahlreichen Beiträge.
>
> Folgende Link habe ich bei mir im Code versucht umzusetzen:
> 
https://www.google.de/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwigkJO_s_zVAhVJaxQKHVR5DrwQFggoMAA&url=http%3A%2F%2Fwww.informatik.uni-bremen.de%2Fagbs%2Flehre%2Fws0203%2Fgdi1%2Fhintergrund-info%2Fringbuffer.c&usg=AFQjCNGCzskq31fiHUxFs-iKQv10tn6cnQ
>
> Hier wird für die Speicherreservierung malloc eingesetzt. Auf meinem
> Mikrocontroller funktioniert das leider nicht mit dem malloc.

1.) Warum nicht? Fehlermeldung oder was?
2.) Dann mach deinen Ringpuffer statisch.
3.) Dir scheint es einfach noch deutlich an Erfahrung zu mangeln. Nimm 
keine sinnlosen Codeschnipsel, lies mal die Leute dir hier geschrieben 
haben und versuche es damit SELBST umzusetzen. Man kommt sich doch 
verarscht vor, wenn man dir hier breit erklärt wie es geht und dann 
einen Codeschnipsel rausziehst und mäkelst "bäh so geht's aber nicht".

[Theor (Gast)]

leo schrieb:
> Problem:
>
> In der Zeit wo die UART noch beschäftigt ist die Daten zu versenden,
> kann möglicherweise wieder ein neues Frame von der
> Ethernet-Schnittstelle ankommen. Somit muss dann dieses Frames in einen
> Ringpuffer kopiert werden. Wenn die UART wieder bereit ist soll der
> Inhalt vom Ringpuffer über die UART gesendet werden.

Warum meinst Du, stellt das ein Problem dar? (Es geht mir mit der Frage 
darum, Dich auf eine strukturierte Denkweise hinzulenken).

Zunächst einmal wäre es gut, sich zumindest eine Übersicht zu 
verschaffen, was die Peripherie eines uC überhaupt kann.

Der UART kann full-duplex arbeiten. Das bedeutet er kann gleichzeitig 
empfangen und senden. Es gibt nur eine Operation, welche im Zusammenhang 
mit dem Datentransfer nicht simultan erledigt werden kann: Nämlich die 
Daten übernehmen bzw. übergeben. (Ob da noch DMA dazwischen ist, spielt 
dabei eine Nebenrolle).

Deine Angaben sind auch widersprüchlich: Im Eröffnungspost schreibst Du 
nur von UART, nun aber kommt auch die Ethernet-Schnittstelle ins Spiel. 
Falls Du über Ethernet empfängst, aber über UART sendest, dann 
verursacht das eher kein Problem, dass mittels eines Ringbuffers zu 
lösen ist. Es besteht allerdings die Möglichkeit, dass die 
Ausführungszeiten schon so knapp sind, dass ein Ringbuffer tatsächlich 
das Projekt rettet, ohne das ein Redesign oder auch nur ein anderer uC 
nötig ist.


Dann wieder malloc: Es ist an sich klar, dass Du Code oft nicht einfach 
nur Eins-Zu-Eins übernehmen kannst. Es hängt ein bisschen davon ab, was 
Deine Vorkenntnisse und Erfahrungen sind und in welchem Kontext Du hier 
Deine Frage stellst: Bist Du Schüler ohne Erfahrungen ist das was 
anderes als wenn Du Student im Praktikum bist oder gar auf PCs schon 
viel Code geschrieben hast, nur auf uCs noch wenig Erfahrung hast.
An sich wird man malloc auf uCs vermeiden und feste Buffer definieren.


Es wären einmal ausführliche Angaben über Situation (sowohl zum Projekt 
als auch zu Deiner Person) nützlich.

Andernfalls solltest Du wenigstens schreiben, wobei Du nun konkret Hilfe 
brauchst. Bitte bedenke, dass hier in der Regel Hilfe zur Selbsthilfe 
geleistet wird.

[Sebastian S. (amateur)]

Hier im Forum, in der Wikipedia und im Netz wirst Du an vielen Stellen 
den vollständigen Code für einen Ringpuffer finden.
Also: "Suchet, so werdet Ihr finden".

[kkuuvvhh (Gast)]

1) Die Adressen in Deinem Ringpuffer bilden einen Kreis.

2) Definiere einen Schreib- und einen Lesezeiger, die jeweils den 
Schreib- und Leseadressen in Deinem Puffer entsprechen.

3) Nach jedem Schreiben in den Puffer wird der Schreibzeiger um 1 (oder 
n) inkrementiert.

4) Nach jedem Lesen aus dem Puffer wird der Lesezeiger um 1 (oder 
n)inkrementiert.

5) Ist vor dem Lesen der Lesezeiger gleich dem Schreibzeiger, dann ist 
der Puffer leer.

6) Ist vor dem Schreiben der Schreibzeiger gleich dem Lesezeiger, dann 
wird der Puffer überlaufen.

[kkuuvvhh (Gast)]

kleiner Fehler, besser:

6) Ist vor dem Schreiben der Schreibzeiger gleich dem Lesezeiger, dann
wird der Puffer überlaufen oder er war leer.

[A. S. (Gast)]

Zu Deinem Code:

1) Wenn Du kein Malloc verwenden willst, dann muss der Aufrufer den 
Speicher mit übergeben. Das ist das sauberste. Am einfachsten, indem du 
ein Makro zur Verfügung stellst, dass bei gegebener Fifo-Größe den 
Gesamt-Platzbedarf in Bytes errechnet. Der Anwender legt dann ein 
Static-Array damit an.

2) Die Operation % (X+1) ist nicht sehr performant. Spielt hier keine 
Rolle, aber um den Charakter des Überlaufs besser zu zeigen wäre besser:

   
    buffer->writeIndex++;
    /* Bei size+1 umlaufen lassen um rIdx==wIdx zu vermeiden, ist OK */
    if(buffer->writeIndex > buffer->size) 
    {
        buffer->writeIndex=0; 
    };

3) Warum du immer nur ein Byte kopierst ist mir auch nicht klar. Eine 
Nachricht sollte doch immer komplett kopiert werden

4) Der Read-Index hat am Ende von Append nichts zu suchen. Im Gegenteil: 
Am Anfang muss geschaut werden, ob genügend Platz drin ist. Darum ist es 
in der Regel einfacher, neben rIdx und wIdx noch einen cnt mitzuführen. 
Man spart damit das "size+1" und kann direkt sagen, ob und wieviel drin 
ist (beim Lesen) oder ob genug Platz zum Schreiben ist. Die Alternative 
((wr-rd+(wr<rd?size:0)) zerfällt nur bei size=2^n und unsigned-typen in 
praktisch nichts.

[chris (Gast)]

hier z.B.

 #define buff_tx_sz (300*10)
 char buff_tx[buff_tx_sz];
 unsigned int   buff_tx_rd =0;
 unsigned int   buff_tx_wr =0;
 unsigned int   buff_tx_rn =0;
 unsigned int   buff_tx_wn =0;

 void put(char c) {
   while(buff_tx_wn!=buff_tx_rn && buff_tx_wr==buff_tx_rd) idle();
   buff_tx[buff_tx_wr++] = c; if(buff_tx_wr>=buff_tx_sz) buff_tx_wr=0;
   buff_tx_wn++;
 }

 char c get() {
   char c;
   while(buff_tx_wn==buff_tx_rn) idle();
   c = buff_tx[buff_tx_rd++]; if(buff_tx_rd>=buff_tx_sz) buff_tx_rd=0;
   buff_tx_rn++;
   return c;
 }

[lui (Gast)]

Mach ich auch immer so. Ich habe zwei FIFOs/Ringspeicher. Einer für Rx 
und einer für Tx. Dann eine getchar() für Rx und eine putchar() für Tx.
Im Interrupt der UART habe ich dann das jeweilige Gegenstück zu getchar 
und putchar.

[c-hater (Gast)]

Achim S. schrieb:

> Die Alternative
> ((wr-rd+(wr<rd?size:0)) zerfällt nur bei size=2^n und unsigned-typen in
> praktisch nichts.

Genau. Da nimmt man halt als Puffergröße statt 3001 eben 4096 Bytes und 
gut isses. Es schadet sicher nix, wenn bis zu drei Frames mehr in den 
Puffer passen als gefordert und es macht den Code erheblich schneller.

Solange man die 1095 Bytes zusätzlichen Puffer nicht dringend irgendwo 
anders benötigt, spricht absolut nix dagegen, das so zu machen.

[Checker (Gast)]

Hallo,

ich kann dir nur empfehlen, nimm die uart lib von Peter Fleury und passe 
sie auf deinen Controller an. In der Lib ist alles enthalten.

[leo (Gast)]

Hallo ich bin dabei die folgende Implementierung auf dieser Seite
https://www.google.de/url?sa=t&rct=j&q=&esrc=s&sou... umzusetzen.
Ich habe nun die Speicherreservierung statisch gestaltet. Allerdings 
sehe ich im Debug Mode, dass die Variablen von der Struktur 
ringbuffer_handler_t nicht initialisiert werden.

[leo (Gast)]

#define NUMBER_OF_FRAMES  10

char Memory[20];

ringbuffer_handler_t * createFIFO(int size)
{
  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

  buffer->readIndex = 0;
  buffer->writeIndex = 0;
  buffer->fifo[400* size];
  buffer->size = size;
}


void main(void)
{
  ringbuffer_handler_t *buffer;
  userdata_t data;
  int ergebnis;

  buffer = createFIFO(NUMBER_OF_FRAMES);

  char TxBuffer[200];
  for(int i = 200; i < 200; i++)
  {
    TxBuffer[i] = 0x13;
  }

  data.length = 100;
  memcpy(data.data, TxBuffer, 100);
  appendFIFO(data, buffer);

}

[leo (Gast)]

Was mache ich da falsch?

[TestX (Gast)]

Kopier den code erstmal richtig...da fehlt einiges...

[leo (Gast)]

Das ist ja quasi nur ein Ausschnitt.

[leo (Gast)]

#define NUMBER_OF_FRAMES  10

//Struktur fuer die Daten
typedef struct
{
  int length;
  char data[BUFFER_SIZE];
} userdata_t;

//Struktur fuer einen Ringbuffer-Handler
//wird benoetigt, um mehrere Listen zu verwalten
typedef struct
{
  //Index zum Lesen
  int readIndex;
  //Index zum Schreiben
  int writeIndex;
  //Platz fuer Speicherelemente, eigentlicher Buffer
  userdata_t *fifo;
  //Groesse des Buffers, d.h. Anzahl der Elemente
  int size;
} ringbuffer_handler_t;


char Memory[6000];

ringbuffer_handler_t * createFIFO(int size)
{
  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

  //Werte des Handler belegen
  //readIndex und WriteIndex zu Anfang 0
  //fuer fifo muss genuegend Speicher reserviert werden,
  //um size Datenelemente aufnehmen zu koennen
  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)
  buffer->readIndex = 0;
  buffer->writeIndex = 0;
  buffer->fifo[512 * size];
  buffer->size = size;
}

void appendFIFO(userdata_t data, ringbuffer_handler_t *buffer)
{
  //Daten in den entsprechenden Platz im Buffer schreiben
  //dafuer ist writeIndex da
  buffer->fifo[buffer->writeIndex] = data;
  //writeIndex wird fuer das naechste Schreiben auf den neuen Wert
  //gesetzt
  //Achtung: wenn der Buffer voll ist, wird wieder vorne hineinge-
  //schrieben (deshalb RINGbuffer), Daten koennen verloren gehen,
  //wenn nicht zwischendurch gelesen wird
  buffer->writeIndex = buffer->writeIndex++ % (buffer->size + 1);
  //an dieser Stelle ist es deshalb sinnvoll, den readIndex auf den
  //letzen wahren Wert zu setzen, wenn NICHT zwischendurch gelesen
  //wurde
  if (buffer->readIndex == buffer->writeIndex)
    buffer->readIndex = buffer->readIndex++ % (buffer->size + 1);
}

int readFIFO(userdata_t *data, ringbuffer_handler_t *buffer)
{
  if (buffer->readIndex != buffer->writeIndex)
  {
    //Daten kopieren
    *data = buffer->fifo[buffer->readIndex];
    //readIndex fuer das naechste Lesen hochsetzen
    buffer->readIndex = buffer->readIndex++ % (buffer->size + 1);
    //Rueckgabewert 1, da gelesen wurde
    return 1;
  }
  else
    //es konnten keine Daten gelesen werden, da keine gueltigen Daten
    //Rueckgabewert also -1
    return -1;
}

void main(void)
{
  ringbuffer_handler_t *buffer;
  userdata_t data;
  int ergebnis;

  buffer = createFIFO(NUMBER_OF_FRAMES);

  char TxBuffer[200];
  for(int i = 200; i < 200; i++)
  {
    TxBuffer[i] = 0x13;
  }

  data.length = 100;
  memcpy(data.data, TxBuffer, 100);
  appendFIFO(data, buffer);

}

[Mike R. (thesealion)]

Abgesehen davon ,das dein Beispiel immer noch nicht komplett ist:

In deiner createFIFO() Funktion vermischt du den eigentlichen Handler 
für den Buffer mit dem Datenspeicher.

Ich kann mit nicht vorstellen, das das ganze im Original mit malloc auch 
so aussah.

[Mike R. (thesealion)]

Ich hab gerade mal nach dem Original gegoogelt (da dein Link oben nicht 
funktioniert) und hier sieht es so aus:

//eine Funktion, um einen Ringbuffer anzulegen
//Parameter size: Groesse des Buffers (Anzahl der Elemente)
//Rückgabewert: Zeiger auf Ringbuffer-Handler
ringbuffer_handler_t *createFIFO(int size)
{
    //Zeiger auf Ringbuffer-Handler deklarieren und genuegend Speicher
    //reservieren
    ringbuffer_handler_t *buffer = 
  (ringbuffer_handler_t *)malloc(sizeof(ringbuffer_handler_t));
    
    //Werte des Handler belegen
    //readIndex und WriteIndex zu Anfang 0
    //fuer fifo muss genuegend Speicher reserviert werden, 
    //um size Datenelemente aufnehmen zu koennen
    //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)
    buffer->readIndex=0;
    buffer->writeIndex=0;
    buffer->fifo = (userdata_t *)malloc(sizeof(userdata_t) * (size + 1));
    buffer->size = size;

    //Zeiger auf Ringbuffer-Handler zurueckgeben
    return buffer;
}

Schau dir noch einmal an, welche Menge speicher für welchen Zweck mit 
malloc reserviert wird und versuche das entsprechend mit statischen 
Variablen nachzubauen.

[leo (Gast)]

Ich habe nochmals nachgeschaut ich sehe keine Vermischung

[leo (Gast)]

Für den kompletten Speicher habe ich 6000 Bytes vorgesehen. Deshalb das 
globale char Array Memory. Das FIFO hat eine maximale Größe von 400 * 10 
Bytes.

400 --> Framegröße von 400 Bytes
size --> Frame Anzahl = 10

char Memory[6000];

ringbuffer_handler_t * createFIFO(int size)
{
  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

  //Werte des Handler belegen
  //readIndex und WriteIndex zu Anfang 0
  //fuer fifo muss genuegend Speicher reserviert werden,
  //um size Datenelemente aufnehmen zu koennen
  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)
  buffer->readIndex = 0;
  buffer->writeIndex = 0;
  buffer->fifo[400* size];
  buffer->size = size;
}

[leo (Gast)]

In der Funktion createFIFO habe ich ein "return buffer" vergessen.

[Frank M. (ukw) (Moderator)]

leo schrieb:
> buffer->fifo[400* size];

statement has no effect.

[leo (Gast)]

char Memory[6000];
char Fifo[5120];

ringbuffer_handler_t * createFIFO(int size)
{
  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

  //Werte des Handler belegen
  //readIndex und WriteIndex zu Anfang 0
  //fuer fifo muss genuegend Speicher reserviert werden,
  //um size Datenelemente aufnehmen zu koennen
  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)
  buffer->readIndex = 0;
  buffer->writeIndex = 0;
  buffer->fifo = (userdata_t *)&Fifo;
  buffer->size = size;

  return buffer;
}

Sobald ich die Methode appendFIFO ausführe stürzt der Controller ab.

[Mike R. (thesealion)]

Dann solltest du dir noch einmal ansehen, was du hier machst

 buffer->fifo = (userdata_t *)&Fifo;

und nicht nur raten. (Es hilft auch die Warnungen und Errors des 
Compilers zu lesen und nicht einfach alles passend zu casten).

[leo (Gast)]

Der Compiler zeigt bei mir keine Warnung/Fehler an.

Es wird hier der Speicher Fifo auf die Struktur userdata_t gecastet.

[Mike R. (thesealion)]

Dann legt doch Fifo gleich als

userdata_t Fifo[10]; //wenn du 10 Elemente haben möchtest

an und schau, was der compiler dazu sagt (dann bitte ohne cast).

[leo (Gast)]

Die Anzahl der Fifo Elemente wird nun in der Struktur fest angelegt.
Dies bedeutet, dass die Zeile in der Funktion createFIFO wegfallen kann.

buffer->fifo = (userdata_t *)&Fifo;

typedef struct
{
  //Index zum Lesen
  int readIndex;
  //Index zum Schreiben
  int writeIndex;
  //Platz fuer Speicherelemente, eigentlicher Buffer
  userdata_t fifo[10];
  //Groesse des Buffers, d.h. Anzahl der Elemente
  int size;
} ringbuffer_handler_t;

[leo (Gast)]

Der Controller stürtzt dann ab wenn diese Zeile ausgeführt wird:

buffer->fifo[buffer->writeIndex] = data;

[leo (Gast)]

Das fifo Element habe ich doch mit einer festen Größe angegeben und 
trotzdem funktioniert das hinzufügen von Elementen nicht.

[Mike R. (thesealion)]

Natürlich funktioniert das nicht, weil dein *buffer nicht dort hin 
zeigt, wo du denkst.

http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/012_c_zeiger_007.htm

Vorher war der FiFo Pointer ebenfalls nicht korrekt aber das hast du ja 
scheinbar korrigiert, auch wenn du immer noch nicht weißt wie ;-)

[leo (Gast)]

Stehe voll auf dem Schlauch.

[leo (Gast)]

Was passiert mit dieser Zeile buffer->fifo ?

ringbuffer_handler_t * createFIFO(int size)
{
  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

  //Werte des Handler belegen
  //readIndex und WriteIndex zu Anfang 0
  //fuer fifo muss genuegend Speicher reserviert werden,
  //um size Datenelemente aufnehmen zu koennen
  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)
  buffer->readIndex = 0;
  buffer->writeIndex = 0;
        buffer->fifo = ????????????????????????
  buffer->size = size;

  return buffer;
}

[J. F. (Firma: Père Lachaise) (rect)]

Wieso wirfst du nicht mal einen Debugger an und überprüfst deine Zeiger 
zur Laufzeit ob diese auch wirklich dahin zeigen wo du denkst?

[Mike R. (thesealion)]

Lies dir einfach den Link von mir durch. Insbesondere, wie man einen 
Pointer auf ein Array verwendet (was du in der Funktion createFIFO() 
Code 2 mal versuchst)

[leo (Gast)]

Ok die Zeiger sind falsch.

Die Adresse von buffer in der create FIFO Funktion ist nicht gleich mit 
der Adresse von buffer in der appendFIFO Funktion. Mir fällt keine 
Lösung ein.

[Mike R. (thesealion)]

Ich zitiert mal aus meinem Link:

[Zitat]
Durch die Anweisung

ptr = element;

wird dem Zeiger ptr die Adresse des Arrays element übergeben. Dies 
funktioniert ohne den Adressoperator, da laut ANSI-C-Standard der 
Array-Name immer als Zeiger auf das erste Array-Element angesehen wird. 
Hier sind der Beweis und das Beispiel dazu:
[/Zitat]

Leider kann dir dein Compiler für deine Fehler nicht auf die Finger 
klopfen, da du ihm durch den cast sagst: "das ist schon so richtig, ich 
weiß was ich tue"

[leo (Gast)]

Ok dann müsste die Codezeile so aussehen (ohne Adressoperator):

ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;

[leo (Gast)]

Nochmals vielen Dank für eure Hilfe.

[leo (Gast)]

Ich bekomme das Problem nicht gelöst.

[AndererGast (Gast)]

wie könntest Du das gelernte jetzt auf die Zeile

leo schrieb:
> buffer->fifo = (userdata_t *)&Fifo;

anwenden?

[leo (Gast)]

Ich komme nicht drauf! Sorry!

[Falk B. (falk)]

@ leo (Gast)

>Ich bekomme das Problem nicht gelöst.

Was nicht verwunderlich ist, wenn man diese ganzen hektischen Unsinn 
hier sieht. Zum Programmieren braucht es Ruhe und Zeit.

[leo (Gast)]

Ich drehe noch durch grrrrrrrrrrrrrrrr

[leo (Gast)]

Die ganze Zeiger und Adresse usw da kommt man durcheinander. Da versteht 
man dann nix mehr

[Vincent H. (vinci)]

Wenn du mit Pointern und deren Arithmetik noch nicht so vertraut bist, 
dann benutz doch einfach einen ganz klassischen Zähler zum Signalisieren 
der Lese- und Schreibposition...

[leo (Gast)]

Könnt ihr mir da nicht noch eine weitere Hilfestellung geben?

[Falk B. (falk)]

@Vincent Hamp (vinci)

>Wenn du mit Pointern und deren Arithmetik noch nicht so vertraut bist,
>dann benutz doch einfach einen ganz klassischen Zähler zum Signalisieren
>der Lese- und Schreibposition...

Man könnte ja auch fertigen, getesteten Quelltext nutzen, der schon 
angeboten wurde. Muss man aber nicht . .  .

[leo (Gast)]

Bin hier quasi alleine.

[leo (Gast)]

Im Netz habe ich bereits schon recherchiert. Diese Lösung würde zu 
meinem Problem passen. Ich benötige einen Ringpuffer der Nachrichten in 
variabler Länge Speichert und wieder löscht.

[leo (Gast)]

Werde nun aufgeben. Vielen Dank für eure Unterstützung!

[Der Andere (Gast)]

leo schrieb:
> Die ganze Zeiger und Adresse usw da kommt man durcheinander. Da versteht
> man dann nix mehr

Sorry aber wenn man sein Handwerkszeug nicht beherrscht dann kann man 
auch kein Gesellenstück bauen.

Dann bleibt nur

Falk B. schrieb:
> Man könnte ja auch fertigen, getesteten Quelltext nutzen, der schon
> angeboten wurde. Muss man aber nicht . .  .

Aber man muss dann zumindest soviel vom Programmieren verstehen daß man 
den Code versteht und anpassen kann falls nötig.

Programmieren ist halt nicht wie backen mit Dr. Oetger. Fertigmischung, 
Milch, rühren, Backofen, lecker (vieleicht).
Das muss man halt LERNEN.

leo schrieb:
> Bin hier quasi alleine.

Wie soll man das verstehen? Alleine beim Hausaufgaben machen oder 
alleine in einer Firma beim Entwickeln einwes Programms für das Kunden 
dann Geld zahlen sollen?

[Falk B. (falk)]

Was für ein Troll!

[X4U (Gast)]

leo schrieb:
> Könnt ihr mir da nicht noch eine weitere Hilfestellung geben?

kann ich leider nicht da selbst C lernender. Kann dir aber sagen was ich 
gemacht habe.

Mir ist dieser ganze Ringbufferkram mit seine Nebenwirkungen und Risiken 
zu hoch. Das ist zwar alles jetzt wunderbar kompakt aber eben gewollt 
hochkomplex.

Deshalb habe ich den "Ringbuffer" durchgeschnitten und zwei Queues draus 
gemacht.

// globals in interrupt
unsigned char LeftBuffer[85] ;     // Left/Right Names for easy distinguishing)
unsigned char RightBuffer[85] ;

Darauf dann zwei Zeiger
volatile unsigned char *pDataBuffer = &LeftBuffer;
volatile unsigned char *pRcvBuffer = &RightBuffer;

Wenn die queue voll ist schalte ich das ganze einfach um

 
pRcvBuffer = &RightBuffer;
pDataBuffer = &LeftBuffer;

Das ist jetzt nicht so ausgefuchst wie ein Ringbuffer und braucht auch 
mehr Speicher. Dafür blicke ich da durch kann mir die Daten im Debugger 
anschauen und die Bearbeitung ist auch wesentlich schneller da ich nur 
die Prüfung auf Message Ende (wird eh gebraucht) und overflow habe.

[X4U (Gast)]

X4U schrieb:
> Wenn die queue voll ist schalte ich das ganze einfach um
>
> pRcvBuffer = &RightBuffer;
> pDataBuffer = &LeftBuffer;

Sorry da fehlt noch Daten links -> rechts :

pRcvBuffer = &LeftBuffer;
pDataBuffer = &RightBuffer;

[Jonas B. (jibi)]

>Deshalb habe ich den "Ringbuffer" durchgeschnitten und zwei Queues draus
>gemacht.

https://de.wikipedia.org/wiki/Doppelpufferung

Gruß J

[leo (Gast)]

Hab nun den ganzen Code in Visual Studio getestet. Siehe da es 
funktioniert (ohne malloc usw.)!

Die createFIFO Funktion sieht nun so aus:

ringbuffer_handler_t * createFIFO(int size)
{
  char Memory[6000];
  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;

  buffer->readIndex = 0;
  buffer->writeIndex = 0;
  buffer->size = size;

  return buffer;
}

Warum tut dann das ganze nicht auf dem Mikrocontroller ?

[Frank M. (ukw) (Moderator)]

leo schrieb:

> ringbuffer_handler_t * createFIFO(int size)
> {
>   char Memory[6000];
>   ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;
> 
>   buffer->readIndex = 0;
>   buffer->writeIndex = 0;
>   buffer->size = size;
> 
>   return buffer;
> }

>
> Warum tut dann das ganze nicht auf dem Mikrocontroller ?

Weil Du das Array namens "Memory" als Auto-Variable definiert hast, 
welche bei der letzten Geschweiften-Klammer-Zu vernichtet wird. Das 
heißt, der Speicher wird wieder freigegeben und kann für andere Aufgaben 
genutzt werden. Der µC nutzt ihn für anderes und stürzt ab, Dein 
PC-Programm zufälligerweise nicht - vermutlich, weil Du nur den einen 
kleinen Teil des µC-Programms auf den PC portiert hast.

Dir fehlt gundlegendes Wissen in C, dass Du Dir dringend aneignen 
solltest. Sonst würdest Du die Speicherklasse "static" kennen und solch 
einen Anfängerfehler vermeiden.

Schreibe also

static char Memory[6000];

statt

char Memory[6000];

und teste erneut.

Das erlöst Dich aber nicht von der dringlichen Aufgabe, erst einmal C 
grundlegend zu lernen als solch eine eher fortgeschrittene 
Programmierübung zu lösen.

[Eric B. (beric)]

leo schrieb:
> Die createFIFO Funktion sieht nun so aus:
>

> ringbuffer_handler_t * createFIFO(int size)
> {
>   char Memory[6000];
>   ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;
>

Das wird spassig sobald du mehr als 1 FIFO anlegen willst...
(auch wenn Memory static ist).

[leo (Gast)]

Guten Morgen Frank M.,

trotz Änderung funktioniert der FIFO nicht auf dem Mikrocontroller.

[leo (Gast)]

Korrektur:

#define BUFFER_SIZE      512
#define NUMBER_OF_FRAMES  10

//Struktur fuer die Daten
typedef struct
{
  int length;
  char data[BUFFER_SIZE];
} userdata_t;

//Struktur fuer einen Ringbuffer-Handler
//wird benoetigt, um mehrere Listen zu verwalten
typedef struct
{
  //Index zum Lesen
  int readIndex;
  //Index zum Schreiben
  int writeIndex;
  //Platz fuer Speicherelemente, eigentlicher Buffer
  userdata_t fifo[NUMBER_OF_FRAMES];
  //Groesse des Buffers, d.h. Anzahl der Elemente
  int size;
} ringbuffer_handler_t;


/*-------------------------------------------------------------------------*/

//eine Funktion, um einen Ringbuffer anzulegen
//Parameter size: Groesse des Buffers (Anzahl der Elemente)
//Rückgabewert: Zeiger auf Ringbuffer-Handler
ringbuffer_handler_t * createFIFO(int size)
{
  static char Memory[6000];
  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;

  //Werte des Handler belegen
  //readIndex und WriteIndex zu Anfang 0
  //fuer fifo muss genuegend Speicher reserviert werden,
  //um size Datenelemente aufnehmen zu koennen
  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)
  buffer->readIndex = 0;
  buffer->writeIndex = 0;
  buffer->size = size;

  return buffer;
}

/*-------------------------------------------------------------------------*/

//eine Funktion, um Elemente anzuhaengen, d.h. in den Buffer zu schreiben
//Parameter data: Daten, die in den Buffer geschrieben werden sollen
//Parameter *buffer: Zeiger auf Ringbuffer-Handler
//kein Rueckgabewert
void appendFIFO(userdata_t data, ringbuffer_handler_t *buffer)
{
  //Daten in den entsprechenden Platz im Buffer schreiben
  //dafuer ist writeIndex da
  buffer->fifo[buffer->writeIndex] = data;
  //writeIndex wird fuer das naechste Schreiben auf den neuen Wert
  //gesetzt
  //Achtung: wenn der Buffer voll ist, wird wieder vorne hineinge-
  //schrieben (deshalb RINGbuffer), Daten koennen verloren gehen,
  //wenn nicht zwischendurch gelesen wird
  buffer->writeIndex = buffer->writeIndex++ % (buffer->size + 1);
  //an dieser Stelle ist es deshalb sinnvoll, den readIndex auf den
  //letzen wahren Wert zu setzen, wenn NICHT zwischendurch gelesen
  //wurde
  if (buffer->readIndex == buffer->writeIndex)
    buffer->readIndex = buffer->readIndex++ % (buffer->size + 1);
}

//eine Funktion, um Elemente aus dem Buffer zu lesen
//Parameter *data: Zeiger auf ein Datenelement, das die gelesenen Daten
//aufnehmen soll
//Parameter *buffer: Zeiger auf Ringbuffer-Handler
//Rueckgabewert -1, wenn nicht gelesen werden konnte
//Rueckgabewert 1, wenn gelesen werden konnte
int readFIFO(userdata_t *data, ringbuffer_handler_t *buffer)
{
  //der writeIndex zeigt immer auf das naechste zu beschreibende Element,
  //d.h. dieses Element ist noch nicht beschrieben worden und enthaelt
  //deshalb keine gueltigen Daten
  //wenn readIndex also gleich writeIndex, darf nicht gelesen werden
  if (buffer->readIndex != buffer->writeIndex)
  {
    //Daten kopieren
    *data = buffer->fifo[buffer->readIndex];
    //readIndex fuer das naechste Lesen hochsetzen
    buffer->readIndex = buffer->readIndex++ % (buffer->size + 1);
    //Rueckgabewert 1, da gelesen wurde
    return 1;
  }
  else
    //es konnten keine Daten gelesen werden, da keine gueltigen Daten
    //Rueckgabewert also -1
    return -1;
}

void main (void)
{
        ringbuffer_handler_t *local_buffer;
  userdata_t write_data;
  userdata_t read_data;
  int ergebnis;

  local_buffer = createFIFO(NUMBER_OF_FRAMES);

  char DummyData[500];
  memset(DummyData, 0x33, 500);

  write_data.length = 101;
  memcpy(write_data.data, DummyData, 101);
  appendFIFO(write_data, local_buffer);

  readFIFO(&read_data, local_buffer);

[/c]

[leo (Gast)]

Ich sehe in dem Code keinen Fehler. Wie gesagt auf dem PC mit Visual 
Studio funktioniert der Code prima.

[Felix F. (wiesel8)]

Deine read/write Index Berechnung ist falsch, es kann also schon mal gar 
nichts funktionieren! (FIFO ist immer "leer")

Und wieso castest du einen Pointer vom Typ userdata auf eine Variable?? 
Erzeuge doch gleich eine lokale Variable vom Typ userdata im Modul. Dann 
sparst du dir auch gleich die ganze Pointerschubserei in den Argumenten. 
Mehr als 1 FIFO brauchst du ja nicht.

mfg

[leo (Gast)]

Ok. Und warum funktioniert der Code in Visual Studio?

[leo (Gast)]

In der createFIFO Funktion wird size nicht auf 0 gesetzt. Somit kackt 
der Controller in der appendFIFO Funktion ab.

[leo (Gast)]

Des Weiteren habe ich der Funktion createFIFO einen flaschen Wert 
übergeben. Ich brauche ja nutr ein FIFO somit ist der Wert 1.

[leo (Gast)]

Also müsste buffer->size auf 1 gesetzt werden. Wird aber nicht gemacht.
Warum????

[batman (Gast)]

Such dir ein anderes Hobby.

[Frank M. (ukw) (Moderator)]

leo schrieb:
> Korrektur:

Ich habe diesen Code mal durch den gcc unter Linux geschickt. Heraus 
kommen folgende Warnungen:

fifo.c: In function ‘appendFIFO’:
fifo.c:64:22: warning: operation on ‘buffer->writeIndex’ may be undefined [-Wsequence-point]
fifo.c:69:23: warning: operation on ‘buffer->readIndex’ may be undefined [-Wsequence-point]
fifo.c: In function ‘readFIFO’:
fifo.c:89:23: warning: operation on ‘buffer->readIndex’ may be undefined [-Wsequence-point]
fifo.c: In function ‘main’:
fifo.c:109:3: warning: implicit declaration of function ‘memset’ [-Wimplicit-function-declaration]
fifo.c:109:3: warning: incompatible implicit declaration of built-in function ‘memset’ [enabled by default]
fifo.c:112:3: warning: implicit declaration of function ‘memcpy’ [-Wimplicit-function-declaration]
fifo.c:112:3: warning: incompatible implicit declaration of built-in function ‘memcpy’ [enabled by default]
fifo.c:104:7: warning: unused variable ‘ergebnis’ [-Wunused-variable]

Woher hast Du diesen Code eigentlich her?!? Die obigen Warnungen sind 
durchaus ernstzunehmen (die mit den Sequence-Points).

Beispiel Zeile 64:

 buffer->writeIndex = buffer->writeIndex++ % (buffer->size + 1);

buffer->writeIndex wird hier an 2 Stellen manipuliert, nämlich einmal 
links vom Gleichheitszeichen und einmal durch den Postinkrement rechts. 
Welche der beiden Operationen gewinnt, ist undefiniert und kann auf 
jedem System anders sein. Dasselbe gilt für alle anderen 
Sequence-Point-Warnings.

Die memcpy-Warnung stammt (hoffentlich) daher, dass Du hier lediglich 
bei Posten des Codes vergessen hast, das dafür notwendige Include dem 
Code voranzustellen, das Include aber in Deinem Source doch drin ist.

Fazit:
Den Code, den Du hier irgendwo geklaut hast, taugt nichts. Schreibe Dein 
eigenes FIFO-Modul. Wenn Du das nicht hinbekommst, empfehle ich Dir, 
erstmal C systematisch von der Pike auf zu lernen und Dich dann (nach 
ein paar Monaten) nochmal diesem Problem zu widmen.