GPStracker/soft/main.c

/*---------------------------------------------------------------*
 * Automotive GPS logger                       (C)ChaN, 2014     *
 * Modified                                       k4be, 2022     *
 *---------------------------------------------------------------*/

#include "main.h"

/*FUSES = {0xFF, 0x11, 0xFE};*/		/* ATmega644PA fuses: Low, High, Extended.
This is the fuse settings for this project. The fuse bits will be included
in the output hex file with program code. However some old flash programmers
cannot load the fuse bits from hex file. If it is the case, remove this line
and use these values to program the fuse bits. */

volatile struct system_s System;
FATFS Fatfs;				/* File system object for each logical drive */
FIL gps_log;				/* File object */
FIL system_log;				/* System log file */
char Line[100];				/* Line buffer */
time_t utc;					/* current time */
struct location_s location;
volatile unsigned long int uptime_ms; /* milliseconds since MCU startup, for the system log */
static unsigned int io_max_ms; /* longest single SD f_write()/f_sync() duration since the last status line, ms */

/*
 * Reset cause: this board is always started via Optiboot, not a fresh MCU
 * reset straight into main(). Optiboot reads MCUSR at its own entry, clears
 * only WDRF (to avoid looping on its own watchdog-based re-entry), and passes
 * the *original* MCUSR value to the application in register r2 before jumping
 * to address 0 - see optiboot.c ("save the reset flags in the designated
 * register ... by putting code in .init0 ... to save R2 to a global
 * variable"). By the time main() runs, the real MCUSR register no longer
 * reflects the actual reset cause, so it must be read out of r2 instead, and
 * that has to happen in .init0 - the very first code executed - before
 * anything else can clobber the register.
 */
volatile unsigned char reset_cause __attribute__((section(".noinit")));
void get_mcusr_from_r2(void) __attribute__((naked, used, section(".init0")));
void get_mcusr_from_r2(void) {
	__asm__ __volatile__ ("mov %0, r2\n" : "=r" (reset_cause) :);
}

/* Disable the watchdog as early as possible, and fall back to reading MCUSR
 * directly if this image is ever flashed straight over ISP, bypassing
 * Optiboot: r2 is only ever populated by Optiboot's own app-start path (see
 * above), so if it came back 0, no bootloader ran and r2 just holds whatever
 * was left in it at power-on - in that case MCUSR itself still holds the
 * real reset cause (nothing has cleared it yet), and needs disabling the
 * watchdog ourselves, since Optiboot isn't there to have done it already.
 * This runs in .init3, after the stack pointer is set up in .init2, so it
 * can be plain C rather than hand-written asm. */
void wdt_disable_early(void) __attribute__((naked, used, section(".init3")));
void wdt_disable_early(void) {
	if (!reset_cause && MCUSR)
		reset_cause = MCUSR; /* no bootloader ran: fall back to MCUSR directly, before it's cleared below */
	MCUSR = 0;
	wdt_disable();
}

/*
 * Stack headroom (AVR121 "StackPaint" pattern): fill all RAM between the end
 * of .bss/.noinit and the top of RAM with a known byte as early as possible
 * (.init1, before the stack pointer itself is set up in .init2), then later
 * count how many bytes of that pattern are still untouched. That count can
 * only shrink over the session, as the deepest interrupt/call nesting grows,
 * so it is a running record of the worst-case stack headroom seen so far -
 * no extra storage needed to remember a "minimum".
 */
#define STACK_CANARY 0xc5

extern uint8_t __heap_start;
extern uint8_t __stack;

void stack_paint(void) __attribute__((naked, used, section(".init1")));
void stack_paint(void) {
	__asm__ __volatile__ (
		"    ldi r30,lo8(__heap_start)\n"
		"    ldi r31,hi8(__heap_start)\n"
		"    ldi r24,lo8(0xc5)\n" /* STACK_CANARY */
		"    ldi r25,hi8(__stack)\n"
		"    rjmp .Lstackpaint_cmp\n"
		".Lstackpaint_loop:\n"
		"    st Z+,r24\n"
		".Lstackpaint_cmp:\n"
		"    cpi r30,lo8(__stack)\n"
		"    cpc r31,r25\n"
		"    brlo .Lstackpaint_loop\n"
		"    breq .Lstackpaint_loop\n"
	);
}

