FatFs mit Fifo Bibliothek von Falk Brunner, Fifo behält trotz Auslesen und read_bursted Restdaten.

[Daniel N. (natulo)]

Guten Tag,

ich benutze in einem AVR Programm FatFS zusammen mit der FIFO 
Bibliothek von Falk Brunner.

Die grundsätzliche Idee war:
Ein AD Wandler misst eine Spannung und im ADC Interrupt wird der Wert in 
den Fifo geschrieben. Hat der Fifo einen gewissen "Füllstand" erreicht, 
schreibe ich die Werte mit FatFS auf eine SD Karte, sofern das Schreiben 
aktiviert ist.
Ist das Schreiben nicht mehr aktiviert, es befinden sich aber noch Daten 
im Fifo, so sollen diese auch auf die SD Karte geschrieben werden.

Den Schreib- und Lesezugriff auf den Fifo habe ich aus der Beispieldatei 
main_fifo.c übernommen.



Nachdem ich im normalen Betrieb Daten auf die Karte geschrieben und dann 
den Schreibmodus deaktiviert habe, sollten eigentlich die im Fifo 
verbliebenen Restdaten einmalig auf die SD Karte geschrieben werden. 
Danach wird der Füllstand des Fifos aktualisiert und er sollte nach 
meinem Verständnis leer sein.
Das Problem ist, dass der Füllstand des Fifos in meinem Programm laut 
fifo_get_level() allerdings nie den Wert 0 erreicht. Der Programmteil, 
der die Restdaten eigentlich nur einmalig abspeichern soll, wird 
fortlaufend aufgerufen.

Nach meinem Verständnis sollte der Füllstand nach dem Schreiben mit 
f_write und der Korrektur des Lesezeigers mit fifo_read_bursted 
eigentlich den Wert 0 erreichen. Das tut er aber nicht.




Scheinbar übersehe ich irgendetwas oder benutze die Fifo Funktionen 
falsch.
Wäre schön wenn jemand einen Blick auf den Code werfen könnte und mir 
zeigt, was ich falsch mache.
Ich kann mir das Verhalten im Augenblick nicht so recht erklären.




In der fertigen Textdatei sieht das dann so aus: (steht alles 
hintereinander, zur Verdeutlichung leicht gekürzt und formatiert)

abcbccccccccc[...]bcccccccccbccc (617 Zeichen/Byte)
x(NUL)[...]404 "NUL"[...](NUL)abcbccccccccc[...]bcccccccccbccc (617 Zeichen/Byte)
xxx(NUL)[...]402 "NUL"[...](NUL)abcbccccccccc[...]bcccccccccbccc (617 Zeichen/Byte)
xxxxx(NUL)[...]400 "NUL"[...](NUL)abcbccccccccc[...]bcccccccccbccc (617 Zeichen/Byte)
xxxxxxx(NUL)[...]398 "NUL"[...](NUL)abcbccccccccc[...]bcccccccccbccc (617 Zeichen/Byte)

usw.

Man sieht einen Zusammenhang zwischen den zunehmenden "x" und den 
abnehmenden "NUL".
Aber woher zieht er die "NUL", die er auf die Karte schreibt und wieso 
steigt die Anzahl der "x"?


Die UART Ausgaben im Code ergeben:

00507   // Ausgabe des Fifo Füllstandes mittels "uart_uint(fifo_get_level(&fifo),5);"
00512
Schreibvorgang:  00512
00005
00010
00015
00020
00025
00030
00035
00040
00045
00050
00055
00060
00065
00070
00075
00080
00085
00090
00095
00100
00105   // Hier wird der Schreibvorgang manuell beendet, Schreiben der Reste soll beginnen
Restdaten speichern:  00105 //fifo_get_level unmittelbar nach Eintritt, kurz danach wird das 'x' in den Fifo 
blocksize  00512   // Wert von fifo_block_size
wrapsize  00512   // Wert von fifo_wrap_size
level ende  00618   // fifo_get_level nach der Korrektur des Lesezeigers durch fifo_read_bursted
Restdaten speichern:  00618  // Funktion wird neu aufgerufen
blocksize  00512
wrapsize  01024
level ende  00107
Restdaten speichern:  00107
blocksize  00512
wrapsize  00512
level ende  00620
Restdaten speichern:  00620
blocksize  00512
wrapsize  01024
level ende  00109
Restdaten speichern:  00109
blocksize  00512
wrapsize  00512
level ende  00622
Restdaten speichern:  00622
blocksize  00512
wrapsize  01024
level ende  00111
Restdaten speichern:  00111
blocksize  00512
wrapsize  00512
level ende  00624
Restdaten speichern:  00624
blocksize  00512
wrapsize  01024
level ende  00113

