GPStracker/gps-test-tool/main.h

/*
 * main.h - PC Compatible Version
 * Central header for GPS Test Tool - handles PC/embedded switches
 */

#pragma once

#ifdef PC_BUILD
    /* ========== PC BUILD CONFIGURATION ========== */

    /* Standard C headers - all includes centralized here */
    #include <stdio.h>
    #include <stdint.h>
    #include <stdlib.h>
    #include <stddef.h>
    #include <string.h>
    #include <time.h>
    #include <math.h>
    #include <stdarg.h>
    #include <ctype.h>

    /* Prevent AVR headers from being included */
    #define _AVR_PGMSPACE_H_ 1
    #define _AVR_IO_H_ 1
    #define _AVR_WDT_H_ 1
    #define _AVR_SLEEP_H_ 1
    #define _AVR_INTERRUPT_H_ 1
    #define _AVR_EEPROM_H_ 1

    /* PROGMEM/Flash support - no-op on PC */
    #define PROGMEM
    #define __flash
    #define PSTR(s) (s)
    #define strcpy_P strcpy
    #define strcat_P strcat
    #define strcmp_P strcmp
    #define pgm_read_byte(addr) (*(addr))

    /* Stub LCD type to bypass error */
    #define LCD_ALNUM

    /* Interrupt stubs */
    #define cli()
    #define sei()

    /* FatFS types */
    typedef struct {
        FILE *fp;
        char filename[256];
    } FIL;

    typedef uint32_t DWORD;
    typedef unsigned int UINT;
    typedef unsigned char BYTE;
    typedef char TCHAR;
    typedef unsigned char FRESULT;

    /* FatFS functions */
    #define FA_WRITE 0x02
    #define FA_OPEN_ALWAYS 0x10

    static inline FRESULT f_open(FIL *file, const TCHAR *path, BYTE mode) {
        (void)mode;
        file->fp = fopen(path, "w");
        return file->fp ? 0 : 1;
    }

    static inline FRESULT f_write(FIL *file, const void *buf, UINT len, UINT *written) {
        if (!file->fp) return 1;
        *written = fwrite(buf, 1, len, file->fp);
        return (*written == len) ? 0 : 1;
    }

    static inline FRESULT f_close(FIL *file) {
        if (file->fp) {
            fclose(file->fp);
            file->fp = NULL;
            return 0;
        }
        return 1;
    }

    /* xprintf functions */
    extern FILE *debug_output;

    static inline void xputs(const char* str) {
        FILE *out = debug_output ? debug_output : stdout;
        fputs(str, out);
    }

    static inline void xputs_P(const char* str) {
        FILE *out = debug_output ? debug_output : stdout;
        fputs(str, out);
    }

    static inline void xprintf(const char* fmt, ...) {
        FILE *out = debug_output ? debug_output : stdout;
        va_list ap;
        va_start(ap, fmt);
        vfprintf(out, fmt, ap);
        va_end(ap);
    }

    static inline void xsprintf(char* buff, const char* fmt, ...) {
        va_list ap;
        va_start(ap, fmt);
        vsprintf(buff, fmt, ap);
        va_end(ap);
    }

    static inline void xfprintf(void (*put)(int), const char* fmt, ...) {
        /* Stub for PC - just ignore output to UART */
        (void)put;
        (void)fmt;
    }

    /* xatof - Parse float from string (used by NMEA parser) */
    static inline void xatof(const char **str, double *result) {
        char *end;
        *result = strtod(*str, &end);
        *str = end;
    }

    /* Math constants */
    #ifndef M_PI
    #define M_PI 3.14159265358979323846
    #endif

    /* NMEA time fields are UTC. The embedded build's stime.S mktime() is a
     * UTC-only conversion (no TZ/DST concept), but libc's mktime() treats
     * struct tm as local time and applies TZ - redirect to timegm() (POSIX/
     * glibc/BSD extension, ignores TZ) so the PC build matches. */
    #define mktime timegm

#else
    /* ========== EMBEDDED BUILD CONFIGURATION ========== */

    #define __PROG_TYPES_COMPAT__
    #include <inttypes.h>
    #include <avr/pgmspace.h>
    #include <avr/interrupt.h>
    #include "stime.h"
    #include "expander.h"
    #include "settings.h"

    #if defined(LCD_GRAPHIC)
    #include "UC1601S-I2C.h"
    #elif defined(LCD_ALNUM)
    #include "HD44780-I2C.h"
    #else
    #error No LCD type defined
    #endif

#endif /* PC_BUILD */

/* ========== COMMON DEFINITIONS (both PC and embedded) ========== */

#define IVT_SYNC        180
#define POWER_SW_TIME   300
#define BACKLIGHT_TIME  10000

#define VI_LVL          3.1
#define VI_LVH          3.4
#define VI_MULT         (3.3 / 6.6 / 2.495 * 1024)

/* GPS initialization states (PC-build value only - GPS_INIT_INITIALIZED
 * doesn't exist here, this tool has no real GPS module init sequence) */
#define GPS_INIT_NOT_INITIALIZED 0
#define GPS_INIT_QUERY_SENT      1

/* struct system_s/location_s/config_s/auto_pause_s and the value constants
 * their fields hold are in soft/common.h - shared byte-for-byte with the
 * embedded build, since gpx.c/nmea.c/syslog.c/autopause.c (soft/) compile
 * unmodified into this tool too (see the *_wrapper.c files). */
#include "../soft/common.h"

extern struct auto_pause_s auto_pause;

/* Global variables */
extern volatile struct system_s System;
extern struct location_s location;
extern time_t utc;