unsigned int get_stack_free_bytes(void) {
	const uint8_t *p = &__heap_start;
	unsigned int count = 0;
	while (p <= &__stack && *p == STACK_CANARY) {
		p++;
		count++;
	}
	return count;
}

void request_immediate_sync(void) {
	FLAGS |= F_SYNC;
}

void io_mark(unsigned long int start_ms) {
	unsigned int dt = (unsigned int)(get_uptime_ms() - start_ms);
	if (dt > io_max_ms)
		io_max_ms = dt;
}

unsigned int io_get_and_reset_max(void) {
	unsigned int v = io_max_ms;
	io_max_ms = 0;
	return v;
}

void start_bootloader(void) {
	typedef void (*do_reboot_t)(void);
	const do_reboot_t do_reboot = (do_reboot_t)((FLASHEND - 1023) >> 1);
	cli();
	uart1_deinit();
/*	close_files(0); // FIXME not working
	display_event(DISPLAY_EVENT_BOOTLOADER);*/
	LCD_Clear(); /* Do not call display.c here! */
	LCD_GoTo(0,0);
	LCD_WriteTextP(PSTR("Aktualizacja"));
	LCD_GoTo(8,1);
	LCD_WriteTextP(PSTR("softu..."));
	TCCR0A = TCCR1A = TCCR2A = 0; // make sure interrupts are off and timers are reset.
	do_reboot();
	wdt_enable(WDTO_15MS);
	while(1);
}

/*---------------------------------------------------------*/
/* 100Hz timer interrupt generated by OC1A                 */
/*---------------------------------------------------------*/

ISR(TIMER1_COMPA_vect)
{
	static WORD ivt_sync;
//	static BYTE led;
	static unsigned int power_sw;
	unsigned int *volatile ctimer;
	unsigned char i;
	unsigned char k;
	static unsigned char oldk;

	uptime_ms += 10; /* this ISR fires at 100Hz */

	for(i=0; i<sizeof(System.timers)/sizeof(unsigned int); i++){ // decrement every variable from timers struct unless it's already zero
		ctimer = ((unsigned int *)&System.timers) + i;
		if(*ctimer)
			(*ctimer)--;
	}

	/* Sync interval */
	if (IVT_SYNC && ++ivt_sync >= IVT_SYNC * 100) {
		ivt_sync = 0;
		FLAGS |= F_SYNC;
	}

	/* Green LED drive */
/*	if (FLAGS & F_POW) {
		if ((FLAGS & F_GPSOK) || (++led & 0x20)) {
			LEDG_ON();
		} else {
			LEDG_OFF();
		}
	} else {
		LEDG_OFF();
	}*/

	/* MMC/SD timer procedure */
	disk_timerproc();
	
	/* Switch off */
	if (POWER_SW_PRESSED()) {
		if (++power_sw == POWER_SW_TIME){
			FLAGS |= F_POWEROFF;
			power_sw++;
		}
		System.timers.backlight = ms(BACKLIGHT_TIME);
	} else {
		power_sw = 0;
	}
	
	if (uart1_test() && uart1_get() == '0' && uart1_get() == ' '){
		LEDB_ON();
		start_bootloader();
	}
	
	/* keyboard */
	k = ((~PIND) >> 4) & 0x0f;
	if (POWER_SW_PRESSED())
		k |= K_POWER;
	if (k && k != oldk) {
		System.keypress = k;
		oldk = k;
	}
	if (!k)
		oldk = 0;
}

unsigned char getkey(void) {
	unsigned char key = System.keypress;
	System.keypress = 0;
	return key;
}


