/*#######################################################################################*/
/* !!! 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"
#include "camctrl.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
);
if(FromLaserCtrl.
LaserStatus)
{
sprintf(string
, ";Laser[m]");
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
);
// laser connected?
if(FromLaserCtrl.
LaserStatus)
{
sprintf(string
,";%d.%02d",FromLaserCtrl.
Distance/100,abs(FromLaserCtrl.
Distance%100));
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
;
}