Rev 119 | Rev 126 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 119 | Rev 125 | ||
---|---|---|---|
1 | /*#######################################################################################*/ |
1 | /*#######################################################################################*/ |
2 | /* !!! THIS IS NOT FREE SOFTWARE !!! */ |
2 | /* !!! THIS IS NOT FREE SOFTWARE !!! */ |
3 | /*#######################################################################################*/ |
3 | /*#######################################################################################*/ |
4 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
4 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
5 | // + Copyright (c) 2008 Ingo Busker, Holger Buss |
5 | // + Copyright (c) 2008 Ingo Busker, Holger Buss |
6 | // + Nur für den privaten Gebrauch |
6 | // + Nur für den privaten Gebrauch |
7 | // + FOR NON COMMERCIAL USE ONLY |
7 | // + FOR NON COMMERCIAL USE ONLY |
8 | // + www.MikroKopter.com |
8 | // + www.MikroKopter.com |
9 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
9 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
10 | // + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), |
10 | // + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), |
11 | // + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. |
11 | // + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. |
12 | // + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt |
12 | // + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt |
13 | // + bzgl. der Nutzungsbedingungen aufzunehmen. |
13 | // + bzgl. der Nutzungsbedingungen aufzunehmen. |
14 | // + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen, |
14 | // + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen, |
15 | // + Verkauf von Luftbildaufnahmen, usw. |
15 | // + Verkauf von Luftbildaufnahmen, usw. |
16 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
16 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
17 | // + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, |
17 | // + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, |
18 | // + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen |
18 | // + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen |
19 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
19 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
20 | // + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts |
20 | // + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts |
21 | // + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de" |
21 | // + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de" |
22 | // + eindeutig als Ursprung verlinkt werden |
22 | // + eindeutig als Ursprung verlinkt werden |
23 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
23 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
24 | // + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion |
24 | // + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion |
25 | // + Benutzung auf eigene Gefahr |
25 | // + Benutzung auf eigene Gefahr |
26 | // + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden |
26 | // + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden |
27 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
27 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
28 | // + Die PORTIERUNG der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur |
28 | // + Die PORTIERUNG der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur |
29 | // + mit unserer Zustimmung zulässig |
29 | // + mit unserer Zustimmung zulässig |
30 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
30 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
31 | // + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen |
31 | // + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen |
32 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
32 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
33 | // + Redistributions of source code (with or without modifications) must retain the above copyright notice, |
33 | // + Redistributions of source code (with or without modifications) must retain the above copyright notice, |
34 | // + this list of conditions and the following disclaimer. |
34 | // + this list of conditions and the following disclaimer. |
35 | // + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived |
35 | // + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived |
36 | // + from this software without specific prior written permission. |
36 | // + from this software without specific prior written permission. |
37 | // + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted |
37 | // + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted |
38 | // + for non-commercial use (directly or indirectly) |
38 | // + for non-commercial use (directly or indirectly) |
39 | // + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted |
39 | // + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted |
40 | // + with our written permission |
40 | // + with our written permission |
41 | // + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be |
41 | // + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be |
42 | // + clearly linked as origin |
42 | // + clearly linked as origin |
43 | // + * PORTING this software (or part of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed |
43 | // + * PORTING this software (or part of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed |
44 | // |
44 | // |
45 | // + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
45 | // + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
46 | // + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
46 | // + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
47 | // + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
47 | // + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
48 | // + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
48 | // + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
49 | // + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
49 | // + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
50 | // + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
50 | // + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
51 | // + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
51 | // + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
52 | // + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
52 | // + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
53 | // + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
53 | // + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
54 | // + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
54 | // + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
55 | // + POSSIBILITY OF SUCH DAMAGE. |
55 | // + POSSIBILITY OF SUCH DAMAGE. |
56 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
56 | // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
57 | #include <stdlib.h> |
57 | #include <stdlib.h> |
58 | #include <stdio.h> |
58 | #include <stdio.h> |
59 | #include "91x_lib.h" |
59 | #include "91x_lib.h" |
60 | #include "gpx.h" |
60 | #include "gpx.h" |
61 | #include "gpx_header.h" |
61 | #include "gpx_header.h" |
62 | #include "timer1.h" |
62 | #include "timer1.h" |
63 | #include "spi_slave.h" |
63 | #include "spi_slave.h" |
64 | #include "main.h" |
64 | #include "main.h" |
65 | #include "uart1.h" |
65 | #include "uart1.h" |
66 | 66 | ||
67 | //________________________________________________________________________________________________________________________________________ |
67 | //________________________________________________________________________________________________________________________________________ |
68 | // Function: GPX_DocumentInit(GPX_Document_t *) |
68 | // Function: GPX_DocumentInit(GPX_Document_t *) |
69 | // |
69 | // |
70 | // Description: This function initializes the gpx-document for further use. |
70 | // Description: This function initializes the gpx-document for further use. |
71 | // |
71 | // |
72 | // |
72 | // |
73 | // Returnvalue: '1' if document was initialized |
73 | // Returnvalue: '1' if document was initialized |
74 | //________________________________________________________________________________________________________________________________________ |
74 | //________________________________________________________________________________________________________________________________________ |
75 | 75 | ||
76 | u8 GPX_DocumentInit(GPX_Document_t *doc) |
76 | u8 GPX_DocumentInit(GPX_Document_t *doc) |
77 | { |
77 | { |
78 | if(doc->state != GPX_DOC_CLOSED) GPX_DocumentClose(doc); // close file if it was opened before |
78 | if(doc->state != GPX_DOC_CLOSED) GPX_DocumentClose(doc); // close file if it was opened before |
79 | doc->state = GPX_DOC_CLOSED; // init state of the gpx-document |
79 | doc->state = GPX_DOC_CLOSED; // init state of the gpx-document |
80 | doc->file = NULL; |
80 | doc->file = NULL; |
81 | return(1); |
81 | return(1); |
82 | } |
82 | } |
83 | 83 | ||
84 | //________________________________________________________________________________________________________________________________________ |
84 | //________________________________________________________________________________________________________________________________________ |
85 | // Function: GPX_Document_Open(s8 *name, GPX_Document_t *doc); |
85 | // Function: GPX_Document_Open(s8 *name, GPX_Document_t *doc); |
86 | // |
86 | // |
87 | // Description: This function opens a new gpx-document with the specified name and creates the document header within the file. |
87 | // Description: This function opens a new gpx-document with the specified name and creates the document header within the file. |
88 | // |
88 | // |
89 | // |
89 | // |
90 | // Returnvalue: '1' if the gpx-file could be created. |
90 | // Returnvalue: '1' if the gpx-file could be created. |
91 | //________________________________________________________________________________________________________________________________________ |
91 | //________________________________________________________________________________________________________________________________________ |
92 | 92 | ||
93 | u8 GPX_DocumentOpen(s8 *name, GPX_Document_t *doc) |
93 | u8 GPX_DocumentOpen(s8 *name, GPX_Document_t *doc) |
94 | { |
94 | { |
95 | 95 | ||
96 | u8 retvalue = 0; |
96 | u8 retvalue = 0; |
97 | 97 | ||
98 | if(doc == NULL) return(0); |
98 | if(doc == NULL) return(0); |
99 | GPX_DocumentInit(doc); // intialize the document with resetvalues |
99 | GPX_DocumentInit(doc); // intialize the document with resetvalues |
100 | doc->file = fopen_(name,'a'); // open a new file with the specified filename on the memorycard. |
100 | doc->file = fopen_(name,'a'); // open a new file with the specified filename on the memorycard. |
101 | 101 | ||
102 | if(doc->file != NULL) // could the file be opened? |
102 | if(doc->file != NULL) // could the file be opened? |
103 | { |
103 | { |
104 | retvalue = 1; // the document could be created on the drive. |
104 | retvalue = 1; // the document could be created on the drive. |
105 | doc->state = GPX_DOC_OPENED; // change document state to opened. At next a placemark has to be opened. |
105 | doc->state = GPX_DOC_OPENED; // change document state to opened. At next a placemark has to be opened. |
106 | fwrite_((void*)GPX_DOCUMENT_HEADER, sizeof(GPX_DOCUMENT_HEADER)-1,1,doc->file);// write the gpx-header to the document. |
106 | fwrite_((void*)GPX_DOCUMENT_HEADER, sizeof(GPX_DOCUMENT_HEADER)-1,1,doc->file);// write the gpx-header to the document. |
107 | } |
107 | } |
108 | 108 | ||
109 | return(retvalue); |
109 | return(retvalue); |
110 | } |
110 | } |
111 | 111 | ||
112 | //________________________________________________________________________________________________________________________________________ |
112 | //________________________________________________________________________________________________________________________________________ |
113 | // Function: DocumentClose(GPX_Document_t *doc); |
113 | // Function: DocumentClose(GPX_Document_t *doc); |
114 | // |
114 | // |
115 | // Description: This function closes the document specified by doc. |
115 | // Description: This function closes the document specified by doc. |
116 | // |
116 | // |
117 | // |
117 | // |
118 | // Returnvalue: '1' if the gpx-file could be closed. |
118 | // Returnvalue: '1' if the gpx-file could be closed. |
119 | //________________________________________________________________________________________________________________________________________ |
119 | //________________________________________________________________________________________________________________________________________ |
120 | 120 | ||
121 | u8 GPX_DocumentClose(GPX_Document_t *doc) |
121 | u8 GPX_DocumentClose(GPX_Document_t *doc) |
122 | { |
122 | { |
123 | 123 | ||
124 | u8 retvalue = 1; |
124 | u8 retvalue = 1; |
125 | 125 | ||
126 | if(doc == NULL) return(0); |
126 | if(doc == NULL) return(0); |
127 | 127 | ||
128 | while(doc->state != GPX_DOC_CLOSED) // close linestring, placemark and document before closing the file on the memorycard |
128 | while(doc->state != GPX_DOC_CLOSED) // close linestring, placemark and document before closing the file on the memorycard |
129 | { |
129 | { |
130 | switch(doc->state) |
130 | switch(doc->state) |
131 | { |
131 | { |
132 | case GPX_DOC_TRACKSEGMENT_OPENED: |
132 | case GPX_DOC_TRACKSEGMENT_OPENED: |
133 | GPX_TrackSegmentEnd(doc); // write terminating tag to end tracksegment. |
133 | GPX_TrackSegmentEnd(doc); // write terminating tag to end tracksegment. |
134 | break; |
134 | break; |
135 | 135 | ||
136 | case GPX_DOC_TRACK_OPENED: // write terminating tag to close track. |
136 | case GPX_DOC_TRACK_OPENED: // write terminating tag to close track. |
137 | GPX_TrackEnd(doc); |
137 | GPX_TrackEnd(doc); |
138 | break; |
138 | break; |
139 | 139 | ||
140 | case GPX_DOC_OPENED: // close the file on the memorycard |
140 | case GPX_DOC_OPENED: // close the file on the memorycard |
141 | if(doc->file != NULL) |
141 | if(doc->file != NULL) |
142 | { |
142 | { |
143 | fwrite_((void*)GPX_DOCUMENT_FOOTER, sizeof(GPX_DOCUMENT_FOOTER)-1,1,doc->file); // write the gpx-footer to the document. |
143 | fwrite_((void*)GPX_DOCUMENT_FOOTER, sizeof(GPX_DOCUMENT_FOOTER)-1,1,doc->file); // write the gpx-footer to the document. |
144 | fclose_(doc->file); |
144 | fclose_(doc->file); |
145 | retvalue = 1; |
145 | retvalue = 1; |
146 | } |
146 | } |
147 | doc->state = GPX_DOC_CLOSED; |
147 | doc->state = GPX_DOC_CLOSED; |
148 | break; |
148 | break; |
149 | 149 | ||
150 | default: |
150 | default: |
151 | doc->state = GPX_DOC_CLOSED; |
151 | doc->state = GPX_DOC_CLOSED; |
152 | break; |
152 | break; |
153 | } |
153 | } |
154 | } |
154 | } |
155 | return(retvalue); |
155 | return(retvalue); |
156 | } |
156 | } |
157 | 157 | ||
158 | //________________________________________________________________________________________________________________________________________ |
158 | //________________________________________________________________________________________________________________________________________ |
159 | // Function: u8 GPX_TrackBegin(GPX_Document_t); |
159 | // Function: u8 GPX_TrackBegin(GPX_Document_t); |
160 | // |
160 | // |
161 | // Description: This function adds a track to the document. |
161 | // Description: This function adds a track to the document. |
162 | // |
162 | // |
163 | // |
163 | // |
164 | // Returnvalue: '1' if the track could be opened |
164 | // Returnvalue: '1' if the track could be opened |
165 | //________________________________________________________________________________________________________________________________________ |
165 | //________________________________________________________________________________________________________________________________________ |
166 | 166 | ||
167 | u8 GPX_TrackBegin(GPX_Document_t *doc) |
167 | u8 GPX_TrackBegin(GPX_Document_t *doc) |
168 | { |
168 | { |
169 | 169 | ||
170 | u8 retvalue = 0; |
170 | u8 retvalue = 0; |
171 | if(doc->state == GPX_DOC_OPENED) |
171 | if(doc->state == GPX_DOC_OPENED) |
172 | { |
172 | { |
173 | if(doc->file != NULL) |
173 | if(doc->file != NULL) |
174 | { |
174 | { |
175 | doc->state = GPX_DOC_TRACK_OPENED; |
175 | doc->state = GPX_DOC_TRACK_OPENED; |
176 | retvalue = 1; |
176 | retvalue = 1; |
177 | fwrite_((void*)GPX_TRACK_HEADER, sizeof(GPX_TRACK_HEADER)-1,1,doc->file); |
177 | fwrite_((void*)GPX_TRACK_HEADER, sizeof(GPX_TRACK_HEADER)-1,1,doc->file); |
178 | } |
178 | } |
179 | } |
179 | } |
180 | return(retvalue); |
180 | return(retvalue); |
181 | } |
181 | } |
182 | 182 | ||
183 | //________________________________________________________________________________________________________________________________________ |
183 | //________________________________________________________________________________________________________________________________________ |
184 | // Function: u8 GPX_TrackEnd(KML_Document_t *doc) |
184 | // Function: u8 GPX_TrackEnd(KML_Document_t *doc) |
185 | // |
185 | // |
186 | // Description: This function ends the track opened before. |
186 | // Description: This function ends the track opened before. |
187 | // |
187 | // |
188 | // |
188 | // |
189 | // Returnvalue: 1' if the track could be closed |
189 | // Returnvalue: 1' if the track could be closed |
190 | //________________________________________________________________________________________________________________________________________ |
190 | //________________________________________________________________________________________________________________________________________ |
191 | 191 | ||
192 | u8 GPX_TrackEnd(GPX_Document_t *doc) |
192 | u8 GPX_TrackEnd(GPX_Document_t *doc) |
193 | { |
193 | { |
194 | 194 | ||
195 | u8 retvalue = 0; |
195 | u8 retvalue = 0; |
196 | 196 | ||
197 | if(doc->state == GPX_DOC_TRACK_OPENED) |
197 | if(doc->state == GPX_DOC_TRACK_OPENED) |
198 | { |
198 | { |
199 | if(doc->file != NULL) |
199 | if(doc->file != NULL) |
200 | { |
200 | { |
201 | doc->state = GPX_DOC_OPENED; |
201 | doc->state = GPX_DOC_OPENED; |
202 | fwrite_((void*)GPX_TRACK_FOOTER, sizeof(GPX_TRACK_FOOTER)-1,1,doc->file); |
202 | fwrite_((void*)GPX_TRACK_FOOTER, sizeof(GPX_TRACK_FOOTER)-1,1,doc->file); |
203 | retvalue = 1; |
203 | retvalue = 1; |
204 | } |
204 | } |
205 | } |
205 | } |
206 | 206 | ||
207 | return(retvalue); |
207 | return(retvalue); |
208 | } |
208 | } |
209 | 209 | ||
210 | //________________________________________________________________________________________________________________________________________ |
210 | //________________________________________________________________________________________________________________________________________ |
211 | // Function: u8 GPX_TrackSegmentBegin(GPX_Document_t *doc); |
211 | // Function: u8 GPX_TrackSegmentBegin(GPX_Document_t *doc); |
212 | // |
212 | // |
213 | // Description: This function starts a track segment. |
213 | // Description: This function starts a track segment. |
214 | // |
214 | // |
215 | // |
215 | // |
216 | // Returnvalue: '1' if the track segement could be started |
216 | // Returnvalue: '1' if the track segement could be started |
217 | //________________________________________________________________________________________________________________________________________ |
217 | //________________________________________________________________________________________________________________________________________ |
218 | 218 | ||
219 | u8 GPX_TrackSegmentBegin(GPX_Document_t *doc) |
219 | u8 GPX_TrackSegmentBegin(GPX_Document_t *doc) |
220 | { |
220 | { |
221 | 221 | ||
222 | u8 retvalue = 0; |
222 | u8 retvalue = 0; |
223 | 223 | ||
224 | if(doc->state == GPX_DOC_TRACK_OPENED) |
224 | if(doc->state == GPX_DOC_TRACK_OPENED) |
225 | { |
225 | { |
226 | if(doc->file != NULL) |
226 | if(doc->file != NULL) |
227 | { |
227 | { |
228 | doc->state = GPX_DOC_TRACKSEGMENT_OPENED; |
228 | doc->state = GPX_DOC_TRACKSEGMENT_OPENED; |
229 | fwrite_((void*)GPX_TRACKSEGMENT_HEADER, sizeof(GPX_TRACKSEGMENT_HEADER)-1,1,doc->file); |
229 | fwrite_((void*)GPX_TRACKSEGMENT_HEADER, sizeof(GPX_TRACKSEGMENT_HEADER)-1,1,doc->file); |
230 | retvalue = 1; |
230 | retvalue = 1; |
231 | } |
231 | } |
232 | } |
232 | } |
233 | return(retvalue); |
233 | return(retvalue); |
234 | } |
234 | } |
235 | 235 | ||
236 | //________________________________________________________________________________________________________________________________________ |
236 | //________________________________________________________________________________________________________________________________________ |
237 | // Function: u8 GPX_TrackSegmentEnd(GPX_Document_t *doc); |
237 | // Function: u8 GPX_TrackSegmentEnd(GPX_Document_t *doc); |
238 | // |
238 | // |
239 | // Description: This function ends the tracksegment opened before. |
239 | // Description: This function ends the tracksegment opened before. |
240 | // |
240 | // |
241 | // |
241 | // |
242 | // Returnvalue: '1' if the track segment could be terminated |
242 | // Returnvalue: '1' if the track segment could be terminated |
243 | //________________________________________________________________________________________________________________________________________ |
243 | //________________________________________________________________________________________________________________________________________ |
244 | 244 | ||
245 | u8 GPX_TrackSegmentEnd(GPX_Document_t *doc) |
245 | u8 GPX_TrackSegmentEnd(GPX_Document_t *doc) |
246 | { |
246 | { |
247 | 247 | ||
248 | u8 retvalue = 0; |
248 | u8 retvalue = 0; |
249 | if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED) |
249 | if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED) |
250 | { |
250 | { |
251 | if(doc->file != NULL) |
251 | if(doc->file != NULL) |
252 | { |
252 | { |
253 | doc->state = GPX_DOC_TRACK_OPENED; |
253 | doc->state = GPX_DOC_TRACK_OPENED; |
254 | fwrite_((void*)GPX_TRACKSEGMENT_FOOTER, sizeof(GPX_TRACKSEGMENT_FOOTER)-1,1,doc->file); |
254 | fwrite_((void*)GPX_TRACKSEGMENT_FOOTER, sizeof(GPX_TRACKSEGMENT_FOOTER)-1,1,doc->file); |
255 | retvalue = 1; |
255 | retvalue = 1; |
256 | } |
256 | } |
257 | } |
257 | } |
258 | return(retvalue); |
258 | return(retvalue); |
259 | } |
259 | } |
260 | 260 | ||
261 | //________________________________________________________________________________________________________________________________________ |
261 | //________________________________________________________________________________________________________________________________________ |
262 | // Function: u8 GPX_TrackSegementAddPoint(GPS_Pos_t * pGPS_Position ,GPX_Document_t *doc); |
262 | // Function: u8 GPX_TrackSegementAddPoint(GPS_Pos_t * pGPS_Position ,GPX_Document_t *doc); |
263 | // |
263 | // |
264 | // Description: This function adds a pointof a track segement to the specified document. |
264 | // Description: This function adds a pointof a track segement to the specified document. |
265 | // |
265 | // |
266 | // |
266 | // |
267 | // Returnvalue: '1' if a point was added |
267 | // Returnvalue: '1' if a point was added |
268 | //________________________________________________________________________________________________________________________________________ |
268 | //________________________________________________________________________________________________________________________________________ |
269 | 269 | ||
270 | u8 GPX_TrackSegementAddPoint(GPX_Document_t *doc) |
270 | u8 GPX_TrackSegementAddPoint(GPX_Document_t *doc) |
271 | { |
271 | { |
272 | 272 | ||
273 | u8 retvalue = 0; |
273 | u8 retvalue = 0; |
274 | s8 string[50]; |
274 | s8 string[50]; |
275 | 275 | ||
276 | if(doc == NULL) return(0); |
276 | if(doc == NULL) return(0); |
277 | 277 | ||
278 | if((GPSData.Position.Status != INVALID) && (GPS_HomePosition.Status != INVALID)) |
278 | if((GPSData.Position.Status != INVALID) && (GPS_HomePosition.Status != INVALID)) |
279 | { |
279 | { |
280 | if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED) |
280 | if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED) |
281 | { |
281 | { |
282 | if(doc->file != NULL) |
282 | if(doc->file != NULL) |
283 | { |
283 | { |
284 | s32 i32_1, i32_2; |
284 | s32 i32_1, i32_2; |
285 | s16 i16_1; |
285 | s16 i16_1; |
286 | u8 u8_1, u8_2; |
286 | u8 u8_1, u8_2; |
287 | // write <trkpt> tag |
287 | // write <trkpt> tag |
288 | if(GPSData.Position.Latitude < 0) u8_1 = '-'; |
288 | if(GPSData.Position.Latitude < 0) u8_1 = '-'; |
289 | else u8_1 = '+'; |
289 | else u8_1 = '+'; |
290 | i32_1 = abs(GPSData.Position.Latitude)/10000000L; |
290 | i32_1 = abs(GPSData.Position.Latitude)/10000000L; |
291 | i32_2 = abs(GPSData.Position.Latitude)%10000000L; |
291 | i32_2 = abs(GPSData.Position.Latitude)%10000000L; |
292 | sprintf(string, "<trkpt lat=\"%c%ld.%07ld\" ",u8_1, i32_1, i32_2); |
292 | sprintf(string, "<trkpt lat=\"%c%ld.%07ld\" ",u8_1, i32_1, i32_2); |
293 | fputs_(string, doc->file); |
293 | fputs_(string, doc->file); |
294 | if(GPSData.Position.Longitude < 0) u8_1 = '-'; |
294 | if(GPSData.Position.Longitude < 0) u8_1 = '-'; |
295 | else u8_1 = '+'; |
295 | else u8_1 = '+'; |
296 | i32_1 = abs(GPSData.Position.Longitude)/10000000L; |
296 | i32_1 = abs(GPSData.Position.Longitude)/10000000L; |
297 | i32_2 = abs(GPSData.Position.Longitude)%10000000L; |
297 | i32_2 = abs(GPSData.Position.Longitude)%10000000L; |
298 | sprintf(string, "lon=\"%c%ld.%07ld\">\r\n",u8_1, i32_1, i32_2); |
298 | sprintf(string, "lon=\"%c%ld.%07ld\">\r\n",u8_1, i32_1, i32_2); |
299 | fputs_(string, doc->file); |
299 | fputs_(string, doc->file); |
300 | // write <ele> taga |
300 | // write <ele> taga |
301 | i32_2 = GPSData.Position.Altitude - GPS_HomePosition.Altitude; |
301 | i32_2 = GPSData.Position.Altitude - GPS_HomePosition.Altitude; |
302 | if(i32_2 < 0) i32_2 = 0; // avoid negative altitudes in log |
302 | if(i32_2 < 0) i32_2 = 0; // avoid negative altitudes in log |
303 | i32_1 = i32_2/1000L; |
303 | i32_1 = i32_2/1000L; |
304 | i32_2 = i32_2%1000L; |
304 | i32_2 = i32_2%1000L; |
305 | sprintf(string,"<ele>%ld.%03ld</ele>\r\n",i32_1, i32_2); |
305 | sprintf(string,"<ele>%ld.%03ld</ele>\r\n",i32_1, i32_2); |
306 | fputs_(string, doc->file); |
306 | fputs_(string, doc->file); |
307 | // write <time> tag only at a resolution of one second |
307 | // write <time> tag only at a resolution of one second |
308 | sprintf(string, "<time>%04d-%02d-%02dT%02d:%02d:%02dZ</time>\r\n",SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour, SystemTime.Min, SystemTime.Sec); |
308 | sprintf(string, "<time>%04d-%02d-%02dT%02d:%02d:%02dZ</time>\r\n",SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour, SystemTime.Min, SystemTime.Sec); |
309 | fputs_(string, doc->file); |
309 | fputs_(string, doc->file); |
310 | // write <sat> tag |
310 | // write <sat> tag |
311 | sprintf(string, "<sat>%d</sat>\r\n", NaviData.SatsInUse); |
311 | sprintf(string, "<sat>%d</sat>\r\n", NaviData.SatsInUse); |
312 | fputs_(string, doc->file); |
312 | fputs_(string, doc->file); |
313 | // todo: add <extensions> tag with additional data to be logged |
313 | // todo: add <extensions> tag with additional data to be logged |
314 | sprintf(string, "<extensions>\r\n"); |
314 | sprintf(string, "<extensions>\r\n"); |
315 | fputs_(string, doc->file); |
315 | fputs_(string, doc->file); |
- | 316 | // Altimeter according to air pressure |
|
- | 317 | sprintf(string, "<Altimeter>%d</Altimeter>\r\n", NaviData.Altimeter); |
|
316 | // Course in deg |
318 | // Course in deg |
317 | i16_1 = GPSData.Heading/100000L; |
319 | i16_1 = GPSData.Heading/100000L; |
318 | sprintf(string, "<Course>%03d</Course>\r\n", i16_1); |
320 | sprintf(string, "<Course>%03d</Course>\r\n", i16_1); |
319 | fputs_(string, doc->file); |
321 | fputs_(string, doc->file); |
320 | // Ground Speed in cm/s |
322 | // Ground Speed in cm/s |
321 | sprintf(string, "<GroundSpeed>%d</GroundSpeed>\r\n", NaviData.GroundSpeed); |
323 | sprintf(string, "<GroundSpeed>%d</GroundSpeed>\r\n", NaviData.GroundSpeed); |
322 | fputs_(string, doc->file); |
324 | fputs_(string, doc->file); |
323 | // Ground Speed in cm/s |
325 | // Ground Speed in cm/s |
324 | sprintf(string, "<FlightTime>%d</FlightTime>\r\n", NaviData.FlyingTime); |
326 | sprintf(string, "<FlightTime>%d</FlightTime>\r\n", NaviData.FlyingTime); |
325 | fputs_(string, doc->file); |
327 | fputs_(string, doc->file); |
326 | // Ubat |
328 | // Ubat |
327 | u8_1 = NaviData.UBat / 10; |
329 | u8_1 = NaviData.UBat / 10; |
328 | u8_2 = NaviData.UBat % 10; |
330 | u8_2 = NaviData.UBat % 10; |
329 | sprintf(string, "<Voltage>%d.%01d</Voltage>\r\n", u8_1, u8_2); |
331 | sprintf(string, "<Voltage>%d.%01d</Voltage>\r\n", u8_1, u8_2); |
330 | fputs_(string, doc->file); |
332 | fputs_(string, doc->file); |
331 | // RC Quality |
333 | // RC Quality |
332 | sprintf(string, "<RCQuality>%d</RCQuality>\r\n", FC.RC_Quality); |
334 | sprintf(string, "<RCQuality>%d</RCQuality>\r\n", FC.RC_Quality); |
333 | fputs_(string, doc->file); |
335 | fputs_(string, doc->file); |
- | 336 | // RC Received Signal Strength Indication |
|
- | 337 | sprintf(string, "<RCRSSI>%d</RCRSSI>\r\n", FC.RC_RSSI); |
|
- | 338 | fputs_(string, doc->file); |
|
334 | // Compassind deg |
339 | // Compassind deg |
335 | i16_1 = FromFlightCtrl.GyroHeading / 10; |
340 | i16_1 = FromFlightCtrl.GyroHeading / 10; |
336 | sprintf(string, "<Compass>%03d</Compass>\r\n", i16_1); |
341 | sprintf(string, "<Compass>%03d</Compass>\r\n", i16_1); |
337 | fputs_(string, doc->file); |
342 | fputs_(string, doc->file); |
338 | // Nick Angle ind deg |
343 | // Nick Angle ind deg |
339 | sprintf(string, "<NickAngle>%03d</NickAngle>\r\n", NaviData.AngleNick); |
344 | sprintf(string, "<NickAngle>%03d</NickAngle>\r\n", NaviData.AngleNick); |
340 | fputs_(string, doc->file); |
345 | fputs_(string, doc->file); |
341 | // Roll Angle in deg |
346 | // Roll Angle in deg |
342 | sprintf(string, "<RollAngle>%03d</RollAngle>\r\n", NaviData.AngleRoll); |
347 | sprintf(string, "<RollAngle>%03d</RollAngle>\r\n", NaviData.AngleRoll); |
343 | fputs_(string, doc->file); |
348 | fputs_(string, doc->file); |
344 | // NC Mode (contains the status) |
349 | // NC Mode (contains the status) |
345 | sprintf(string, "<NCFlag>%02X</NCFlag>\r\n", NCFlags); |
350 | sprintf(string, "<NCFlag>%02X</NCFlag>\r\n", NCFlags); |
346 | fputs_(string, doc->file); |
351 | fputs_(string, doc->file); |
347 | // Target Bearing in deg |
352 | // Target Bearing in deg |
348 | sprintf(string, "<TargetBearing>%03d</TargetBearing>\r\n", NaviData.TargetPositionDeviation.Bearing); |
353 | sprintf(string, "<TargetBearing>%03d</TargetBearing>\r\n", NaviData.TargetPositionDeviation.Bearing); |
349 | fputs_(string, doc->file); |
354 | fputs_(string, doc->file); |
350 | // Target Distance in dm |
355 | // Target Distance in dm |
351 | sprintf(string, "<TargetDistance>%d</TargetDistance>\r\n", NaviData.TargetPositionDeviation.Distance); |
356 | sprintf(string, "<TargetDistance>%d</TargetDistance>\r\n", NaviData.TargetPositionDeviation.Distance); |
352 | fputs_(string, doc->file); |
357 | fputs_(string, doc->file); |
353 | // RC Sticks as Nick/Roll/Yaw |
358 | // RC Sticks as Nick/Roll/Yaw |
354 | sprintf(string, "<RCSticks>%d, %d, %d</RCSticks>\r\n", FC.StickNick,FC.StickRoll, FC.StickYaw); |
359 | sprintf(string, "<RCSticks>%d, %d, %d</RCSticks>\r\n", FC.StickNick,FC.StickRoll, FC.StickYaw); |
355 | fputs_(string, doc->file); |
360 | fputs_(string, doc->file); |
356 | // GPS Sticks as Nick/Roll/Yaw |
361 | // GPS Sticks as Nick/Roll/Yaw |
357 | sprintf(string, "<GPSSticks>%d, %d, %d</GPSSticks>\r\n", GPS_Stick.Nick, GPS_Stick.Roll, GPS_Stick.Yaw); |
362 | sprintf(string, "<GPSSticks>%d, %d, %d</GPSSticks>\r\n", GPS_Stick.Nick, GPS_Stick.Roll, GPS_Stick.Yaw); |
358 | fputs_(string, doc->file); |
363 | fputs_(string, doc->file); |
359 | 364 | ||
360 | // eof extensions |
365 | // eof extensions |
361 | sprintf(string, "</extensions>\r\n"); |
366 | sprintf(string, "</extensions>\r\n"); |
362 | fputs_(string, doc->file); |
367 | fputs_(string, doc->file); |
363 | sprintf(string, "</trkpt>\r\n"); |
368 | sprintf(string, "</trkpt>\r\n"); |
364 | fputs_(string, doc->file); |
369 | fputs_(string, doc->file); |
365 | retvalue = 1; |
370 | retvalue = 1; |
366 | } |
371 | } |
367 | } |
372 | } |
368 | } |
373 | } |
369 | return(retvalue); |
374 | return(retvalue); |
370 | } |
375 | } |
371 | 376 | ||
372 | //________________________________________________________________________________________________________________________________________ |
377 | //________________________________________________________________________________________________________________________________________ |
373 | // Function: u8 KML_LoggGPSCoordinates(gps_data_t *, KML_Document_t *) |
378 | // Function: u8 KML_LoggGPSCoordinates(gps_data_t *, KML_Document_t *) |
374 | // |
379 | // |
375 | // Description: This function opens and adds gpscoordinates to an GPX-Document. The document will be opened, if not already done |
380 | // Description: This function opens and adds gpscoordinates to an GPX-Document. The document will be opened, if not already done |
376 | // |
381 | // |
377 | // |
382 | // |
378 | // Returnvalue: '1' if an gps coordinate was logged |
383 | // Returnvalue: '1' if an gps coordinate was logged |
379 | //________________________________________________________________________________________________________________________________________ |
384 | //________________________________________________________________________________________________________________________________________ |
380 | 385 | ||
381 | u8 GPX_LoggGPSCoordinates(GPX_Document_t *doc) |
386 | u8 GPX_LoggGPSCoordinates(GPX_Document_t *doc) |
382 | { |
387 | { |
383 | u8 retval = 0; |
388 | u8 retval = 0; |
384 | while(doc->state != GPX_DOC_TRACKSEGMENT_OPENED) // automatic create document with default filename on the card. |
389 | while(doc->state != GPX_DOC_TRACKSEGMENT_OPENED) // automatic create document with default filename on the card. |
385 | { |
390 | { |
386 | switch(doc->state) |
391 | switch(doc->state) |
387 | { |
392 | { |
388 | case GPX_DOC_CLOSED: // document hasn't been opened yet therefore it will be initialized automatically |
393 | case GPX_DOC_CLOSED: // document hasn't been opened yet therefore it will be initialized automatically |
389 | retval = GPX_DocumentOpen("default.gpx",doc); // open the gpx-document with a standardname. |
394 | retval = GPX_DocumentOpen("default.gpx",doc); // open the gpx-document with a standardname. |
390 | break; |
395 | break; |
391 | 396 | ||
392 | case GPX_DOC_OPENED: // if a document has been opened before but no track exists: |
397 | case GPX_DOC_OPENED: // if a document has been opened before but no track exists: |
393 | retval = GPX_TrackBegin(doc); |
398 | retval = GPX_TrackBegin(doc); |
394 | break; |
399 | break; |
395 | 400 | ||
396 | case GPX_DOC_TRACK_OPENED: // add tracksegement to the track |
401 | case GPX_DOC_TRACK_OPENED: // add tracksegement to the track |
397 | retval = GPX_TrackSegmentBegin(doc); |
402 | retval = GPX_TrackSegmentBegin(doc); |
398 | break; |
403 | break; |
399 | 404 | ||
400 | default: |
405 | default: |
401 | retval = 0; |
406 | retval = 0; |
402 | break; |
407 | break; |
403 | 408 | ||
404 | } |
409 | } |
405 | if(retval != 1) return(retval); // stop on error |
410 | if(retval != 1) return(retval); // stop on error |
406 | } |
411 | } |
407 | 412 | ||
408 | if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED) // if the document was opened add coordinates to the document. |
413 | if(doc->state == GPX_DOC_TRACKSEGMENT_OPENED) // if the document was opened add coordinates to the document. |
409 | { |
414 | { |
410 | retval = GPX_TrackSegementAddPoint(doc); // add a track segment point |
415 | retval = GPX_TrackSegementAddPoint(doc); // add a track segment point |
411 | } |
416 | } |
412 | return(retval); |
417 | return(retval); |
413 | } |
418 | } |
414 | 419 | ||
415 | 420 |