/* Power supply monitor */
ISR(ADC_vect)
{
	float bat_volt;
	static unsigned int adc_buf;
	static unsigned char adc_cnt;
	static BYTE lvt;
	
	adc_buf += ADC;
	if(++adc_cnt < 15)
		return;

	bat_volt = (float)adc_buf/(float)(adc_cnt)/VI_MULT;
	adc_buf = 0;
	adc_cnt = 0;
	
	System.bat_volt = bat_volt;
	if (FLAGS & F_LVD) {
		if (bat_volt > VI_LVH) {
			FLAGS &= ~F_LVD;
			lvt = 0;
		}
	} else {
		if (bat_volt < VI_LVL) {
			if (++lvt >= 3) {
				FLAGS |= F_LVD;
				FLAGS |= F_SYNC; /* flush now, as early as possible before an imminent brownout */
			}
		} else {
			lvt = 0;
		}
	}
}

void sleep(void) {
	set_sleep_mode(SLEEP_MODE_IDLE);
	sleep_enable();
	sleep_cpu();
	sleep_disable();
}

/*--------------------------------------------------------------------------*/
/* Controls                                                                 */

void beep (UINT len, BYTE cnt)
{
	while (cnt--) {
		BEEP_ON();
		set_timer(beep, len);
		while(!timer_expired(beep)) {};
		BEEP_OFF();
		set_timer(beep, len);
		while(!timer_expired(beep)) {};
	}
}

/* Number of consecutive epochs (nmea_epoch_complete() pulses) a new
 * fix-acquired/lost state must hold before it's logged - coalesces the rapid
 * flapping seen on marginal reception (e.g. 2D/3D/no-fix alternating for
 * about a minute) into at most one or two log lines instead of one per flip. */
#define FIX_HOLD_EPOCHS	5

#define LOG_SIZE	300

struct {
	char buf[LOG_SIZE+1];
	unsigned int len;
} logbuf;

void log_put(int c){
	UINT bw;
	if (System.conf.uart_log_mode != UART_LOG_MODE_NMEA)
		uart1_put(c);
	logbuf.buf[logbuf.len++] = c;
	if (logbuf.len >= LOG_SIZE && (FLAGS & F_FILEOPEN)) {
		unsigned long int t0 = get_uptime_ms();
		unsigned char err = f_write(&system_log, logbuf.buf, logbuf.len, &bw);
		io_mark(t0);
		if (!err)
			logbuf.len = 0;
	}
	if (logbuf.len > LOG_SIZE) {
		logbuf.len--;
	}
}

static
void ioinit (void)
{
	wdt_enable(WDTO_4S); /* MCUSR was already cleared in wdt_disable_early() (.init3) */
	POWER_ON_DDR |= POWER_ON;
	PORTA |= POWER_ON;
	
	BUZZER_DDR |= BUZZER;
	GPS_OFF();
	GPS_DIS_DDR |= GPS_DIS;
	LEDR_DDR |= LEDR;

	OCR1A = F_CPU/8/100-1;		/* Timer1: 100Hz interval (OC1A) */
	TCCR1B = _BV(WGM12) | _BV(CS11);
	TIMSK1 = _BV(OCIE1A);		/* Enable TC1.oca interrupt */

	/* ADC */
//	ADMUX = 0;
	ADMUX = 1; // FIXME only testing battery voltage
	ADCSRA = _BV(ADEN)|_BV(ADATE)|_BV(ADIE)|_BV(ADPS2)|_BV(ADPS1)|_BV(ADPS0);
	
	/* uart1 (debug) */	
	uart1_init();
	
	I2C_init();
	expander_init(0, 0x00, 0x00); /* all as outputs */
	
	LCD_Initialize();
	LCD_Clear();

	LCD_GoTo(0,0);

	wdt_reset();

	sei();
	
	ADCSRA |= _BV(ADSC);
	
	/* unused pins */
	DDRA |= _BV(PA2) | _BV(PA4) | _BV(PA5);
	PRR0 |= _BV(PRTIM2) | _BV(PRTIM0);
	ACSR = _BV(ACD);		/* Disable analog comp */
}

