Mikrocontroller: Ringpuffer für UART-Kommunikation

Es handelt sich hierbei um einen XMC4700 Mikrocontroller von Infineon

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

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.

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.

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.

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.

kleiner Fehler, besser:

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

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:

1

2

    buffer->writeIndex++;

3

    /* Bei size+1 umlaufen lassen um rIdx==wIdx zu vermeiden, ist OK */

4

    if(buffer->writeIndex > buffer->size) 

5

    {

6

        buffer->writeIndex=0; 

7

    };

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.

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;
 }

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.

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.

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.

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.

Was mache ich da falsch?

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

Das ist ja quasi nur ein Ausschnitt.

Ich habe nochmals nachgeschaut ich sehe keine Vermischung

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

1

char Memory[6000];

2

3

ringbuffer_handler_t * createFIFO(int size)

4

{

5

  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

6

7

  //Werte des Handler belegen

8

  //readIndex und WriteIndex zu Anfang 0

9

  //fuer fifo muss genuegend Speicher reserviert werden,

10

  //um size Datenelemente aufnehmen zu koennen

11

  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)

12

  buffer->readIndex = 0;

13

  buffer->writeIndex = 0;

14

  buffer->fifo[400* size];

15

  buffer->size = size;

16

}

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

1

char Memory[6000];

2

char Fifo[5120];

3

4

ringbuffer_handler_t * createFIFO(int size)

5

{

6

  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

7

8

  //Werte des Handler belegen

9

  //readIndex und WriteIndex zu Anfang 0

10

  //fuer fifo muss genuegend Speicher reserviert werden,

11

  //um size Datenelemente aufnehmen zu koennen

12

  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)

13

  buffer->readIndex = 0;

14

  buffer->writeIndex = 0;

15

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

16

  buffer->size = size;

17

18

  return buffer;

19

}

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

Der Compiler zeigt bei mir keine Warnung/Fehler an.

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

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

1

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

1

typedef struct

2

{

3

  //Index zum Lesen

4

  int readIndex;

5

  //Index zum Schreiben

6

  int writeIndex;

7

  //Platz fuer Speicherelemente, eigentlicher Buffer

8

  userdata_t fifo[10];

9

  //Groesse des Buffers, d.h. Anzahl der Elemente

10

  int size;

11

} ringbuffer_handler_t;

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

1

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

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

Stehe voll auf dem Schlauch.

Was passiert mit dieser Zeile buffer->fifo ?

1

ringbuffer_handler_t * createFIFO(int size)

2

{

3

  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)&Memory;

4

5

  //Werte des Handler belegen

6

  //readIndex und WriteIndex zu Anfang 0

7

  //fuer fifo muss genuegend Speicher reserviert werden,

8

  //um size Datenelemente aufnehmen zu koennen

9

  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)

10

  buffer->readIndex = 0;

11

  buffer->writeIndex = 0;

12

        buffer->fifo = ????????????????????????

13

  buffer->size = size;

14

15

  return buffer;

16

}

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.

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

1

ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;

Nochmals vielen Dank für eure Hilfe.

Ich bekomme das Problem nicht gelöst.

wie könntest Du das gelernte jetzt auf die Zeile

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

anwenden?

Ich komme nicht drauf! Sorry!

Ich drehe noch durch grrrrrrrrrrrrrrrr

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

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

Bin hier quasi alleine.

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.

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

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?

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.

1

// globals in interrupt

2

unsigned char LeftBuffer[85] ;     // Left/Right Names for easy distinguishing)

3

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

1

2

pRcvBuffer = &RightBuffer;

3

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 schrieb:
> Wenn die queue voll ist schalte ich das ganze einfach um
>
> pRcvBuffer = &RightBuffer;
> pDataBuffer = &LeftBuffer;

Sorry da fehlt noch Daten links -> rechts :

1

pRcvBuffer = &LeftBuffer;

2

pDataBuffer = &RightBuffer;

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

Die createFIFO Funktion sieht nun so aus:

1

ringbuffer_handler_t * createFIFO(int size)

2

{

3

  char Memory[6000];

4

  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;

5

6

  buffer->readIndex = 0;

7

  buffer->writeIndex = 0;

8

  buffer->size = size;

9

10

  return buffer;

11

}

Warum tut dann das ganze nicht auf dem Mikrocontroller ?

Guten Morgen Frank M.,

trotz Änderung funktioniert der FIFO nicht auf dem Mikrocontroller.

Korrektur:

1

#define BUFFER_SIZE      512

2

#define NUMBER_OF_FRAMES  10

3

4

//Struktur fuer die Daten

5

typedef struct

6

{

7

  int length;

8

  char data[BUFFER_SIZE];

9

} userdata_t;

