0,0 → 1,631 |
/*#######################################################################################*/ |
/* !!! THIS IS NOT FREE SOFTWARE !!! */ |
/*#######################################################################################*/ |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + www.MikroKopter.com |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Software Nutzungsbedingungen (english version: see below) |
// + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt - |
// + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den |
// + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool |
// + - nachfolgend Software genannt - nur für private Zwecke zu nutzen. |
// + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig. |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im |
// + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu. |
// + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie |
// + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden. |
// + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren |
// + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt. |
// + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren |
// + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand |
// + des Mitverschuldens offen. |
// + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet. |
// + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt. |
// + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern. |
// + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang |
// + und auf Grundlage der Datenschutzvorschriften erhebt, speichert, verarbeitet und, sofern notwendig, an Dritte übermittelt. |
// + *) Die räumliche Nutzung bezieht sich nur auf den Einsatzort, nicht auf die Reichweite der programmierten Software. |
// + #### ENDE DER NUTZUNGSBEDINGUNGEN ####' |
// + Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar. |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Software LICENSING TERMS |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor - |
// + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware |
// + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*. |
// + The Software may only be used with the Licensor's products. |
// + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this |
// + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this |
// + agreement shall be the property of the Licensor. |
// + The information contained in the Software copyright notices, trademarks, other legal reservations, serial numbers and other |
// + features that can be used to identify the program may not be altered or defaced by the customer. |
// + The customer shall be responsible for taking reasonable precautions |
// + for the safe use of the Software. The customer shall test the Software thoroughly regarding its suitability for the |
// + intended purpose before implementing it for actual operation. The Licensor's liability shall be limited to the extent of typical and |
// + foreseeable damage to the extent permitted by law, notwithstanding statutory liability for bodily injury and product |
// + liability. However, the Licensor shall be entitled to the defense of contributory negligence. |
// + The customer will take adequate precautions in the case, that the software is not working properly. The customer will test |
// + the software for his purpose before any operational usage. The customer will backup his data before using the software. |
// + The customer understands that the Licensor collects, stores and processes, and, where required, forwards, customer data |
// + to third parties to the extent necessary for executing the agreement, subject to applicable data protection and privacy regulations. |
// + *) The territory aspect only refers to the place where the Software is used, not its programmed range. |
// + #### END OF LICENSING TERMS #### |
// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de. |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
#include <stdio.h> |
#include <stdlib.h> |
#include "91x_lib.h" |
#include "main.h" |
#include "timer1.h" |
#include "timer2.h" |
#include "uart1.h" |
#include "triggerlog.h" |
#include "gpx.h" |
#include "ssc.h" |
#include "settings.h" |
#include "led.h" |
#include "logging.h" |
#include "timer1.h" |
#include "gps.h" |
#include "spi_slave.h" |
|
u16 Logged_TRIG_Counter = 0; |
u16 TRIG_Filenum = 0; |
u8 BlitzSchuhConnected = 1; |
|
TrigLog_t TrigLogging; |
|
void TriggerInput(void) // triggerinput on IO1 |
{ |
TrigLogging.Longitude = GPSData.Position.Longitude; |
TrigLogging.Latitude = GPSData.Position.Latitude; |
TrigLogging.Count++; |
if(BlitzSchuhConnected) TrigLogging.CountExternal++; |
else TrigLogging.CountExternal = 0; |
TrigLogging.AltiBaro = NaviData.Altimeter_5cm * 5; // in cm |
TrigLogging.AltiGPS = GPSData.Position.Altitude; |
TrigLogging.ShutterCounter = NaviData_Volatile.ShutterCounter; |
|
TrigLogging.Hour = SystemTime.Hour; |
TrigLogging.Min = SystemTime.Min; |
TrigLogging.Sec = SystemTime.Sec; |
TrigLogging.mSec = SystemTime.mSec; |
TrigLogging.ServoControlNick = ServoParams.NickControl; |
TrigLogging.ServoControlPoi = POI_KameraNick; |
if(SimulationFlags) TrigLogging.Yaw = CompassSetpointCorrected; |
else TrigLogging.Yaw = GyroCompassCorrected; |
TrigLogging.NewData++; |
} |
|
const s8 TRIG_DOCUMENT_FOOTER[] = |
{ |
"\r\n" |
"#Triggerlogfile closed\r\n" |
}; |
|
//________________________________________________________________________________________________________________________________________ |
// Function: TRIG_DocumentInit(TRIG_Document_t *) |
// |
// Description: This function initializes the kml-document for further use. |
// |
// |
// Returnvalue: '1' if document was initialized |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_DocumentInit(TRIG_Document_t *doc) |
{ |
doc->state = TRIG_DOC_CLOSED; // state of the kml-document |
doc->file = NULL; |
return(1); |
} |
|
|
//________________________________________________________________________________________________________________________________________ |
// Function: DocumentClose(TRIG_Document_t *doc); |
// |
// Description: This function closes the document specified by doc. |
// |
// |
// Returnvalue: '1' if the KML- file could be closed. |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_DocumentClose(TRIG_Document_t *doc) |
{ |
|
u8 retvalue = 1; |
|
if(doc == NULL) return(0); |
|
while(doc->state != TRIG_DOC_CLOSED) // close linestring, placemark and document before closing the file on the memorycard |
{ |
switch(doc->state) |
{ |
case TRIG_DOC_LINESTRING_OPENED: |
TRIG_LineStringEnd(doc); // write terminating tag to end linestring. |
break; |
|
case TRIG_DOC_PLACEMARK_OPENED: // write terminating tag to close placemark. |
TRIG_PlaceMarkClose(doc); |
break; |
|
case TRIG_DOC_OPENED: // close the file on the memorycard |
if(doc->file != NULL) |
{ |
fwrite_((void*)TRIG_DOCUMENT_FOOTER, sizeof(TRIG_DOCUMENT_FOOTER)-1,1,doc->file); // write the KML- footer to the document. |
fclose_(doc->file); |
retvalue = 1; |
} |
doc->state = TRIG_DOC_CLOSED; |
break; |
|
default: |
doc->state = TRIG_DOC_CLOSED; |
break; |
|
} |
} |
return(retvalue); |
} |
|
//________________________________________________________________________________________________________________________________________ |
// Function: u8 TRIG_PlaceMarkOpen(TRIG_Document_t *doc); |
// |
// Description: This function adds a placemark to the document. |
// |
// |
// Returnvalue: '1' if the PlaceMark could be opened |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_PlaceMarkOpen(TRIG_Document_t *doc) |
{ |
u8 retvalue = 0; |
if(doc->state == TRIG_DOC_OPENED) |
{ |
if(doc->file != NULL) |
{ |
doc->state = TRIG_DOC_PLACEMARK_OPENED; |
retvalue = 1; |
// fwrite_((void*)TRIG_PLACEMARK_HEADER, sizeof(TRIG_PLACEMARK_HEADER)-1,1,doc->file); |
} |
} |
return(retvalue); |
} |
|
//________________________________________________________________________________________________________________________________________ |
// Function: u8 PlaceMarkClose(TRIG_PlaceMark_t *place, File *file); |
// |
// Description: This function ends the placemark opened before. |
// |
// |
// Returnvalue: 1' if the PlaceMark could be closed |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_PlaceMarkClose(TRIG_Document_t *doc) |
{ |
|
u8 retvalue = 0; // close the Placemark-tag of the corosponding document. |
|
if(doc->state == TRIG_DOC_PLACEMARK_OPENED) |
{ |
if(doc->file != NULL) |
{ |
doc->state = TRIG_DOC_OPENED; |
// fwrite_((void*)TRIG_PLACEMARK_FOOTER, sizeof(TRIG_PLACEMARK_FOOTER)-1,1,doc->file); |
retvalue = 1; |
} |
} |
|
return(retvalue); |
} |
|
//________________________________________________________________________________________________________________________________________ |
// Function: u8 LineStringBegin(TRIG_Document_t *doc); |
// |
// Description: This function ends the placemark opened before. |
// |
// |
// Returnvalue: '1' if the LineString could be started |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_LineStringBegin(TRIG_Document_t *doc) |
{ |
|
u8 retvalue = 0; |
|
if(doc->state == TRIG_DOC_PLACEMARK_OPENED) |
{ |
if(doc->file != NULL) |
{ |
doc->state = TRIG_DOC_LINESTRING_OPENED; |
// fwrite_((void*)TRIG_LINESTRING_HEADER, sizeof(TRIG_LINESTRING_HEADER)-1,1,doc->file); |
Logged_TRIG_Counter = 0; |
TrigLogging.NewData = 0; |
retvalue = 1; |
} |
} |
return(retvalue); |
} |
|
//________________________________________________________________________________________________________________________________________ |
// Function: u8 TRIG_LineStringEnd(TRIG_Document_t *doc) |
// |
// Description: This function ends the placemark opened before. |
// |
// |
// Returnvalue: '1' if the LineString could be terminated |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_LineStringEnd(TRIG_Document_t *doc) |
{ |
u8 retvalue = 0; |
if(doc->state == TRIG_DOC_LINESTRING_OPENED) |
{ |
if(doc->file != NULL) |
{ |
doc->state = TRIG_DOC_PLACEMARK_OPENED; |
// fwrite_((void*)TRIG_LINESTRING_FOOTER, sizeof(TRIG_LINESTRING_FOOTER)-1,1,doc->file); |
retvalue = 1; |
} |
} |
return(retvalue); |
} |
|
//________________________________________________________________________________________________________________________________________ |
// Function: TRIG_Document_Open(void); |
// |
// Description: This function opens a new KML- document with the specified name and creates the document header within the file. |
// |
// |
// Returnvalue: '1' if the KML- file could be created. |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_DocumentOpen(s8 *name, TRIG_Document_t *doc) |
{ |
|
u8 retvalue = 0; |
s8 string[150]; |
|
if(doc == NULL) return(0); |
|
TRIG_DocumentInit(doc); // intialize the document with resetvalues |
doc->file = fopen_(name,'a'); // open a new file with the specified filename on the memorycard. |
|
if(doc->file != NULL) // could the file be opened? |
{ |
retvalue = 1; // the document could be created on the drive. |
doc->state = TRIG_DOC_OPENED; // change document state to opened. At next a placemark has to be opened. |
sprintf(string, "#Counter;Time;Latitude;Longitude;GPSAltitude[m](raw);BaroAltitude[m];Compass[deg];ServoSetpoint(raw);ServoPoi[deg]"); |
fputs_(string, doc->file); |
sprintf(string, "\r\n#%4i.%02i.%02i Nr:%i (%02i%02i%02i%02i.GPX)", SystemTime.Year, SystemTime.Month, SystemTime.Day, TRIG_Filenum, SystemTime.Year%100, SystemTime.Month, SystemTime.Day, GPX_Filenum); |
fputs_(string, doc->file); |
if(SimulationFlags) { sprintf(string, " SIMULATED"); fputs_(string, doc->file);}; |
if(BlitzSchuhConnected){ sprintf(string, "\r\n#External hotshoe sensor connected"); fputs_(string, doc->file);}; |
} |
return(retvalue); |
} |
|
|
//________________________________________________________________________________________________________________________________________ |
// Function: u8 LineStringAddPoint(gps_data_t, TRIG_Document_t *doc) |
// |
// Description: This function adds a point to the specified document. |
// |
// |
// Returnvalue: '1' if a ppoint was added could be started |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_LineStringAddPoint(TRIG_Document_t *doc) |
{ |
|
u8 retvalue = 0; |
s8 string[70]; |
s32 rel_altitude = 0; |
|
if(doc == NULL) return(0); |
|
if(GPSData.Position.Status != INVALID) |
{ |
if(doc->state == TRIG_DOC_LINESTRING_OPENED) |
{ |
if(doc->file != NULL) |
{ |
s32 i1, i2; |
u8 sign; |
// Counter |
sprintf(string,"\r\n%d",TrigLogging.Count); |
fputs_(string, doc->file); |
// Time |
sprintf(string, ";%04d-%02d-%02dT%02d:%02d:%02d.%dZ",SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour, SystemTime.Min, SystemTime.Sec,SystemTime.mSec/100); |
fputs_(string, doc->file); |
// Position |
if(TrigLogging.Latitude < 0) sign = '-'; |
else sign = '+'; |
i1 = abs(TrigLogging.Latitude)/10000000L; |
i2 = abs(TrigLogging.Latitude)%10000000L; |
sprintf(string,";%c%ld.%07ld",sign, i1, i2); |
fputs_(string, doc->file); |
|
if(TrigLogging.Longitude < 0) sign = '-'; |
else sign = '+'; |
i1 = abs(TrigLogging.Longitude)/10000000L; |
i2 = abs(TrigLogging.Longitude)%10000000L; |
sprintf(string,";%c%ld.%07ld",sign, i1, i2); |
fputs_(string, doc->file); |
// calculate relative altitude with respect to the altitude of the home position |
// Altitude GPS |
rel_altitude = TrigLogging.AltiGPS;// - NaviData.HomePosition.Altitude; |
// if(rel_altitude < 0) rel_altitude = 0; // avoid negative altitudes in log |
i1 = rel_altitude/1000L; |
i2 = rel_altitude%1000L; |
sprintf(string,";%ld.%03ld",i1, labs(i2)); |
fputs_(string, doc->file); |
// Altitude Baro |
sprintf(string,";%ld.%02d",TrigLogging.AltiBaro/100,abs(TrigLogging.AltiBaro%100)); |
fputs_(string, doc->file); |
// Yaw angle |
sprintf(string,";%d.%d",TrigLogging.Yaw/10,abs(TrigLogging.Yaw%10)); |
fputs_(string, doc->file); |
// ServoSet; ServoPoi |
sprintf(string,";%d;%d.%d",TrigLogging.ServoControlNick,TrigLogging.ServoControlPoi/10,abs(TrigLogging.ServoControlPoi%10)); |
fputs_(string, doc->file); |
|
Logged_TRIG_Counter++; |
retvalue = 1; |
} |
} |
} |
else |
{ |
if(doc->state == TRIG_DOC_LINESTRING_OPENED) |
{ |
if(doc->file != NULL) |
{ |
sprintf(string,"\r\n"); |
fputs_(string, doc->file); |
Logged_TRIG_Counter++; |
retvalue = 1; |
} |
} |
} |
return(retvalue); |
} |
|
//________________________________________________________________________________________________________________________________________ |
// Function: u8 TRIG_LoggGPSCoordinates(gps_data_t *, TRIG_Document_t *) |
// |
// Description: This function opens adds gpscoordinates to an KML-Document. The document will be opened, if not already done |
// |
// |
// Returnvalue: '1' if an gps coordinate was logged |
//________________________________________________________________________________________________________________________________________ |
|
u8 TRIG_LoggGPSCoordinates(TRIG_Document_t *doc) |
{ |
u8 retval = 0; |
while(doc->state != TRIG_DOC_LINESTRING_OPENED) // automatic create document with default filename on the card. |
{ |
switch(doc->state) |
{ |
case TRIG_DOC_CLOSED: // document hasn't been opened yet therefore it will be initialized automatically |
// retval = TRIG_DocumentOpen("default.kml",doc); // open the kml-document with a standardname. |
break; |
|
case TRIG_DOC_OPENED: // if a document has been opened before but no placemark exists: |
retval = TRIG_PlaceMarkOpen(doc); |
break; |
|
case TRIG_DOC_PLACEMARK_OPENED: // add linestring to the placemark |
retval = TRIG_LineStringBegin(doc); |
break; |
|
default: |
retval = 0; |
break; |
|
} |
if(retval != 1) return(retval); // stop on error |
} |
|
if(doc->state == TRIG_DOC_LINESTRING_OPENED) // if the document was opened add coordinates to the document. |
{ |
retval = TRIG_LineStringAddPoint(doc); |
} |
return(retval); |
} |
|
|
|
//---------------------------------------------------------------------------------------------------- |
s8* GenerateTriggLogFileName(void) |
{ |
static u16 filenum = 0; // file name counter |
static s8 filename[40]; |
|
static DateTime_t LastTime = {0,0,0,0,0,0,0,0}; |
if(filenum < GPX_Filenum) filenum = GPX_Filenum; |
if(SystemTime.Valid) |
{ |
// if the day has been changed |
if((LastTime.Year != SystemTime.Year) || (LastTime.Month != SystemTime.Month) || (LastTime.Day != SystemTime.Day)) |
{ |
LastTime.Year = SystemTime.Year; |
LastTime.Month = SystemTime.Month; |
LastTime.Day = SystemTime.Day; |
LastTime.Valid = 1; |
filenum = 0; // reset file counter |
} |
if(!(SimulationFlags & SIMULATION_ACTIVE)) |
{ |
if(filenum < 100) sprintf(filename, "/LOG/%04i%02i%02i/GPX/%02i%02i%02i%02i.TXT", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Year % 100, SystemTime.Month, SystemTime.Day, filenum); |
else sprintf(filename, "/LOG/%04i%02i%02i/GPX/GPS%05i.TXT", SystemTime.Year, SystemTime.Month, SystemTime.Day, filenum); |
} |
else |
{ |
if(filenum < 100 && SystemTime.Year > 2000) sprintf(filename, "/SIMULATE/%04i%02i%02i/GPX/S%i%02i%02i%02i.TXT", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Year % 10, SystemTime.Month, SystemTime.Day, filenum); |
else sprintf(filename, "/SIMULATE/%04i%02i%02i/GPX/SIM%05i.TXT", SystemTime.Year, SystemTime.Month, SystemTime.Day, filenum); |
} |
TRIG_Filenum = filenum; |
filenum++; |
return filename; |
} |
else return NULL; |
} |
|
|
|
//---------------------------------------------------------------------------------------------------- |
// logs the current gps position to a csv file |
logfilestate_t LoggingTrigger(u32 LogDelay) |
{ |
static logfilestate_t logfilestate = LOGFILE_IDLE; // the current logfilestate |
static s8* logfilename = NULL; // the pointer to the logfilename |
static u32 logtimer = 0, flushtimer = 0; // the log update timer |
static TRIG_Document_t logfile; // the logfilehandle |
static u32 appendtimer = 0; // the log update timer |
static u8 logging_active = 0; |
|
// initialize if LogDelay is zero |
if(!LogDelay) |
{ |
switch(logfilestate) |
{ |
case LOGFILE_OPENED: |
TRIG_DocumentClose(&logfile); // try to close it |
break; |
default: |
break; |
} |
logfilestate = LOGFILE_IDLE; |
logfilename = NULL; |
TRIG_DocumentInit(&logfile); |
logtimer = SetDelay(0); // set logtimer to now |
return logfilestate; |
} |
// no init |
if(CheckDelay(logtimer) || (TrigLogging.NewData && logging_active)) |
{ |
logtimer = SetDelay(LogDelay); // standard interval |
|
if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) |
{ |
logging_active = 1; |
appendtimer = SetDelay(APPEND_LOG_TIME_MS); |
} |
else |
{ |
if(CheckDelay(appendtimer)) logging_active = 0; |
} |
|
if(logging_active) |
{ |
switch(logfilestate) |
{ |
case LOGFILE_IDLE: |
case LOGFILE_CLOSED: |
if(GPX_logging_active == 2) // start after GPX-Log |
{ |
logfilestate = LOGFILE_START; |
} |
break; |
case LOGFILE_START: |
// find unused logfile name |
do |
{ // try to generate a new logfile name |
logfilename = GenerateTriggLogFileName(); |
}while((logfilename != NULL) && fexist_(logfilename)); |
// if logfilename exist |
if(logfilename != NULL) |
{ |
// try to create the log file |
if(TRIG_DocumentOpen(logfilename, &logfile)) |
{ |
flushtimer = SetDelay(LOG_FLUSH_INTERVAL); |
logfilestate = LOGFILE_OPENED; // goto next step |
UART1_PutString("\r\nOpening trigger-file:"); |
UART1_PutString(logfilename); |
UART1_PutString("\r\n"); |
TrigLogging.NewData = 0; |
TrigLogging.Count = 0; |
TrigLogging.CountExternal = 0; |
fflush_(logfile.file); |
} |
else // could not be openend |
{ |
logfilestate = LOGFILE_ERROR; |
UART1_PutString("\r\nError opening trigger-file: "); |
UART1_PutString(logfilename); |
UART1_PutString("\r\n"); |
logtimer = SetDelay(10); // try again in open logfile in 10 mili sec |
SD_LoggingError = 1; |
} |
} |
else |
{ |
logfilestate = LOGFILE_ERROR; |
UART1_PutString("\r\nError getting free trigger-file name\r\n"); |
SD_LoggingError = 2; |
} |
// else retry in next loop |
break; |
case LOGFILE_OPENED: |
// append new gps log data |
if(TrigLogging.NewData) |
{ |
TrigLogging.NewData--; |
if((GPSData.Status != INVALID))// && (GPSData.Flags & FLAG_GPSFIXOK) && (GPSData.SatFix == SATFIX_3D)) |
{ |
if(!TRIG_LoggGPSCoordinates(&logfile)) |
{ // error logging data |
UART1_PutString("\r\nError logging to trigger-file\r\n"); |
SD_LoggingError = 3; |
TRIG_DocumentClose(&logfile); |
logfilestate = LOGFILE_ERROR; |
TrigLogging.NewData = 0; |
} |
else // sucessfully logged |
{ |
SD_LoggingError = 0; |
// if(CheckDelay(flushtimer)) |
{ |
// flushtimer = SetDelay(LOG_FLUSH_INTERVAL); |
fflush_(logfile.file); |
} |
} |
|
} |
} |
break; |
|
case LOGFILE_ERROR: |
break; |
|
default: |
logfilestate = LOGFILE_IDLE; |
break; |
} |
} // EOF motors are not running |
else // model is not flying |
{ // close log file if opened |
if(logfilestate == LOGFILE_OPENED) |
{ |
if(TRIG_DocumentClose(&logfile)) |
{ |
UART1_PutString("\r\nClosing trigger-file\r\n"); |
logfilestate = LOGFILE_CLOSED; |
} |
else // could not be closed |
{ |
UART1_PutString("\r\nError closing trigger-file\r\n"); |
SD_LoggingError = 4; |
logfilestate = LOGFILE_ERROR; |
} |
} |
} //EOF motors are not running |
} // EOF Check LogTimer |
|
return logfilestate; |
} |
|
|
|