void close_files(unsigned char flush_logs) {
	UINT bw;
	if (FLAGS & F_FILEOPEN) {
		if (flush_logs)
			log_session_summary(1);
		if (f_close(&gps_log)) {
			System.status = STATUS_FILE_CLOSE_ERROR;
			System.global_error |= ERROR_FILE_CLOSE;
		}
		if (gpx_close(&gpx_file)) {
			System.status = STATUS_FILE_CLOSE_ERROR;
			System.global_error |= ERROR_FILE_CLOSE;
		}
		if (flush_logs && logbuf.len && !f_write(&system_log, logbuf.buf, logbuf.len, &bw)) {
			logbuf.len = 0;
		}
		if (f_close(&system_log)) {
			System.status = STATUS_FILE_CLOSE_ERROR;
			System.global_error |= ERROR_FILE_CLOSE;
		}
		xputs_P(PSTR("File closed\r\n"));
		display_event(DISPLAY_EVENT_FILE_CLOSED);
	}
	FLAGS &= ~F_FILEOPEN;
	disk_ioctl(0, CTRL_POWER, 0);
}

void reset_counters(void) {
	System.distance = 0;
	System.elevation_gain = 0;
	System.elevation_loss = 0;
	System.elevation_gain_raw = 0;
	System.elevation_loss_raw = 0;
	System.alt_max = 0;
	System.speed_accum_x100 = 0;
	System.speed_sample_count = 0;
	System.points_written = 0;
	System.rejected_count = 0;
	System.points_paused = 0;
	System.points_skipped = 0;
	System.points_accepted = 0;
	System.bat_volt_min = 99.0;
	System.time_start = 0;
	System.current_pause_start = 0;
	System.pause_time = 0;
}

unsigned int get_avg_speed_x100(void) {
	if (!System.speed_sample_count)
		return 0;
	return System.speed_accum_x100 / System.speed_sample_count;
}

/* Average speed the "old" way (distance / moving time), kept only so it can
 * be logged alongside get_avg_speed_x100() in the session summary - the two
 * should track each other, and a growing gap is worth noticing. */
unsigned int get_dist_avg_speed_x100(void) {
	unsigned int moving = get_logging_time();
	if (!moving)
		return 0;
	/* (distance_cm * 3.6) / moving_s, kept as an all-integer x100 fixed-point value */
	return (unsigned int)((unsigned long int)System.distance * 36UL / (10UL * moving));
}

/* A fix normally arrives about once a second; treat a longer gap between
 * accepted points as a fix having been lost and reacquired (regardless of
 * why the epochs in between were rejected/absent - fix loss, a 2D fix, poor
 * HDOP, or the receiver simply not producing lines). Shared by
 * gpx_process_point() (resets the Kalman/averaging warm-up, the same as
 * after power-on - a freshly reacquired fix can carry a wildly wrong
 * position/altitude for a few seconds) and auto_pause_process() (resets the
 * stationary-time counter - otherwise it keeps counting through the gap
 * with no visibility into how long the gap was or whether the device kept
 * moving during it, and can trip a pause within moments of reacquiring a
 * fix that was actually lost while the device was genuinely still moving).
 * Called at most once per accepted point (the main loop below calls it
 * before both), so a single static last-seen time is enough - two callers
 * checking independently would each need their own copy and could disagree
 * about where the gap boundary was. */
#define FIX_GAP_SECONDS	3

unsigned char fix_gap_detected(time_t point_time) {
	static time_t last_point_time = 0;
	unsigned char gap = last_point_time && point_time - last_point_time > FIX_GAP_SECONDS;
	last_point_time = point_time;
	return gap;
}

/* Call exactly once, at the moment tracking_paused/tracking_auto_paused
 * actually transitions to true (auto_pause_activate(), tracking_pause()) -
 * not deferred until the next accepted point, which may never come before
 * the pause ends (a near-stationary point, which is exactly what triggers a
 * pause, is also exactly what a min-distance/Kalman/distdiff reject in
 * gpx_process_point() would drop) or may come from a much later, unrelated
 * pause, corrupting current_pause_start into a stale value that then leaks
 * into get_pause_time() and the pause_time carried forward on resume. */
void pause_time_start(void) {
	System.current_pause_start = utc;
}

/* Call exactly once, at the moment tracking_paused/tracking_auto_paused
 * actually transitions to false (auto_unpause(), tracking_pause()) - folds
 * this pause's duration into the permanent accumulator and clears the
 * start, so a later summary/query while not paused never reuses it. */
