GPStracker/gps-test-tool/main.c

/*
 * GPS Test Tool - PC Application
 *
 * Tests GPS filtering and GPX generation using actual embedded code
 * Usage: ./gps-test-tool [options] <input.nmea>
 *
 * Generates (default mode):
 *   - output_filtered.gpx
 *   - output_unfiltered.gpx
 *   - debug_filtered.txt
 *   - debug_unfiltered.txt
 *
 * With -o, does a single run with the given settings instead (used by
 * gps-test-tool-gui).
 */

#define PC_BUILD
#include "main.h"
#include <getopt.h>

/* Global variables expected by project code */
volatile struct system_s System;
struct location_s location;
time_t utc;
unsigned char FLAGS = 0;
volatile unsigned char reset_cause = 0; /* no real MCU reset happened; log_boot_record() reports "UNKNOWN" */

/* File handle for debug output redirection */
FILE *debug_output = NULL;

/* soft/syslog.c's log_config()/log_boot_record() print these; not part of
 * this PC build otherwise (they're normally in soft/settings.c). */
__flash const char gnss_name_stub[] = "GPS+GLONASS+GALILEO/etc (PC test tool - not tracked per mode)";
__flash const char *gnss_names[] = {
	gnss_name_stub, gnss_name_stub, gnss_name_stub,
	gnss_name_stub, gnss_name_stub, gnss_name_stub,
};
__flash const char uart_log_mode_stub[] = "n/a (PC test tool)";
__flash const char *uart_log_mode_names[] = {
	uart_log_mode_stub, uart_log_mode_stub, uart_log_mode_stub,
};

/* Function prototypes from project files */
unsigned char gpx_init(FIL *file);
unsigned char gpx_close(FIL *file);
void gpx_process_point(struct location_s *loc, FIL *file);
void gpx_reset_gap(void);
time_t gps_parse(const char *nmea);

/* Time function implementation */
char *get_iso_time(time_t time, unsigned char local) {
    static char output[32];
    struct tm *ct = gmtime(&time);
    sprintf(output, "%04d-%02d-%02dT%02d:%02d:%02d.000Z",
            ct->tm_year + 1900, ct->tm_mon + 1, ct->tm_mday,
            ct->tm_hour, ct->tm_min, ct->tm_sec);
    return output;
}

void iso_time_to_filename(char *time) {
    while (*time) {
        switch (*time) {
            case ':': *time = '-'; break;
            case '+': *time = 'p'; break;
        }
        time++;
    }
}

/* Settings applied by reset_system(); command-line options override these. */
static unsigned char opt_skip_points = 0;  /* Don't skip points for testing */
/* Match soft/settings.c's defaults_u8, so this tool's auto-pause behavior
 * matches an out-of-the-box device. */
static unsigned char opt_auto_pause_time = 30;
static unsigned char opt_auto_pause_dist = 10;
static unsigned char opt_auto_pause_speed = 3;
static unsigned char opt_min_sats = 4;  /* Require at least 4 satellites */
static unsigned char opt_auto_pause = 1;
static unsigned char opt_verbose_log = 0;

/* Reset system state */
void reset_system(void) {
    memset((void*)&System, 0, sizeof(System));
    memset(&location, 0, sizeof(location));
    System.conf.skip_points = opt_skip_points;
    System.conf.auto_pause_time = opt_auto_pause_time;
    System.conf.auto_pause_dist = opt_auto_pause_dist;
    System.conf.auto_pause_speed = opt_auto_pause_speed;
    System.conf.min_sats = opt_min_sats;
    System.tracking_paused = 0;
    System.tracking_auto_paused = 0;
    System.bat_volt = 4.0f;   /* no real ADC here; keeps the status line's v=/bat%= fields sane */
    System.bat_volt_min = 4.0f;
    utc = 0;
}

