Subversion Repositories Projects

Rev

Rev 426 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 426 Rev 434
Line 58... Line 58...
58
#include <stdio.h>
58
#include <stdio.h>
59
#include <string.h>
59
#include <string.h>
60
#include "gpx.h"
60
#include "gpx.h"
61
#include "gpx_header.h"
61
#include "gpx_header.h"
62
#include "timer0.h"
62
#include "timer0.h"
63
//#include "spi_slave.h"
-
 
64
#include "main.h"
63
#include "main.h"
65
#include "uart1.h"
-
 
66
#include "ubx.h"
-
 
67
 
64
 
68
//________________________________________________________________________________________________________________________________________
65
//________________________________________________________________________________________________________________________________________
69
// Function:    GPX_DocumentInit(GPX_Document_t *)
66
// Function:    GPX_DocumentInit(GPX_Document_t *)
70
//
67
//
71
// Description: This function initializes the gpx-document for further use.
68
// Description: This function initializes the gpx-document for further use.
Line 93... Line 90...
93
 
90
 
94
uint8_t GPX_DocumentOpen(int8_t *name, GPX_Document_t *doc)
91
uint8_t GPX_DocumentOpen(int8_t *name, GPX_Document_t *doc)
95
{
92
{
96
 
93
 
97
        uint8_t retvalue = 0;
94
        uint8_t retvalue = 0;
-
 
95
        uint16_t i;
-
 
96
        int8_t c;
-
 
97
        const prog_char *str;
98
 
98
 
99
        if(doc == NULL) return(0);
99
        if(doc == NULL) return(0);
100
        GPX_DocumentInit(doc);                                                                                                          // intialize the document with resetvalues
100
        GPX_DocumentInit(doc);                                                                                                          // intialize the document with resetvalues
101
        doc->file = fopen_(name,'a');                                                                                           // open a new file with the specified filename on the memorycard.
101
        doc->file = fopen_(name,'a');                                                                                           // open a new file with the specified filename on the memorycard.
102
 
102
 
103
        if(doc->file != NULL)                                                                                                           // could the file be opened?
103
        if(doc->file != NULL)                                                                                                           // could the file be opened?
104
        {
104
        {
105
                retvalue = 1;                                                                                                                   // the document could be created on the drive.
105
                retvalue = 1;                                                                                                                   // the document could be created on the drive.
106
                doc->state = GPX_DOC_OPENED;                                                                                            // change document state to opened. At next a placemark has to be opened.
106
                doc->state = GPX_DOC_OPENED;                                                                                    // change document state to opened. At next a placemark has to be opened.
107
                fwrite_((void*)GPX_DOCUMENT_HEADER, sizeof(GPX_DOCUMENT_HEADER)-1,1,doc->file);// write the gpx-header to the document.
107
                str = GPX_DOCUMENT_HEADER;                                                                                              // write the gpx-header to the document..
-
 
108
                for(i= 0; i < sizeof(GPX_DOCUMENT_HEADER); i++)
-
 
109
                {
-
 
110
                        c = (int8_t)pgm_read_byte(str++); // get byte from flash
-
 
111
                        fputc_(c, doc->file); // and write that to sd-card
-
 
112
                }
108
        }
113
        }
109
 
114
 
110
        return(retvalue);
115
        return(retvalue);
111
}
116
}
112
 
117
 
Line 121... Line 126...
121
 
126
 