void pause_time_end(void) {
	/* Same time_start floor as get_pause_time() - a pause that started (and
	 * possibly also ended) before the first fix contributes no pause time,
	 * since logging itself hadn't started yet either. */
	if (System.current_pause_start && System.current_pause_start >= System.time_start)
		System.pause_time += utc - System.current_pause_start;
	System.current_pause_start = 0;
}

time_t get_pause_time(void) {
	time_t res = System.pause_time;
	/* current_pause_start is 0 whenever there's no in-progress pause to add -
	 * either genuinely not paused, or paused but reset_counters() cleared it
	 * (along with time_start) after pause_time_start() ran for this pause.
	 * The time_start floor guards the one remaining case reset_counters()
	 * doesn't cover: pause_time_start() ran before the first fix (e.g. the
	 * boot-time "don't log until moving" pause), leaving current_pause_start
	 * at an earlier (possibly 0) utc than time_start - only time since
	 * logging actually started counts as pause time. */
	if (is_paused() && System.current_pause_start && System.current_pause_start >= System.time_start)
		res += utc - System.current_pause_start;
	return res;
}

unsigned int get_logging_time(void) {
	if (!utc || !System.time_start)
		return 0;
	return utc - System.time_start - get_pause_time();
}

unsigned char tracking_is_paused(void) {
	return System.tracking_paused || System.tracking_auto_paused;
}

__flash const char __open_msg[] = "Open %s\r\n";

/*-----------------------------------------------------------------------*/
/* Main                                                                  */
/*-----------------------------------------------------------------------*/