Der Code sieht in Auszügen so aus:

Main.h:

#define fifo_buffersize 1024
#define fifo_writesize 512

Main.c:

fifo_t fifo;
fifo_data_t fifo_bufferarray[fifo_buffersize];


ISR(ADC_vect){
    if(SDcard_ready && AnalogChannel.WriteEnable){
        if(fifo_get_free_ISR(&fifo)){
            if(fifo_write_code0&(1<<i)){  
                fifo_write_ISR(&fifo,'a'); // bei Start des Schreivorgangs
                fifo_write_code0&=~(1<<i);
            } else if ((AnalogChannel.Abtastfreq==1)||fifo_write_code1&(1<<i)){ // jede Sekunde
                fifo_write_ISR(&fifo,'b');
                fifo_write_code1&=~(1<<i);
            } else {
                fifo_write_ISR(&fifo,'c');
            }
        }
    }
}


int main(){
    [...]
    fifo_init(&fifo, fifo_bufferarray,sizeof(fifo_bufferarray)/sizeof(fifo_data_t));
    uint16_t fifo_wrap_size;
    uint16_t fifo_block_size=fifo_writesize;

while(1){
    [...]

    // Normaler Schreibvorgang auf SD Karte
    if(SDcard_ready && (fifo_get_level(&fifo)>=fifo_block_size) && writeEnableCheck()){
    uart_puts("Schreibvorgang:\t");
    uart_uint(fifo_get_level(&fifo),5);
    uart_putc('\n');
    
    fifo_wrap_size = fifo_get_read_wrap(&fifo);
    
  
    if (fifo_block_size > fifo_wrap_size) {
        // split action into two blocks due to pointer wrap around
        f_write(&file1, (uint8_t*)fifo.read_p, fifo_wrap_size * sizeof(fifo_data_t), &fatfs_bytes_written);
        fifo_read_bursted(&fifo, fifo_wrap_size);
        fifo_block_size -= fifo_wrap_size;
    }
    // no pointer wrap around in block or second half of block operation
      
    f_write(&file1, (uint8_t*)fifo.read_p, fifo_block_size * sizeof(fifo_data_t), &fatfs_bytes_written);
    fifo_read_bursted(&fifo, fifo_block_size);
  
    }



    // Inhalt des Fifo auf Karte schreiben, wenn kein Kanal mehr loggt, aber noch Daten im Fifo liegen
    if( !writeEnableCheck() && SDcard_ready && fifo_get_level(&fifo)){
        uart_puts("Restdaten speichern:\t");   // UART "Restdaten speichern"
        uart_uint(fifo_get_level(&fifo),5);
        uart_putc('\n');
        
        fifo_write(&fifo,'x');   // hier kommt das x her
    
        fifo_wrap_size = fifo_get_read_wrap(&fifo);
    
        uart_puts("blocksize\t");      // UART "Blocksize"
        uart_uint(fifo_block_size,5);
        uart_putc('\n');
    
        uart_puts("wrapsize\t");        // UART "Wrapsize"
        uart_uint(fifo_wrap_size,5);
        uart_putc('\n');
    
        
        if (fifo_block_size > fifo_wrap_size) {
        // split action into two blocks due to pointer wrap around
        
        f_write(&file1, (uint8_t*)fifo.read_p, fifo_wrap_size * sizeof(fifo_data_t), &fatfs_bytes_written);
        fifo_read_bursted(&fifo, fifo_wrap_size);
        fifo_block_size -= fifo_wrap_size;
       
        uart_puts("wrapsize gtlvl\t");
        uart_uint(fifo_get_level(&fifo),5);
        uart_putc('\n');
        
        }
        // no pointer wrap around in block or second half of block operation
        
        f_write(&file1, (uint8_t*)fifo.read_p, fifo_block_size * sizeof(fifo_data_t), &fatfs_bytes_written);
        fifo_read_bursted(&fifo, fifo_block_size);
    
        uart_puts("level ende\t");         // UART "Level Ende"
        uart_uint(fifo_get_level(&fifo),5);
        uart_putc('\n');
    
        f_sync(&file1);
    
    }

[Falk B. (falk)]

@Michael N. (natulo)

>ich benutze in einem AVR Programm FatFS zusammen mit der FIFO
>Bibliothek von Falk Brunner.

Schön. Aber ist der Betreff deines Beitrag nicht ein "wenig" lang? ;-)

>Die grundsätzliche Idee war:

Die Idee ist grundsätzlich richtig. Sie muss aber auch korrekt umgesetzt 
werden.

Wie schnell arbeitet dein ADC (Abtastrate)?

>Ist das Schreiben nicht mehr aktiviert, es befinden sich aber noch Daten
>im Fifo, so sollen diese auch auf die SD Karte geschrieben werden.

Hier wird es schwammig.

>Nachdem ich im normalen Betrieb Daten auf die Karte geschrieben und dann
>den Schreibmodus deaktiviert habe, sollten eigentlich die im Fifo
>verbliebenen Restdaten einmalig auf die SD Karte geschrieben werden.
>Danach wird der Füllstand des Fifos aktualisiert und er sollte nach
>meinem Verständnis leer sein.

Nö, denn parallel zum Schreiben auf SD-Karte kommen ja neue Daten vom 
AD-Wandler.

>Das Problem ist, dass der Füllstand des Fifos in meinem Programm laut
>fifo_get_level() allerdings nie den Wert 0 erreicht.

Logisch.

>Der Programmteil,
>der die Restdaten eigentlich nur einmalig abspeichern soll, wird
>fortlaufend aufgerufen.

Programmfehler.

>Nach meinem Verständnis sollte der Füllstand nach dem Schreiben mit
>f_write und der Korrektur des Lesezeigers mit fifo_read_bursted
>eigentlich den Wert 0 erreichen. Das tut er aber nicht.

Siehe oben.

Ich glaube der Fehler liegt in deinem 2. Abschnitt.

    // Inhalt des Fifo auf Karte schreiben, wenn kein Kanal mehr loggt, aber noch Daten im Fifo liegen
    if( !writeEnableCheck() && SDcard_ready && fifo_get_level(&fifo)){
        uart_puts("Restdaten speichern:\t");   // UART "Restdaten speichern"
        uart_uint(fifo_get_level(&fifo),5);
        uart_putc('\n');
        
        fifo_write(&fifo,'x');   // hier kommt das x her
    
        fifo_wrap_size = fifo_get_read_wrap(&fifo);
    
        uart_puts("blocksize\t");      // UART "Blocksize"
        uart_uint(fifo_block_size,5);
        uart_putc('\n');
    
        uart_puts("wrapsize\t");        // UART "Wrapsize"
        uart_uint(fifo_wrap_size,5);
        uart_putc('\n');
    
        
        if (fifo_block_size > fifo_wrap_size) {
        // split action into two blocks due to po

Hier darfst du natürlich NICHT mit fifo_block_size Daten lesen, sondern 
nur den Rest! Eher so.

    // Inhalt des Fifo auf Karte schreiben, wenn kein Kanal mehr loggt, aber noch Daten im Fifo liegen
    if( !writeEnableCheck() && SDcard_ready && fifo_get_level(&fifo)){
        uart_puts("Restdaten speichern:\t");   // UART "Restdaten speichern"
        uart_uint(fifo_get_level(&fifo),5);
        uart_putc('\n');
        
        fifo_write(&fifo,'x');   // hier kommt das x her
    
        fifo_wrap_size = fifo_get_read_wrap(&fifo);
       
        rest_size = fifo_get_level(&fifo);
        uart_puts("restsize\t");      // UART "Blocksize"
        uart_uint(rest_size,5);
        uart_putc('\n');
    
        uart_puts("wrapsize\t");        // UART "Wrapsize"
        uart_uint(fifo_wrap_size,5);
        uart_putc('\n');
    
        
        if (rest_size > fifo_wrap_size) {
        // split action into two blocks due to pointer wrap around
        
        f_write(&file1, (uint8_t*)fifo.read_p, fifo_wrap_size * sizeof(fifo_data_t), &fatfs_bytes_written);
        fifo_read_bursted(&fifo, fifo_wrap_size);
        rest_size -= fifo_wrap_size;
       
        uart_puts("wrapsize gtlvl\t");
        uart_uint(fifo_get_level(&fifo),5);
        uart_putc('\n');
        
        }
        // no pointer wrap around in block or second half of block operation
        
        f_write(&file1, (uint8_t*)fifo.read_p, rest_size * sizeof(fifo_data_t), &fatfs_bytes_written);
        fifo_read_bursted(&fifo, fifo_block_size);
    
        uart_puts("level ende\t");         // UART "Level Ende"
        uart_uint(fifo_get_level(&fifo),5);
        uart_putc('\n');
    
        f_sync(&file1);
    
    }

Kleiner Tip. Die Sequenz mit den 2 Blöcken für den FIFO-Zugriff und 
SD-zugriff packt man besser in eine Funktion. Denn sie wird 2 mal 
verwendet und ist recht lang. Damit wird deine Hauptschleife kürzer und 
übersichtlicher.

[Daniel N. (natulo)]

Hallo Falk, vielen Dank für die Antwort!

Falk B. schrieb:
> @Michael N. (natulo)
>
> Schön. Aber ist der Betreff deines Beitrag nicht ein "wenig" lang? ;-)
>

Ich wusste nicht wie ich das Problem auf den Punktbringen soll, daher 
wollte ich möglichst viele Informationen in den Titel stopfen damit 
direkt erkennt, worum es in dem Thema geht.

>>Die grundsätzliche Idee war:
>
> Die Idee ist grundsätzlich richtig. Sie muss aber auch korrekt umgesetzt
> werden.
>
> Wie schnell arbeitet dein ADC (Abtastrate)?
>
Über einen 1ms Interrupt mit 1/10/100/1000Hz jeweils als Einzelwandlung.

>>Ist das Schreiben nicht mehr aktiviert, es befinden sich aber noch Daten
>>im Fifo, so sollen diese auch auf die SD Karte geschrieben werden.
>
> Hier wird es schwammig.
>
Da SD Karten erst bei Vielfachen von 512 Byte richtig schnell schreiben, 
war die Idee einen Fifo mit z.B. 2048 Byte Größe anzulegen, in den dann 
die Wandlerwerte geschoben werden.
Wenn der Füllstand des Fifo dann z.B. 1024 Byte übersteigt, sollen diese 
auf die SD Karte geschrieben werden. Das wäre der "normale" 
Schreibvorgang.

Wenn ich den Schreibmodus beende, aber erst z.B. 240 Byte im Fifo sind, 
sollen diese auf die SD Karte geschrieben werden, auch wenn noch nicht 
die z.B. 1024 Byte voll sind. Daher das Schreiben der "Restdaten".

Zumindest ist das mein aktueller Ansatz.

>>Nachdem ich im normalen Betrieb Daten auf die Karte geschrieben und dann
>>den Schreibmodus deaktiviert habe, sollten eigentlich die im Fifo
>>verbliebenen Restdaten einmalig auf die SD Karte geschrieben werden.
>>Danach wird der Füllstand des Fifos aktualisiert und er sollte nach
>>meinem Verständnis leer sein.
>
> Nö, denn parallel zum Schreiben auf SD-Karte kommen ja neue Daten vom
> AD-Wandler.
>

Der AD-Wandler läuft zwar weiter, die Ergebnisse werden aber nur in den 
Fifo geschrieben wenn die jeweilige "WriteEnable" Variable gesetzt ist.
(if-Abfrage im ADC Interrupt)
Beim Deaktivieren des Schreibmodus wird die Variable auf 0 gesetzt.


>>Der Programmteil,
>>der die Restdaten eigentlich nur einmalig abspeichern soll, wird
>>fortlaufend aufgerufen.
>
> Programmfehler.
>

Korrekt.


>
> Ich glaube der Fehler liegt in deinem 2. Abschnitt.
>

Ebenfalls korrekt. Als ich deine Antwort gelesen habe, hat mich 
sinnbildlich der Blitz getroffen.
Wenn man sich in Ruhe verdeutlicht was das Programm da macht, ist das 
einer dieser "logisch, wieso habe ich das nicht gesehen?" Fehler.

Was ich gemacht habe:
Es sind z.B. 100 Byte an Restdaten im Fifo, schreibe fifo_block_size = 
512 Byte aus dem Fifo auf die SD Karte und korrigiere den Lesezeiger um 
512 Byte. Da braucht man sich dann auch nicht wundern, wieso das schief 
geht.

Richtig und logisch ist natürlich deine Korrektur:
Guck wie viele Restdaten noch im Fifo sind, merk dir die Anzahl und 
schreibe dann diese Anzahl an Bytes auf die SD Karte und korrigiere 
entsprechend den Lesezeiger.

Mit dem korrigierten Code klappt es.

if( !writeEnableCheck() && SDcard_ready && fifo_get_level(&fifo)){
    fifo_wrap_size = fifo_get_read_wrap(&fifo);
 
    rest_size = fifo_get_level(&fifo);
 
    if (rest_size > fifo_wrap_size) {
        // split action into two blocks due to pointer wrap around
 
        f_write(&file1, (uint8_t*)fifo.read_p, fifo_wrap_size * sizeof(fifo_data_t), &fatfs_bytes_written);
        fifo_read_bursted(&fifo, fifo_wrap_size);
        rest_size -= fifo_wrap_size;
 
    }
    // no pointer wrap around in block or second half of block operation
 
    f_write(&file1, (uint8_t*)fifo.read_p, rest_size * sizeof(fifo_data_t), &fatfs_bytes_written);
    fifo_read_bursted(&fifo, fifo_block_size); // Anm.: hier dann natürlich ebenfalls rest_size
 
    f_sync(&file1);
    }

>
> Kleiner Tip. Die Sequenz mit den 2 Blöcken für den FIFO-Zugriff und
> SD-zugriff packt man besser in eine Funktion. Denn sie wird 2 mal
> verwendet und ist recht lang. Damit wird deine Hauptschleife kürzer und
> übersichtlicher.

Danke für den Tipp, werde ich machen!

[Falk B. (falk)]

@ Michael N. (natulo)

>> Schön. Aber ist der Betreff deines Beitrag nicht ein "wenig" lang? ;-)

>Ich wusste nicht wie ich das Problem auf den Punktbringen soll, daher
>wollte ich möglichst viele Informationen in den Titel stopfen damit
>direkt erkennt, worum es in dem Thema geht.

Nicht sinnvoll, das gehört in den 1. Beitrag. Die Überschrift sollte 
eher kurz und prägnant sein.

Problem mit FATfs + FIFO

>Da SD Karten erst bei Vielfachen von 512 Byte richtig schnell schreiben,
>war die Idee einen Fifo mit z.B. 2048 Byte Größe anzulegen, in den dann
>die Wandlerwerte geschoben werden.

Ja, aber das macht FATfs schon, das hat einen 512 Byte Sektorpuffer.

Beitrag "Re: Geschwindigkeitsfrage AVR auf SD"

>Wenn der Füllstand des Fifo dann z.B. 1024 Byte übersteigt, sollen diese
>auf die SD Karte geschrieben werden. Das wäre der "normale"
>Schreibvorgang.

Ist OK.

>Wenn ich den Schreibmodus beende, aber erst z.B. 240 Byte im Fifo sind,
>sollen diese auf die SD Karte geschrieben werden, auch wenn noch nicht
>die z.B. 1024 Byte voll sind. Daher das Schreiben der "Restdaten".

Schon klar.

>Ebenfalls korrekt. Als ich deine Antwort gelesen habe, hat mich
>sinnbildlich der Blitz getroffen.

;-)

>Wenn man sich in Ruhe verdeutlicht was das Programm da macht, ist das
>einer dieser "logisch, wieso habe ich das nicht gesehen?" Fehler.

Das ist das "ich sehe den Wald vor lauter Bäumen nicht"-Problem.

>Mit dem korrigierten Code klappt es.

Heureka!