122
uint8_t GPX_DocumentClose(GPX_Document_t *doc)
127
uint8_t GPX_DocumentClose(GPX_Document_t *doc)
123
{
128
{
124
 
129
 
125
        uint8_t retvalue = 1;
130
        uint8_t retvalue = 1;
-
 
131
        uint16_t i;
-
 
132
        int8_t c;
-
 
133
        const prog_char *str;
126
 
134
 
127
        if(doc == NULL) return(0);
135
        if(doc == NULL) return(0);
128
 
136
 
129
        while(doc->state != GPX_DOC_CLOSED)                                                             // close linestring, placemark and document before closing the file on the memorycard
137
        while(doc->state != GPX_DOC_CLOSED)                                                             // close linestring, placemark and document before closing the file on the memorycard
130
        {
138
        {
Line 139... Line 147...
139
                                break;
147
                                break;
140
 
148
 
141
                        case GPX_DOC_OPENED:                                                                    // close the file on the memorycard
149
                        case GPX_DOC_OPENED:                                                                    // close the file on the memorycard
142
                                if(doc->file != NULL)
150
                                if(doc->file != NULL)
143
                                {
151
                                {
144
                                        fwrite_((void*)GPX_DOCUMENT_FOOTER, sizeof(GPX_DOCUMENT_FOOTER)-1,1,doc->file); // write the gpx-footer to the document.
152
                                        str = GPX_DOCUMENT_FOOTER;                                              // write the gpx-footer to the document.
-
 
153
                                        for(i= 0; i < sizeof(GPX_DOCUMENT_FOOTER); i++)
-
 
154
                                        {
-
 
155
                                                c = (int8_t)pgm_read_byte(str++); // get byte from flash
-
 
156
                                                fputc_(c, doc->file); // and write that to sd-card
-
 
157
                                        }
145
                                        fclose_(doc->file);
158
                                        fclose_(doc->file);
146
                                        retvalue = 1;
159
                                        retvalue = 1;
147
                                }
160
                                }
148
                                doc->state = GPX_DOC_CLOSED;
161
                                doc->state = GPX_DOC_CLOSED;
149
                                break;
162
                                break;
Line 167... Line 180...
167
 
180
 
168
uint8_t GPX_TrackBegin(GPX_Document_t *doc)
181
uint8_t GPX_TrackBegin(GPX_Document_t *doc)
169
{
182
{
170
 
183
 
171
        uint8_t retvalue = 0;
184
        uint8_t retvalue = 0;
-
 
185
        uint16_t i;
-
 
186
        int8_t c;
-
 
187
        const prog_char *str;
-
 
188
 
-
 
189
 
172
        if(doc->state == GPX_DOC_OPENED)
190
        if(doc->state == GPX_DOC_OPENED)
173
        {
191
        {
174
                if(doc->file != NULL)
192
                if(doc->file != NULL)
175
                {
193
                {
176
                        doc->state = GPX_DOC_TRACK_OPENED;
194
                        doc->state = GPX_DOC_TRACK_OPENED;
177
                        retvalue = 1;
195
                        retvalue = 1;
-
 
196
                        str = GPX_TRACK_HEADER;
178
                        fwrite_((void*)GPX_TRACK_HEADER, sizeof(GPX_TRACK_HEADER)-1,1,doc->file);
197
                        for(i= 0; i < sizeof(GPX_TRACK_HEADER); i++)
-
 
198
                        {
-
 
199
                                c = (int8_t)pgm_read_byte(str++); // get byte from flash
-
 
200
                                fputc_(c, doc->file); // and write that to sd-card
-
 
201
                        }
179
                }
202
                }
180
        }
203
        }
181
        return(retvalue);
204
        return(retvalue);
182
}
205
}
183
 
206
 
Line 192... Line 215...
192
 
215
 
193
uint8_t GPX_TrackEnd(GPX_Document_t *doc)
216
uint8_t GPX_TrackEnd(GPX_Document_t *doc)
194
{
217
{
195
 
218
 
196
        uint8_t retvalue = 0;
219
        uint8_t retvalue = 0;
-
 
220
        uint16_t i;
-
 
221
        int8_t c;
-
 
222
        const prog_char *str;
197
 
223
 
198
        if(doc->state == GPX_DOC_TRACK_OPENED)
224
        if(doc->state == GPX_DOC_TRACK_OPENED)
199
        {
225
        {
200
                if(doc->file != NULL)
226
                if(doc->file != NULL)
201
                {
227
                {
202
                        doc->state = GPX_DOC_OPENED;
228
                        doc->state = GPX_DOC_OPENED;
-
 
229
                        str = GPX_TRACK_FOOTER;
203
                        fwrite_((void*)GPX_TRACK_FOOTER, sizeof(GPX_TRACK_FOOTER)-1,1,doc->file);
230
                        for(i= 0; i < sizeof(GPX_TRACK_FOOTER); i++)
204
                        retvalue = 1;
231
                        {
-
 
232
                                c = (int8_t)pgm_read_byte(str++); // get byte from flash
-
 
233
                                fputc_(c, doc->file); // and write that to sd-card
-
 
234
                        }
205
                }
235
                }
206
        }
236
        }
207
 
237
 
208
        return(retvalue);
238
        return(retvalue);
209
}
239
}
Line 219... Line 249...
219
 
249
 
220
uint8_t GPX_TrackSegmentBegin(GPX_Document_t *doc)
250
uint8_t GPX_TrackSegmentBegin(GPX_Document_t *doc)
221
{
251
{
222
 
252
 
223
        uint8_t retvalue = 0;
253
        uint8_t retvalue = 0;
-
 
254
        uint16_t i;
-
 
255
        int8_t c;
-
 
256
        const prog_char *str;
224
 
257
 
225
        if(doc->state == GPX_DOC_TRACK_OPENED)
258
        if(doc->state == GPX_DOC_TRACK_OPENED)
226
        {
259
        {
227
                if(doc->file != NULL)
260
                if(doc->file != NULL)
228
                {
261
                {
229
                        doc->state = GPX_DOC_TRACKSEGMENT_OPENED;
262
                        doc->state = GPX_DOC_TRACKSEGMENT_OPENED;
-
 
263
                        str = GPX_TRACKSEGMENT_HEADER;
230
                        fwrite_((void*)GPX_TRACKSEGMENT_HEADER, sizeof(GPX_TRACKSEGMENT_HEADER)-1,1,doc->file);
264
                        for(i = 0; i < sizeof(GPX_TRACKSEGMENT_HEADER); i++)
-
 
265
                        {
-
 
266
                                c = (int8_t)pgm_read_byte(str++); // get byte from flash
-
 
267
                                fputc_(c, doc->file); // and write that to sd-card
-
 
268
                        }
231
                        retvalue = 1;
269
                        retvalue = 1;
232
                }
270
                }
233
        }
271
        }
234
        return(retvalue);
272
        return(retvalue);
235
}
273
}
Line 245... Line 283...
245
 
283
 
246
uint8_t GPX_TrackSegmentEnd(GPX_Document_t *doc)
284
uint8_t GPX_TrackSegmentEnd(GPX_Document_t *doc)
247
{
285
{
248
 
286
 
249
        uint8_t retvalue = 0;
287
        uint8_t retvalue = 0;
-
 
288
        uint16_t i;
-
 
289
        int8_t c;
-
 
290
        const prog_char *str;
-
 
291
 
-
 
292
 
250
        if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED)
293
        if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED)
251
        {
294
        {
252
                if(doc->file != NULL)
295
                if(doc->file != NULL)
253
                {
296
                {
254
                        doc->state = GPX_DOC_TRACK_OPENED;
297
                        doc->state = GPX_DOC_TRACK_OPENED;
-
 
298
                        str = GPX_TRACKSEGMENT_FOOTER;
255
                        fwrite_((void*)GPX_TRACKSEGMENT_FOOTER, sizeof(GPX_TRACKSEGMENT_FOOTER)-1,1,doc->file);
299
                        for(i = 0; i < sizeof(GPX_TRACKSEGMENT_FOOTER); i++)
-
 
300
                        {
-
 
301
                                c = (int8_t)pgm_read_byte(str++); // get byte from flash
-
 
302
                                fputc_(c, doc->file); // and write that to sd-card
-
 
303
                        }
256
                        retvalue = 1;
304
                        retvalue = 1;
257
                }
305
                }
258
        }
306
        }
259
        return(retvalue);
307
        return(retvalue);
260
}
308
}