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)) {};
	}
}

#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.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));
}

time_t get_pause_time(void) {
	time_t res = System.pause_time;
	if (System.current_pause_start < System.time_start)
		System.current_pause_start = System.time_start; /* disallow negative pause time */
	if (is_paused() && System.current_pause_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();
}

__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 sbas_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) */
			{
				unsigned char fix_ok_now = (FLAGS & F_GPSOK) && !System.sat_count_low;
				if (fix_ok_now != fix_ok_prev) {
					if (fix_ok_now)
						log_fix_event();
					else
						log_fix_lost();
					fix_ok_prev = fix_ok_now;
				}
			}

			/* SBAS/DGPS on-off transitions */
			if (System.sbas != sbas_prev) {
				if (sbas_prev != 0xFF)
					log_sbas_transition();
				sbas_prev = System.sbas;
			}

			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 */
					gpx_process_point(&location, &gpx_file);
					auto_pause_process();
				}
				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 */
	}

}