Hallo, aufgrund eines schnellen datenaufkommens von seitens der
UDP-Kommunikation (PC-> Mikrocontroller) auf einem Mikrocontroller, soll
ein Software FIFO in die bestende UART-Kommunikation integriert werden.
Für das Senden von UART Frames gibt es eine Methode mit der ein
Interrupt getriggert wird. In der UART Interruptroutine werden
nacheiander die Daten vom UartBuffer versendet. Danach wird der Trigger
wieder deaktiviert bis wieder die Send Methode ausgeführt wird. Das
Software FIFO kann insgesamt 10 Frames von der Länge 200 Bytes
speichern.
In der Regel sollte es beim UART ein Flag(Bit) geben, welches anzeigt ob
das letzte Byte gesendet wurde. Dieses Flag überprüfst du in der
Schleife des Hauptprogramms. Ist der UART bereit das nächste Byte zu
senden, liest du dieses aus den FIFO und übergibst es dem UART.
Unabhängig davon schreibst du neue zu sendende Bytes in den FIFO.
Vergiss dir nicht zu überlegen, was bei einem Überlauf des FIFOs
passieren muss. Überschreibst du ältere Bytes oder übernimmst du keine
neuen Bytes mehr in den FIFO? Das musst Du je nach den Anforderungen
Deiner Anwendung selbst festlegen.
Vielen Dank für eure Hilfe.
Vorgehensweise:
--> Send Methode werden die ankommenden Daten von UDP in das FIFO
abgelegt
--> In der Hauptschleife wird geprüft ob die UART noch sendet oder
nicht.
Wenn die UART frei ist soll der Sende-Interrupt getriggert werden.
Hier wird dann das erste Element vom FIFO versendet.
Was passiert wenn nun mehrere Elemente im FOF vorhanden sind. Sollen
dann alle Elemente auf einmal versendet werden?
Ich n nun dabei Code von Peter Dannegger zu verstehen und das Prinzip
auf meiner Anwendung zu integrieren.
Folgendes ist mir unklar:
In der while-Schleife vom Hauptprogramm wird mit der Funktion uputchar0
Datenhinzugefügt. Welche Funktion hat dabei die Funktion utx0_ready?
Techniker schrieb:> Welche Funktion hat dabei die Funktion utx0_ready?
uputchar0 wartet, wenn kein Puffer mehr frei ist.
utx0_ready prüft, ob mindestens 1 Byte Puffer frei ist.
> Sollen dann alle Elemente auf einmal versendet werden?
Verwechsele die Begriffe nicht. UART Schnittstellen senden Bytes (oder
Zeichen). Ein Element kann alles mögliche sein, zum Beispiel ein Stück
von einem Videoclip.
Und da sie ein Byte nach dem andere heraus schieben, kann man gar nicht
mehrere Bytes auf einmal senden. Du kannst nicht einmal ein Element am
Stück senden, wenn es aus mehr als einem Byte besteht.
Folgende Funktionen gibt es in meiner Applikation:
- Sendefunktion --> Hier werden die ankommenden Frames in ein FIFO
abgelegt
- AppendFrameToFIFO --> Diese Funktion wird in der Sendefunktion
ausgeführt
- Operate Methode --> Diese Methode wird im Hauptprogramm in der
while-Schleife ausgeführt
- Sende Service Interruptroutine
Hallo Adam, danke für das Beispiel!
In deinem Beispiel wird die send_frame_data permanent ausgeführt.
In meiner Applikation wird je nach Ereignis die Send Methode ausgeführt.
Ja kannst du ja implementieren, wie es dir am besten passt,
aber ich würde sie nicht "send" nennen, da sie nicht sendet.
Der Ablauf ist doch wie folgt:
- operate()
- evtl. create_frame()
- append_frame_to_fifo()
- start_send() / enable_uart()
- read_fifo() / fifo_get_byte()
Eine Fkt. "send" zu nennen und in dieser aber den Frame lediglich in
FIFO schreiben, ist etwas verwirrend.
Man kann sich ja eine Funktion schreiben, die anhand der Indizes die
Anzahl freier Bytes berechnet. Und wenn diese kleiner als ein Frame ist,
wird der Frame verworfen. Damit vermeidet man das Warten, bis das
vorherige Senden beendet ist.
Will man keine Frames verlieren, muß man aber warten, und das macht
uputchar0 schon von sich aus.
Oder man erzeugt mit einem Timer oder Sheduler die Frames nicht
schneller, als sie gesendet werden können.
Techniker schrieb:> Welchen Ablauf müsste ich in der while-Schleife (operate-Methode)> umsetzen?
Das hängt doch davon ab, was du machen möchtest...
Daten einlesen (AD Wandler, andere Schnittstellen), Daten verarbeiten,
Daten in ein Frame verpacken, Frame in FIFO schieben, Senden aktivieren.
Hallo Peter in deiner Implementierung werden die Daten byteweise in das
FIFO geschrieben und wieder gelesen.
Meine Implementierung ist etwas anders. Ich bekomme von der
UDP-Kommunikation Daten in Form eines Frames die in ein FIFO gespeichert
werden. Das Versenden eines FIFO Eintrage ist quasi ein Frame mit einer
bestimmten Anzahl von Bytes. Diese Bytes werden dann in der
Interruptroutine nacheinander von der UART versendet.
Hier mal ein Fifo von 255 Byte ;-)
Put: Aufruf mit [0..255]. Rückgabe -1 wenn voll.
Get: Aufruf mit -1. Rückgabe -1 wenn leer
Put oder Get ist interruptfest, wenn ++ atomar ist.
1
typedefunsignedcharBYTE;/* sieht schlanker aus |**/