/* Process NMEA file with specified filter setting */
int process_nmea_file(const char *input_file, const char *output_gpx,
                      const char *debug_file, int filters_enabled) {
    FILE *input;
    FIL gpx_file;
    char line[256];
    int point_count = 0;

    /* Open input file */
    input = fopen(input_file, "r");
    if (!input) {
        fprintf(stderr, "Error: Cannot open input file '%s'\n", input_file);
        return 1;
    }

    /* Open debug output file */
    debug_output = fopen(debug_file, "w");
    if (!debug_output) {
        fprintf(stderr, "Error: Cannot open debug file '%s'\n", debug_file);
        fclose(input);
        return 1;
    }

    /* Reset system state */
    reset_system();

    /* Configure filters */
    set_flag(CONFFLAG_DISABLE_FILTERS, !filters_enabled);
    set_flag(CONFFLAG_AUTO_PAUSE, opt_auto_pause);
    set_flag(CONFFLAG_VERBOSE_LOG, opt_verbose_log);

    gps_powered_on();
    log_boot_record();

    /* Open GPX output file */
    if (f_open(&gpx_file, output_gpx, FA_WRITE | FA_OPEN_ALWAYS) != 0) {
        fprintf(stderr, "Error: Cannot open GPX file '%s'\n", output_gpx);
        fclose(input);
        fclose(debug_output);
        return 1;
    }

    /* Initialize GPX file */
    if (gpx_init(&gpx_file) != 0) {
        fprintf(stderr, "Error: GPX initialization failed\n");
        fclose(input);
        fclose(debug_output);
        f_close(&gpx_file);
        return 1;
    }

    fprintf(debug_output, "=== GPS Test Tool - %s ===\n",
            filters_enabled ? "FILTERS ENABLED" : "FILTERS DISABLED");
    fprintf(debug_output, "Input: %s\n", input_file);
    fprintf(debug_output, "Output: %s\n\n", output_gpx);

    /* Process NMEA file line by line */
    /* Kept in sync with soft/main.c's FIX_HOLD_EPOCHS. */
    #define FIX_HOLD_EPOCHS 5
    unsigned char fix_ok_prev = 0;
    unsigned char fix_hold_counter = 0;
    unsigned char dgps_prev = 0xFF; /* 0xFF: not yet known, suppress the first (non-)transition */
    time_t next_status_utc = 0;
    time_t next_summary_utc = 0;
    while (fgets(line, sizeof(line), input)) {
        size_t len = strlen(line);

        /* Skip empty lines */
        if (len == 0) continue;

        /* Ensure line ends with \r\n as expected by gps_parse */
        if (len > 0 && line[len-1] == '\n') {
            line[len-1] = '\0';
            len--;
        }
        if (len > 0 && line[len-1] == '\r') {
            line[len-1] = '\0';
            len--;
        }
        /* Add back \r\n for gps_parse, bounded: fgets can fill line[] to
         * capacity with no trailing newline, leaving no room for it. */
        if (len + 2 >= sizeof(line))
            len = sizeof(line) - 3;
        line[len] = '\0';
        strcat(line, "\r\n");

        /* Parse NMEA sentence */
        if (gps_parse(line) != 0) {
            /* Valid location data received (RMC parsed) */
            /* Only process if we have valid coordinates from GGA */
            if (System.location_valid == LOC_VALID_NEW || System.location_valid == LOC_VALID) {
                if (fix_gap_detected(location.time)) {
                    auto_pause_reset_gap();
                    gpx_reset_gap();
                }
                auto_pause_process();
                gpx_process_point(&location, &gpx_file);
                point_count++;
            }
        }

        /* Mirror soft/main.c's system-log event/status triggers, so this
         * tool exercises and lets you review the same log output the
         * firmware produces. There's no real clock here, so pace the
         * periodic status line/session summary off the NMEA timestamps
         * instead of uptime. */
        if (utc) {
            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();
                }
            }
            if (System.dgps != dgps_prev) {
                if (dgps_prev != 0xFF)
                    log_dgps_transition();
                dgps_prev = System.dgps;
            }
            if (!next_status_utc)
                next_status_utc = utc + 60;
            if (utc >= next_status_utc) {
                log_status_line();
                next_status_utc = utc + 60;
            }
            if (!next_summary_utc)
                next_summary_utc = utc + 3600;
            if (utc >= next_summary_utc) {
                log_session_summary(0);
                next_summary_utc = utc + 3600;
            }
        }
    }

    /* Close GPX file */
    gpx_close(&gpx_file);
    log_session_summary(1);

    /* Print summary */
    {
        unsigned int moving = get_logging_time();
        unsigned long int stopped = get_pause_time();
        /* points_accepted counts every point past all reject checks, at
         * AVG_COUNT=3 samples per written trkpt with filters enabled (1:1
         * with filters disabled, so this is 0 in that mode). */
        unsigned long int averaged_out = System.points_accepted - System.points_written *
            (filters_enabled ? 3UL : 1UL);
        fprintf(debug_output, "\n=== Summary ===\n");
        fprintf(debug_output, "Points processed: %d\n", point_count);
        fprintf(debug_output, "Points during pauses: %lu\n", System.points_paused);
        fprintf(debug_output, "Points skipped (warm-up): %lu\n", System.points_skipped);
        fprintf(debug_output, "Points rejected: %lu\n", System.rejected_count);
        fprintf(debug_output, "Points averaged out: %lu\n", averaged_out);
        fprintf(debug_output, "Points saved: %lu\n", System.points_written);
        fprintf(debug_output, "Total distance: %.2f km\n", System.distance / 100000.0);
        fprintf(debug_output, "Elevation gain: %.1f m\n", System.elevation_gain / 10.0);
        fprintf(debug_output, "Elevation loss: %.1f m\n", System.elevation_loss / 10.0);
        fprintf(debug_output, "Moving time: %uh%02um\n", moving/3600, (moving/60)%60);
        fprintf(debug_output, "Stopped time: %luh%02lum\n", stopped/3600, (stopped/60)%60);
        fprintf(debug_output, "Average speed: %.2f km/h\n", get_avg_speed_x100()/100.0);
        fprintf(debug_output, "Average speed (dist/time): %.2f km/h\n", get_dist_avg_speed_x100()/100.0);
    }

    /* Close files */
    fclose(input);
    fclose(debug_output);
    debug_output = NULL;

    printf("Processed %d points -> %s (filters %s)\n",
           point_count, output_gpx, filters_enabled ? "ON" : "OFF");

    return 0;
}