/* Kept in sync with soft/settings.c's get_flag()/set_flag(): System.conf.flags
 * is part of struct config_s in common.h, and CONFFLAG_* there is a bit
 * index (not a pre-shifted mask), so this must index the same way - not the
 * config_flags-bitmask scheme this used to have, which numbered its flags
 * differently (and didn't have all of them), a silent mismatch from
 * embedded's real indices that a shared header can't paper over unless both
 * sides actually agree on what a CONFFLAG_* value means. */
static inline unsigned char get_flag(unsigned char index) {
    return System.conf.flags[index/8] & (1 << (index % 8));
}

static inline void set_flag(unsigned char index, unsigned char val) {
    if (val)
        System.conf.flags[index/8] |= (1 << (index % 8));
    else
        System.conf.flags[index/8] &= ~(1 << (index % 8));
}

/* soft/main.c's helpers, reimplemented here: soft/main.c itself isn't part
 * of this PC build (this test tool has its own main()), but soft/syslog.c
 * calls into them. */
unsigned char is_paused(void); /* soft/gpx.c, via gpx_wrapper.c */

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

/* Kept in sync with soft/main.c's pause_time_start()/pause_time_end()/
 * get_pause_time(): call the start/end function exactly once, at the moment
 * a pause actually begins/ends (not deferred to the next accepted point,
 * which may never come before the pause ends, or may come from a much
 * later, unrelated pause) - see soft/main.c for the full rationale. */
static inline void pause_time_start(void) {
    System.current_pause_start = utc;
}

static inline void pause_time_end(void) {
    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;
}

/* Kept in sync with soft/main.c's fix_gap_detected() - see there for the
 * full rationale. */
static inline 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 > 3;
    last_point_time = point_time;
    return gap;
}

static inline time_t get_pause_time(void) {
    time_t res = System.pause_time;
    if (is_paused() && System.current_pause_start && System.current_pause_start >= System.time_start)
        res += utc - System.current_pause_start;
    return res;
}

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

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

static inline unsigned int get_dist_avg_speed_x100(void) {
    unsigned int moving = get_logging_time();
    if (!moving)
        return 0;
    return (unsigned int)((unsigned long int)System.distance * 36UL / (10UL * moving));
}

/* Time functions */
char *get_iso_time(time_t time, unsigned char local);
void iso_time_to_filename(char *time);

/* GPS and distance functions */
void gps_initialize(void);
void add_distance(float dist);
void add_elevation(float ele_change);
float distance(struct location_s *pos1, struct location_s *pos2);
unsigned char nmea_epoch_complete(void);

/* The structured system log (soft/syslog.c) is compiled into this test tool
 * too (see syslog_wrapper.c), so its real log_reject()/log_jump()/log_prefix()
 * etc. are used here, not stubs - see gnss_names/uart_log_mode_names/
 * reset_cause below for what it needs that isn't otherwise part of this
 * PC build. */
void log_prefix(void);
void log_reject(unsigned char reason);
void log_reject_flush(void);
void log_jump(unsigned char is_alt, float meters);
void log_boot_record(void);
void log_status_line(void);
void log_fix_event(void);
void log_fix_lost(void);
void log_dgps_transition(void);
void log_session_summary(unsigned char final);
void log_pause_event(unsigned char started);
void gps_powered_on(void);

/* Auto-pause is real logic (soft/autopause.c), not stubbed - it directly
 * gates System.distance/elevation_gain/elevation_loss, which is a major part
 * of what this tool's output looks like. It calls beep(), which is
 * meaningless on PC and stubbed out here. */
void auto_pause_process(void);
void auto_pause_reset_gap(void);
unsigned char gps_fix_trustworthy(void);
static inline void beep(unsigned int len, unsigned char cnt) { (void)len; (void)cnt; }

extern volatile unsigned char reset_cause;
extern __flash const char *gnss_names[];
extern __flash const char *uart_log_mode_names[];

/* MCUSR reset-cause bits and _BV(): meaningless on PC (reset_cause is always
 * 0 here, so log_boot_record() just reports "UNKNOWN"), but syslog.c
 * references them unconditionally. */
#define _BV(x) (1 << (x))
#define WDRF 3
#define BORF 2
#define EXTRF 1
#define PORF 0

/* soft/main.c's SD I/O timing and stack-headroom instrumentation isn't
 * meaningful for the PC build's stdio-based file stubs; stub it out. */
static inline unsigned long int get_uptime_ms(void) { return 0; }
static inline void io_mark(unsigned long int start_ms) { (void)start_ms; }
static inline unsigned int io_get_and_reset_max(void) { return 0; }
static inline unsigned int get_stack_free_bytes(void) { return 0; }

/* Stub functions for PC build */
#ifdef PC_BUILD
static inline void set_timer(int timer, int val) { (void)timer; (void)val; }
static inline int timer_expired(int timer) { (void)timer; return 0; }
static inline void wdt_reset(void) {}
static inline void sleep(void) {}
static inline int uart0_test(void) { return 0; }
static inline unsigned char uart0_get(void) { return 0; }
static inline void uart0_put(char c) { (void)c; }
static inline void uart1_put(char c) { (void)c; }
/* Must have external linkage (defined once, in main.c/test_malformed.c):
 * nmea.c (compiled via nmea_actual_wrapper.c, a separate translation unit)
 * sets F_GPSOK here, and the driver loop needs to see that same flag. A
 * `static` FLAGS in this shared header would give every .c file its own
 * private copy, silently discarding those updates. */
extern unsigned char FLAGS;
#define F_LVD 0x01
#define F_POWEROFF 0x02
#define F_GPSOK 0x04
#define recv_timeout 0
#endif /* PC_BUILD stubs */