10

11

//Struktur fuer einen Ringbuffer-Handler

12

//wird benoetigt, um mehrere Listen zu verwalten

13

typedef struct

14

{

15

  //Index zum Lesen

16

  int readIndex;

17

  //Index zum Schreiben

18

  int writeIndex;

19

  //Platz fuer Speicherelemente, eigentlicher Buffer

20

  userdata_t fifo[NUMBER_OF_FRAMES];

21

  //Groesse des Buffers, d.h. Anzahl der Elemente

22

  int size;

23

} ringbuffer_handler_t;

24

25

26

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

27

28

//eine Funktion, um einen Ringbuffer anzulegen

29

//Parameter size: Groesse des Buffers (Anzahl der Elemente)

30

//Rückgabewert: Zeiger auf Ringbuffer-Handler

31

ringbuffer_handler_t * createFIFO(int size)

32

{

33

  static char Memory[6000];

34

  ringbuffer_handler_t *buffer = (ringbuffer_handler_t *)Memory;

35

36

  //Werte des Handler belegen

37

  //readIndex und WriteIndex zu Anfang 0

38

  //fuer fifo muss genuegend Speicher reserviert werden,

39

  //um size Datenelemente aufnehmen zu koennen

40

  //size gibt Anzahl der Elemente im Ringbuffer an (aus Parameter)

41

  buffer->readIndex = 0;

42

  buffer->writeIndex = 0;

43

  buffer->size = size;

44

45

  return buffer;

46

}

47

48

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

49

50

//eine Funktion, um Elemente anzuhaengen, d.h. in den Buffer zu schreiben

51

//Parameter data: Daten, die in den Buffer geschrieben werden sollen

52

//Parameter *buffer: Zeiger auf Ringbuffer-Handler

53

//kein Rueckgabewert

54

void appendFIFO(userdata_t data, ringbuffer_handler_t *buffer)

55

{

56

  //Daten in den entsprechenden Platz im Buffer schreiben

57

  //dafuer ist writeIndex da

58

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

59

  //writeIndex wird fuer das naechste Schreiben auf den neuen Wert

60

  //gesetzt

61

  //Achtung: wenn der Buffer voll ist, wird wieder vorne hineinge-

62

  //schrieben (deshalb RINGbuffer), Daten koennen verloren gehen,

63

  //wenn nicht zwischendurch gelesen wird

64

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

65

  //an dieser Stelle ist es deshalb sinnvoll, den readIndex auf den

66

  //letzen wahren Wert zu setzen, wenn NICHT zwischendurch gelesen

67

  //wurde

68

  if (buffer->readIndex == buffer->writeIndex)

69

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

70

}

71

72

//eine Funktion, um Elemente aus dem Buffer zu lesen

73

//Parameter *data: Zeiger auf ein Datenelement, das die gelesenen Daten

74

//aufnehmen soll

75

//Parameter *buffer: Zeiger auf Ringbuffer-Handler

76

//Rueckgabewert -1, wenn nicht gelesen werden konnte

77

//Rueckgabewert 1, wenn gelesen werden konnte

78

int readFIFO(userdata_t *data, ringbuffer_handler_t *buffer)

79

{

80

  //der writeIndex zeigt immer auf das naechste zu beschreibende Element,

81

  //d.h. dieses Element ist noch nicht beschrieben worden und enthaelt

82

  //deshalb keine gueltigen Daten

83

  //wenn readIndex also gleich writeIndex, darf nicht gelesen werden

84

  if (buffer->readIndex != buffer->writeIndex)

85

  {

86

    //Daten kopieren

87

    *data = buffer->fifo[buffer->readIndex];

88

    //readIndex fuer das naechste Lesen hochsetzen

89

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

90

    //Rueckgabewert 1, da gelesen wurde

91

    return 1;

92

  }

93

  else

94

    //es konnten keine Daten gelesen werden, da keine gueltigen Daten

95

    //Rueckgabewert also -1

96

    return -1;

97

}

98

99

void main (void)

100

{

101

        ringbuffer_handler_t *local_buffer;

102

  userdata_t write_data;

103

  userdata_t read_data;

104

  int ergebnis;

105

106

  local_buffer = createFIFO(NUMBER_OF_FRAMES);

107

108

  char DummyData[500];

109

  memset(DummyData, 0x33, 500);

110

111

  write_data.length = 101;

112

  memcpy(write_data.data, DummyData, 101);

113

  appendFIFO(write_data, local_buffer);

114

115

  readFIFO(&read_data, local_buffer);

[/c]

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

Ok. Und warum funktioniert der Code in Visual Studio?

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

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

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

Such dir ein anderes Hobby.