static void usage(const char *name) {
    fprintf(stderr, "Usage: %s [options] <input.nmea>\n", name);
    fprintf(stderr, "\nWithout -o, generates:\n");
    fprintf(stderr, "  - output_filtered.gpx\n");
    fprintf(stderr, "  - output_unfiltered.gpx\n");
    fprintf(stderr, "  - debug_filtered.txt\n");
    fprintf(stderr, "  - debug_unfiltered.txt\n");
    fprintf(stderr, "\nOptions:\n");
    fprintf(stderr, "  -o FILE  single run: write GPX to FILE only\n");
    fprintf(stderr, "  -l FILE  single run: write debug output to FILE (default: none)\n");
    fprintf(stderr, "  -n       single run: disable filters\n");
    fprintf(stderr, "  -A       disable auto-pause\n");
    fprintf(stderr, "  -t SEC   auto-pause time (default %u)\n", opt_auto_pause_time);
    fprintf(stderr, "  -d M     auto-pause distance (default %u)\n", opt_auto_pause_dist);
    fprintf(stderr, "  -s KMH   auto-pause speed (default %u)\n", opt_auto_pause_speed);
    fprintf(stderr, "  -k N     skip points after fix (default %u)\n", opt_skip_points);
    fprintf(stderr, "  -m N     minimum satellites (default %u)\n", opt_min_sats);
    fprintf(stderr, "  -v       verbose log\n");
}

/* Parse a 0..255 setting value; returns 0 on success. */
static int parse_u8(const char *str, unsigned char *val) {
    char *end;
    long v = strtol(str, &end, 10);
    if (!*str || *end || v < 0 || v > 255)
        return 1;
    *val = v;
    return 0;
}

int main(int argc, char *argv[]) {
    int ret, c, bad = 0;
    const char *single_gpx = NULL;
    const char *single_debug = "/dev/null";
    int single_filters = 1;

    while ((c = getopt(argc, argv, "o:l:nAt:d:s:k:m:v")) != -1) {
        switch (c) {
            case 'o': single_gpx = optarg; break;
            case 'l': single_debug = optarg; break;
            case 'n': single_filters = 0; break;
            case 'A': opt_auto_pause = 0; break;
            case 't': bad |= parse_u8(optarg, &opt_auto_pause_time); break;
            case 'd': bad |= parse_u8(optarg, &opt_auto_pause_dist); break;
            case 's': bad |= parse_u8(optarg, &opt_auto_pause_speed); break;
            case 'k': bad |= parse_u8(optarg, &opt_skip_points); break;
            case 'm': bad |= parse_u8(optarg, &opt_min_sats); break;
            case 'v': opt_verbose_log = 1; break;
            default: bad = 1; break;
        }
    }

    if (bad || optind != argc - 1) {
        usage(argv[0]);
        return 1;
    }

    if (single_gpx)
        return process_nmea_file(argv[optind], single_gpx, single_debug, single_filters);

    printf("GPS Test Tool v1.0\n");
    printf("==================\n\n");

    /* Process with filters enabled */
    printf("Processing with filters ENABLED...\n");
    ret = process_nmea_file(argv[optind], "output_filtered.gpx",
                            "debug_filtered.txt", 1);
    if (ret != 0) {
        fprintf(stderr, "Failed to process with filters enabled\n");
        return ret;
    }

    /* Process with filters disabled */
    printf("Processing with filters DISABLED...\n");
    ret = process_nmea_file(argv[optind], "output_unfiltered.gpx",
                            "debug_unfiltered.txt", 0);
    if (ret != 0) {
        fprintf(stderr, "Failed to process with filters disabled\n");
        return ret;
    }

    printf("\nProcessing complete!\n");
    printf("Generated files:\n");
    printf("  - output_filtered.gpx (filters ON)\n");
    printf("  - output_unfiltered.gpx (filters OFF)\n");
    printf("  - debug_filtered.txt (debug output with filters)\n");
    printf("  - debug_unfiltered.txt (debug output without filters)\n");

    return 0;
}