sd-Raw_write

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) )

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;

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.

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

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.

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.

1

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

2

3

// coord

4

volatile char tim[7];

5

volatile char lat[10];

6

volatile char lon[11];

7

8

// richtungen

9

volatile char latD[2];

10

volatile char lonD[2];

11

12

13

uint8_t ix;

14

ix = 0;

15

what = 0;

16

17

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

18

while( pToken ) {

19

20

                   if ((ix == 0) && (strncmp( uart_buffer, "$GPGGA", 6 ) == 0))  {

21

what = 1;

22

}

23

24

                   if (what == 1) {

25

switch (ix){

26

      case 1:

27

               strncpy(tim,pToken,6);

28

               tim[7] = 0;

29

               myuart_puts("Tim:");

30

               myuart_puts(tim);

31

              break;

32

            case 2:

33

               strncpy(lat,pToken,9);

34

               lat[9] = 0;

35

               myuart_puts("Lat:");

36

               myuart_puts(lat);

37

              break;

38

            case 3:

39

               strncpy(latD,pToken,1);

40

               latD[1] = 0;

41

              break;

42

            case 4:

43

               strncpy(lon,pToken,10);

44

               lon[10] = 0;

45

               myuart_puts("Lon:");

46

               myuart_puts(lon);

47

              break;

und nun die SD zeug:

1

  myuart_puts("StringLen:");

2

  myuart_puts(itoa(strlen(lon),s,10));

3

  myuart_puts(lon);

4

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

5

        myoffset++;

6

        sd_raw_sync();

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.

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