sd-Raw_write

[gast (Gast)]

Hallo,

ich habe das Problem, dass folgende funktion nur einmal funktioniert.
nach dem aufrufen von sd_write schreibt er zwar noch den wert aus der
variablen, jedoch danach nichts mehr auf die karte, auch keine anderen 
Zeichen mehr.


SD Lib von Roland Rigel:
Atmega32L

volatile char lon[11];
uint32_t myoffset = 100;


-> wird mehrfach aufgerufen alle 4 sekunden

sd_raw_write(myoffset,&lon,strlen(lon) )
myoffset++;
sd_raw_sync();

[holger (Gast)]

Und du meinst aus diesem Codeschnipsel kann man
auf deinen Fehler schliessen? Was steht in lon?
strlen(lon) könnte sonstwas liefern wenn da
kein gültiger String drin steht.

>sd_raw_write(myoffset,&lon,strlen(lon) )

sd_raw_write(myoffset,lon,strlen(lon) )

[gast (Gast)]

beschreibe ich so:

pToken ist ein NMEA GPGA string den ich aufteile.
lon beinhaltet zu dem zeitpunkt tatsaechlich daten die ich
an ein lcd ausgebe, lon ist also niemals leer und schliest an stelle 10 
immer mit 0 ab.


strncpy(lon,pToken,10);
lon[10] = 0;

[gast (Gast)]

also ich hab mir selbst mal strlen() ueber itoa() per uart ausgeben 
lassen,
und er zeigt IMMER 10 an.
und direkt danach habe ich auch noch lon ausgeben lassen.
dieser besteht immer aus 10 Zeichen.

[gast (Gast)]

also ich habs nochmal probiert, irgendwas ist doch an der funktion
von sd_write nicht in ordnung.

[Knut B. (Firma: TravelRec.) (travelrec)]

Prüfe mal die Pins /CS und DO an der SD-Karte, wenn möglich mit 
Speicheroszi.

[gast (Gast)]

die Leitungen sind drann, denke ich.

was mir nicht in den kopf will, ich kann stundenlang, MB weise
da drauf schreiben, solange ich nur einzelne zeichen schreibe.
z.B. abwechselnd ein K und ein L.
aber sobald ich einmal den string aus 10 zeichen drauf schreibe, 
schreibt er den und danach is schluss, nix passiert mehr.

[Mario G. (mario)]

das problem liegt vermutlich im den stringoperationen. poste mal etwas 
mehr code...

[gast (Gast)]

ok, ich befuelle die variable in der gps.c:

Also das zerlegen des GGA strings funzt auf jedenfall,
ich gebe das auch aufs lcd und uart aus.

uint8_t what = 0; // 1 GGA,  2 VTG

// coord
volatile char tim[7];
volatile char lat[10];
volatile char lon[11];

// richtungen
volatile char latD[2];
volatile char lonD[2];


uint8_t ix;
ix = 0;
what = 0;

                  char* pToken = strtok(uart_buffer, ",");
while( pToken ) {

                   if ((ix == 0) && (strncmp( uart_buffer, "$GPGGA", 6 ) == 0))  {
what = 1;
}

                   if (what == 1) {
switch (ix){
      case 1:
               strncpy(tim,pToken,6);
               tim[7] = 0;
               myuart_puts("Tim:");
               myuart_puts(tim);
              break;
            case 2:
               strncpy(lat,pToken,9);
               lat[9] = 0;
               myuart_puts("Lat:");
               myuart_puts(lat);
              break;
            case 3:
               strncpy(latD,pToken,1);
               latD[1] = 0;
              break;
            case 4:
               strncpy(lon,pToken,10);
               lon[10] = 0;
               myuart_puts("Lon:");
               myuart_puts(lon);
              break;

und nun die SD zeug:

  myuart_puts("StringLen:");
  myuart_puts(itoa(strlen(lon),s,10));
  myuart_puts(lon);
        sd_raw_write(myoffset,lon,strlen(lon));
        myoffset++;
        sd_raw_sync();

[holger (Gast)]

Auch wenn es vermutlich das Problem nicht behebt:

>        sd_raw_write(myoffset,lon,strlen(lon));
>        myoffset++;

       myoffset += strlen(lon);

Dürfte da wohl angebracht sein.

[gast (Gast)]

Du das koennte sogar genau mein Problem sein, ich verschiebe den offset 
ja blos um eins, hab mal ein kleinen trick gemacht

void sdXX(const char *s) {
  while (*s) {
      sd_raw_write(myoffset,s,1);
      myoffset++;
    sd_raw_sync();
      s++;
   }
}


und siehe da, mein problem tritt nicht mehr auf, und warum? weil ich nur 
1 Byte schreibe