Hallo Leute, ich versuche gerade einen Fifo- Buffer für mein Uart hin zubekommen wo immer ein ganzer string gespeichert werden soll. Das Speichern des Befehls funktioniert schon sehr gut nur das abfragen mittels Pointer habe ich noch nicht so ganz im Griff. Dabei habe ich mir als Beispiel den 2^n-Ringbuffer aus diesem Artikel genommen: http://www.mikrocontroller.net/articles/FIFO Volgendes habe ich gemacht: Struktur für den Fifo-Buffer: #define UART_FIFO_CMD_LEN 256 // länge eines Strings #define UART_FIFO_ANZ 128 // muss 2^n betragen (8, 16, 32, 64 ...) #define FIFO_MASK (UART_FIFO_ANZ - 1) // Klammern auf keinen Fall vergessen struct fifo_buffer { char data[UART_FIFO_ANZ][UART_FIFO_CMD_LEN]; unsigned char read; // zeigt auf das Feld mit dem ältesten Inhalt unsigned char write; // zeigt immer auf leeres Feld } uart_fifo = {{}, 0, 0}; Funktion zum speichern des Commandos: unsigned char Topt_mod_uart_FifoIn(char *pcCom){ unsigned int next; next = ((uart_fifo.write + 1) & FIFO_MASK); if (uart_fifo.read == next) return 1; strcpy(uart_fifo.data[uart_fifo.write & FIFO_MASK],pcCom); uart_fifo.write = next; return NOERR; } Funktion zum ausgeben des ersten Commandos: Eigentlich möchte ich das ich die Funktion aufrufe und dann mit dem Pointer pcComFifo weiter arbeiten kann. unsigned char Topt_mod_uart_FifoOut(char *pcComFifo) { if (uart_fifo.read == uart_fifo.write) return 60; // ergibt nicht das was ich will *pcComFifo = uart_fifo.data[uart_fifo.read]; uart_fifo.read = (uart_fifo.read+1) & FIFO_MASK; return NOERR; } Habt Ihr da vielleicht eine Idee. Ich glaub ich hab da einen Denkfehler. Wie würde ich das mit der Pointerübergabe denn realisieren? Gruß Andreas
Andreas Müller schrieb: > unsigned char Topt_mod_uart_FifoOut(char *pcComFifo) > { > if (uart_fifo.read == uart_fifo.write) > return 60; > // ergibt nicht das was ich will > *pcComFifo = uart_fifo.data[uart_fifo.read]; > uart_fifo.read = (uart_fifo.read+1) & FIFO_MASK; > return NOERR; > } char **pcComFifo im Parameter wäre korrekter.
Hi Leute, der Tip war super. Jetzt funktioniert es. Funktionsaufruf: unsigned char Topt_mod_usb_interpreter_get_uart(char *pcParm){ char *pcComFifo; Topt_mod_uart_FifoOut(&pcComFifo); return NOERR; } FIFO-Funktionen: #define UART_FIFO_CMD_LEN 256 // länge eines Strings #define UART_FIFO_ANZ 128 // muss 2^n betragen (8, 16, 32, 64 ...) #define FIFO_MASK (UART_FIFO_ANZ - 1) // Klammern auf keinen Fall vergessen struct fifo_buffer { char data[UART_FIFO_ANZ][UART_FIFO_CMD_LEN]; unsigned char read; // zeigt auf das Feld mit dem ältesten Inhalt unsigned char write; // zeigt immer auf leeres Feld } uart_fifo = {{}, 0, 0}; unsigned char Topt_mod_uart_FifoIn(char *pcCom){ unsigned int next; next = ((uart_fifo.write + 1) & FIFO_MASK); if (uart_fifo.read == next) return 1; strcpy(uart_fifo.data[uart_fifo.write & FIFO_MASK],pcCom); uart_fifo.write = next; return NOERR; } unsigned char Topt_mod_uart_FifoOut(char **pcComFifo) { if (uart_fifo.read == uart_fifo.write) return 1; *pcComFifo = uart_fifo.data[uart_fifo.read]; uart_fifo.read = (uart_fifo.read+1) & FIFO_MASK; return 0; } JLes: Kannst du mir kurz die Hintergründe des doppelstern beschreiben? Das wäre mir für die Zukunft sehr geholfen. Gruß Andreas
Andreas Müller schrieb: > Kannst du mir kurz die Hintergründe des doppelstern beschreiben? > Das wäre mir für die Zukunft sehr geholfen. In C werden (mit Ausnahme von Arrays) Argumente an eine Funktion immer so übergeben, dass die Funktion eine Kopie des Wertes bekommt.
1 | void foo( int j ) |
2 | {
|
3 | j = 8; |
4 | }
|
5 | |
6 | int main() |
7 | {
|
8 | int i; |
9 | |
10 | i = 5; |
11 | |
12 | foo( i ); |
13 | }
|
Wenn von main aus foo aufgerufen wird, so bekommt foo eine Kopie des Wertes von i, abgelegt in er Variablen j. Wenn daher foo j verändert, dann macht es das nur lokal, i ist davon nicht betroffen. Nur manchmal möchte man genau das nicht. Man möchte haben, dass eine Funktion eine Variable beim Aufrufer ändern kann. Was tun? Nun in diesem Fall, darf man logischerweise keine Kopie des aktuellen Wertes an die Funktion übergeben, sondern man übergibt die Adresse der Variablen (die natürlich ebenfalls als Kopie übergeben wird). Die Funktion kann dann über diese Speicheradresse, direkt auf die Variable des Aufrufers zugreifen
1 | void foo( int* j ) |
2 | {
|
3 | *j = 8; |
4 | }
|
5 | |
6 | int main() |
7 | {
|
8 | int i; |
9 | |
10 | i = 5; |
11 | |
12 | foo( &i ); |
13 | }
|
Jetzt kann foo, über den Pointer, direkt auf i in main zugreifen und es verändern. Das allgemeine Schema sieht daher so aus. Sei T irgendein Datentyp, dann ermöglicht mir
1 | void foo( T* argument ) |
2 | {
|
3 | *argument = .... |
dass die Funktion eine Variable vom Datentyp T beim Aufrufer ändern kann
1 | T eine_Variable; |
2 | |
3 | foo( & eine_Variable ); |
T kann jetzt irgendein Datentyp sein. Zb. auch ein char* Setzt du für T char* ein, so erhältst du
1 | void foo( char** argument ) |
2 | {
|
3 | ...
|
4 | }
|
5 | |
6 | char* eine_Variable; |
7 | |
8 | foo( & eine_Variable ); |
Hat denn dein C-Buch gar nichts zum Thema Argument-Passing an Funktionen zu sagen?
Andreas Müller schrieb:
> Kannst du mir kurz die Hintergründe des doppelstern beschreiben?
Gerne.
Wenn der Parameter so aussieht:
char *pcComFifo
referenziert er über den Pointer ein Char-Zeichen. Du benötigst aber
einen String, richtig? Du versuchst den String mit der Zeile
*pcComFifo = uart_fifo.data[uart_fifo.read];
zurückzugeben. Formal gesehen (ohne Rücksicht auf Parametertyp), ist
diese Zeile ganz korrekt. Der Zeiger auf aktuelle zu lesende Zeile wird
in den Speicher geschrieben, der über den Parameter pcComFifo
referenziert wird. In der alten Version wird ein Zeichen (also 1 Byte)
referenziert, und 1 Byte von... ich weiss dein Memory-Model nicht, aber
angenommen für Win32 ist es 4-Byte-Adresse... also von 4 Bytes wird nur
1 übertragen.
In der Funktion Topt_mod_usb_interpreter_get_uart hast du den String
richtig deklariert: char *pcComFifo. Das ist ein Zeiger auf die
Zeichen(kette). Wenn Du diesen als Referenz in andere Funktion
übertragst, wird ein Zeiger auf dein Speicherplatz namens pcComFifo
übertragen, der "Zeiger auf den Zeiger auf die Zeichen" heißt. Daher
zwei Sterne beim Parameter.
Also ich muss ja mal was loswerden. Das Forum ist einfach nur spitze und ihr seit spitze. Jetzt hab ich das auch verstanden mit dem Pointer auf einen Pointer. Ihr seit echt klasse. Großes Lob und Danke für die Hilfe. Gruß Andreas
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.