int main (void)
{
	UINT bw, len;
	time_t tmp_utc, localtime;
	FRESULT res;
	unsigned char prev_status;
	unsigned char already_logging = 0;
	static unsigned char fix_ok_prev = 0;
	static unsigned char fix_hold_counter = 0;
	static unsigned char dgps_prev = 0xFF; /* 0xFF: not yet known, suppress the first (non-)transition */
	static unsigned long int last_summary_uptime = 0;

	ioinit();
	xdev_out(log_put);
	xputs_P(PSTR("STARTUP\r\n"));
	disp_init();
	display_event(DISPLAY_EVENT_STARTUP);
	settings_load();
	reset_counters();
	log_boot_record();
	request_immediate_sync(); /* flush the boot/config lines as soon as a log file opens, not after up to IVT_SYNC seconds */

	menu_push(default_menu);

	for (;;) {
		wdt_reset();
		if (FLAGS & (F_POWEROFF | F_LVD)) {
			xputs_P(PSTR("POWEROFF\r\n"));
			display_event(DISPLAY_EVENT_POWEROFF);
			if (FLAGS & F_LVD) {
				display_event(DISPLAY_EVENT_LOW_BATTERY);
				_delay_ms(500);
			}
			POWEROFF();
			while (POWER_SW_PRESSED());
			_delay_ms(2000); /* wait for switch off */
			FLAGS &= ~F_POWEROFF; /* restart if power is not lost */
			POWERON();
			xputs_P(PSTR("RESTART\r\n"));
		}

		display_event(DISPLAY_EVENT_INITIALIZED);
		log_loop_status(System.status);
		request_immediate_sync(); /* flush the just-logged loop/error status promptly */
		utc = 0;
		localtime = 0;
		prev_status = System.status;
		System.status = STATUS_NO_POWER;

		beep(250, prev_status);	/* Error beep */

		/* Wait for supply voltage stabled */
		_delay_ms(500);
		if (FLAGS & F_LVD)
			continue;

		/* report error here ( prev_status) */

		if (disk_status(0) & STA_NODISK) {
			System.status = STATUS_NO_DISK;
			continue;
		}

		res = f_mount(&Fatfs, "", 1);
		if (res != FR_OK) {
			xprintf(PSTR("FS error %u\r\n"), res);
			System.status = STATUS_DISK_ERROR;
			System.global_error |= ERROR_DISK;
			continue;
		}
		System.status = STATUS_NO_GPS;
		xputs(PSTR("FS Ok\r\n"));
		display_event(DISPLAY_EVENT_CARD_INITIALIZED);
		beep(50, 1);				/* 1 beep */

		/* Initialize GPS receiver */
		GPS_ON();		/* GPS power on */
		FLAGS |= F_POW;
		_delay_ms(1);
		uart0_init();	/* Enable UART */
		_delay_ms(300);	/* Delay */
		System.gps_initialized = 0;
		gps_powered_on();


		if (!already_logging && !get_flag(CONFFLAG_LOGGING_AFTER_BOOT)) {
			tracking_pause(TRACKING_PAUSE_CMD_PAUSE, 0);
		}

		for (;;) { /* main loop */
			wdt_reset();
			gettemp();

			/* Check temperature sensor after initialization */
			if ((FLAGS & F_GPSOK) && !System.temperature_ok) {
				System.global_error |= ERROR_TEMPERATURE;
			}

			menu();
			check_error_and_jump();
			display_refresh(0);
			if (no_menu())
				menu_push(default_menu); /* returned from top-level */

			if (System.timers.backlight)
				LEDW_ON();
			else
				LEDW_OFF();

			len = get_line(Line, sizeof Line);	/* Receive a line from GPS receiver */
			if (!len){
				if (FLAGS & (F_LVD | F_POWEROFF))
					break; /* brownout */
				continue;
			}

			tmp_utc = gps_parse(Line);
			if (tmp_utc) {
				localtime = tmp_utc + local_time_diff(tmp_utc) * 3600L;	/* Local time */
				LEDG_ON();
				_delay_ms(2);
				LEDG_OFF();
			}

			/* Battery low-water mark, for the session summary */
			if (System.bat_volt > 0 && System.bat_volt < System.bat_volt_min)
				System.bat_volt_min = System.bat_volt;

			/* Fix acquired/lost events (a "fix" requires both a valid GPS status and enough
			 * satellites). Gated on nmea_epoch_complete() so sats=/hdop= are never read from a
			 * stale epoch, and debounced so a single bad epoch on marginal reception doesn't log
			 * a FIX/FIX LOST pair by itself - the new state must hold for FIX_HOLD_EPOCHS epochs. */
			if (nmea_epoch_complete()) {
				unsigned char fix_ok_now = (FLAGS & F_GPSOK) && !System.sat_count_low;
				if (fix_ok_now == fix_ok_prev) {
					fix_hold_counter = 0;
				} else if (++fix_hold_counter >= FIX_HOLD_EPOCHS) {
					fix_hold_counter = 0;
					fix_ok_prev = fix_ok_now;
					if (fix_ok_now) {
						log_fix_event();
					} else {
						log_fix_lost();
						request_immediate_sync();
					}
				}
			}

			/* DGPS-quality-fix on-off transitions (the receiver's own doing,
			 * e.g. from SBAS - not necessarily caused by our own SBAS-search
			 * request, CONFFLAG_ENABLE_SBAS) */
			if (System.dgps != dgps_prev) {
				if (dgps_prev != 0xFF)
					log_dgps_transition();
				dgps_prev = System.dgps;
			}

			if (timer_expired(status_log)) {
				set_timer(status_log, 60000);
				log_status_line();
			}

			if (get_uptime_ms() - last_summary_uptime >= 3600000UL) {
				last_summary_uptime = get_uptime_ms();
				log_session_summary(0);
			}

			if (FLAGS & F_FILEOPEN) {
				{
					unsigned long int t0 = get_uptime_ms();
					f_write(&gps_log, Line, len-1, &bw);
					io_mark(t0);
				}
				if (bw != len-1) {
					System.status = STATUS_FILE_WRITE_ERROR;
					System.global_error |= ERROR_FILE_WRITE;
					break;
				}
				if (System.location_valid == LOC_VALID_NEW) { /* a new point */
					if (fix_gap_detected(location.time)) {
						auto_pause_reset_gap();
						gpx_reset_gap();
					}
					auto_pause_process();
					gpx_process_point(&location, &gpx_file);
				}
				wdt_reset();
				if (FLAGS & F_SYNC) {
					/* Sync all three log files together, on this same periodic
					 * timer (IVT_SYNC), rather than after every write: an SD
					 * f_sync() can stall for 100ms+ and must not happen on
					 * every line, or it would stall the NMEA UART reception. */
					unsigned long int t0 = get_uptime_ms();
					unsigned char sync_err = f_sync(&gps_log);
					io_mark(t0);
					t0 = get_uptime_ms();
					sync_err |= f_sync(&gpx_file);
					io_mark(t0);
					t0 = get_uptime_ms();
					sync_err |= f_sync(&system_log);
					io_mark(t0);
					if (sync_err) {
						System.status = STATUS_FILE_SYNC_ERROR;
						System.global_error |= ERROR_FILE_SYNC;
						break;
					}
					FLAGS &= ~F_SYNC;
				}
				if (System.open_new_file) {
					close_files(1);
					System.open_new_file = 0;
					if (!System.tracking_paused)
						tracking_pause(TRACKING_PAUSE_CMD_PAUSE, 0);
					if (get_flag(CONFFLAG_RESET_ON_NEW_FILE))
						reset_counters();
				}
				if (!System.tracking_paused)
					already_logging = 1; /* to avoid pausing on any reset caused by some error */
			}
			if (System.location_valid == LOC_VALID_NEW) {
				System.location_valid = LOC_VALID;
			}

			if (localtime && !(FLAGS & F_FILEOPEN)) {
				char *time = get_iso_time(utc, 1);
				iso_time_to_filename(time);
				xsprintf(Line, PSTR("%s-NMEA.LOG"), time);
				xprintf(__open_msg, Line);
				wdt_disable();
				if (f_open(&gps_log, Line, FA_WRITE | FA_OPEN_ALWAYS)		/* Open log file */
					|| f_lseek(&gps_log, f_size(&gps_log)) 					/* Append mode */
					|| f_write(&gps_log, "\r\n", 2, &bw))					/* Put a blank line as start marker */
				{
					System.status = STATUS_FILE_OPEN_ERROR;
					System.global_error |= ERROR_FILE_OPEN;
					break;	/* Failed to start logging */
				}

				xsprintf(Line, PSTR("%s.GPX"), time);
				xprintf(__open_msg, Line);
				if (f_open(&gpx_file, Line, FA_WRITE | FA_OPEN_ALWAYS)		/* Open log file */
					|| f_lseek(&gpx_file, f_size(&gpx_file)) 				/* Append mode */
					|| gpx_init(&gpx_file))									/* Put a blank line as start marker */
				{
					f_close(&gpx_file);
					System.status = STATUS_FILE_OPEN_ERROR;
					System.global_error |= ERROR_FILE_OPEN;
					break;	/* Failed to start logging */
				}

				xsprintf(Line, PSTR("%s-SYSTEM.LOG"), time);
				xprintf(__open_msg, Line);
				if (f_open(&system_log, Line, FA_WRITE | FA_OPEN_ALWAYS)	/* Open log file */
					|| f_lseek(&system_log, f_size(&system_log)) 			/* Append mode */
					|| f_write(&system_log, "\r\n", 2, &bw))				/* Put a blank line as start marker */
				{
					f_close(&gpx_file);
					f_close(&gps_log);
					System.status = STATUS_FILE_OPEN_ERROR;
					System.global_error |= ERROR_FILE_OPEN;
					break;	/* Failed to start logging */
				}
				wdt_enable(WDTO_4S);
				FLAGS |= F_FILEOPEN;
				System.status = STATUS_OK;
				set_timer(status_log, 60000);
				last_summary_uptime = get_uptime_ms();
				beep(50, System.tracking_paused?8:2);		/* Two beeps. Start logging. */
				display_event(DISPLAY_EVENT_FILE_OPEN);
				continue;
			}
		}
		
		wdt_enable(WDTO_4S);

		/* Stop GPS receiver */
		uart0_deinit();
		GPS_OFF();
		FLAGS &= ~F_POW;

		/* Close file */
		close_files(1);
		if (System.status != STATUS_FILE_CLOSE_ERROR)
			beep(500, 1);	/* Long beep on file close succeeded */
		
		settings_store(); /* save eeprom data */
	}

}