From 24167015705ae831692b95735968b04a876f935e Mon Sep 17 00:00:00 2001 From: Keith Packard Date: Fri, 4 Apr 2014 23:34:48 -0700 Subject: altos: Rename 'core' to 'kernel' core remains a bad name to use -- dirvish skips files (and directories, it seems) with that name. Signed-off-by: Keith Packard --- src/kernel/ao_config.c | 805 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 805 insertions(+) create mode 100644 src/kernel/ao_config.c (limited to 'src/kernel/ao_config.c') diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c new file mode 100644 index 00000000..4482f673 --- /dev/null +++ b/src/kernel/ao_config.c @@ -0,0 +1,805 @@ +/* + * Copyright © 2009 Keith Packard + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. + */ + +#include "ao.h" +#include "ao_log.h" +#include +#if HAS_FLIGHT +#include +#include +#endif + +__xdata struct ao_config ao_config; +__pdata uint8_t ao_config_loaded; +__pdata uint8_t ao_config_dirty; +__xdata uint8_t ao_config_mutex; + +#ifndef AO_CONFIG_DEFAULT_APRS_INTERVAL +#define AO_CONFIG_DEFAULT_APRS_INTERVAL 0 +#endif +#define AO_CONFIG_DEFAULT_MAIN_DEPLOY 250 +#define AO_CONFIG_DEFAULT_RADIO_CHANNEL 0 +#define AO_CONFIG_DEFAULT_CALLSIGN "N0CALL" +#define AO_CONFIG_DEFAULT_ACCEL_ZERO_G 16000 +#define AO_CONFIG_DEFAULT_APOGEE_DELAY 0 +#define AO_CONFIG_DEFAULT_IGNITE_MODE AO_IGNITE_MODE_DUAL +#define AO_CONFIG_DEFAULT_PAD_ORIENTATION AO_PAD_ORIENTATION_ANTENNA_UP +#if HAS_EEPROM +#ifndef USE_INTERNAL_FLASH +#error Please define USE_INTERNAL_FLASH +#endif +#endif +#ifndef AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX +#if USE_INTERNAL_FLASH +#define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX ao_storage_config +#else +#define AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX ((uint32_t) 192 * (uint32_t) 1024) +#endif +#endif +#ifndef AO_CONFIG_DEFAULT_RADIO_POWER +#define AO_CONFIG_DEFAULT_RADIO_POWER 0x60 +#endif +#define AO_CONFIG_DEFAULT_RADIO_AMP 0 + +#if HAS_EEPROM +static void +_ao_config_put(void) +{ + ao_config_setup(); + ao_config_erase(); + ao_config_write(0, &ao_config, sizeof (ao_config)); +#if HAS_FLIGHT + ao_log_write_erase(0); +#endif + ao_config_flush(); +} + +void +ao_config_put(void) +{ + ao_mutex_get(&ao_config_mutex); + _ao_config_put(); + ao_mutex_put(&ao_config_mutex); +} +#endif + +#if HAS_RADIO +void +ao_config_set_radio(void) +{ + ao_config.radio_setting = ao_freq_to_set(ao_config.frequency, ao_config.radio_cal); +} +#endif /* HAS_RADIO */ + +static void +_ao_config_get(void) +{ + uint8_t minor; + + if (ao_config_loaded) + return; +#if HAS_EEPROM + /* Yes, I know ao_storage_read calls ao_storage_setup, + * but ao_storage_setup *also* sets ao_storage_config, which we + * need before calling ao_storage_read here + */ + ao_config_setup(); + ao_config_read(0, &ao_config, sizeof (ao_config)); +#endif + if (ao_config.major != AO_CONFIG_MAJOR) { + ao_config.major = AO_CONFIG_MAJOR; + ao_config.minor = 0; + + /* Version 0 stuff */ + ao_config.main_deploy = AO_CONFIG_DEFAULT_MAIN_DEPLOY; + ao_xmemset(&ao_config.callsign, '\0', sizeof (ao_config.callsign)); + ao_xmemcpy(&ao_config.callsign, CODE_TO_XDATA(AO_CONFIG_DEFAULT_CALLSIGN), + sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1); + ao_config._legacy_radio_channel = 0; + } + minor = ao_config.minor; + if (minor != AO_CONFIG_MINOR) { + /* Fixups for minor version 1 */ + if (minor < 1) + ao_config.apogee_delay = AO_CONFIG_DEFAULT_APOGEE_DELAY; + /* Fixups for minor version 2 */ + if (minor < 2) { + ao_config.accel_plus_g = 0; + ao_config.accel_minus_g = 0; + } + /* Fixups for minor version 3 */ +#if HAS_RADIO + if (minor < 3) + ao_config.radio_cal = ao_radio_cal; +#endif + /* Fixups for minor version 4 */ +#if HAS_FLIGHT + if (minor < 4) + ao_config.flight_log_max = AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX; +#endif + /* Fixupes for minor version 5 */ + if (minor < 5) + ao_config.ignite_mode = AO_CONFIG_DEFAULT_IGNITE_MODE; + if (minor < 6) + ao_config.pad_orientation = AO_CONFIG_DEFAULT_PAD_ORIENTATION; + if (minor < 8) + ao_config.radio_enable = AO_RADIO_ENABLE_CORE; + if (minor < 9) + ao_xmemset(&ao_config.aes_key, '\0', AO_AES_LEN); + if (minor < 10) + ao_config.frequency = 434550 + ao_config._legacy_radio_channel * 100; + if (minor < 11) + ao_config.apogee_lockout = 0; +#if AO_PYRO_NUM + if (minor < 12) + memset(&ao_config.pyro, '\0', sizeof (ao_config.pyro)); +#endif + if (minor < 13) + ao_config.aprs_interval = AO_CONFIG_DEFAULT_APRS_INTERVAL; +#if HAS_RADIO_POWER + if (minor < 14) + ao_config.radio_power = AO_CONFIG_DEFAULT_RADIO_POWER; + #endif +#if HAS_RADIO_AMP + if (minor < 14) + ao_config.radio_amp = AO_CONFIG_DEFAULT_RADIO_AMP; +#endif +#if HAS_GYRO + if (minor < 15) { + ao_config.accel_zero_along = 0; + ao_config.accel_zero_across = 0; + ao_config.accel_zero_through = 0; + + /* Reset the main accel offsets to force + * re-calibration + */ + ao_config.accel_plus_g = 0; + ao_config.accel_minus_g = 0; + } +#endif + ao_config.minor = AO_CONFIG_MINOR; + ao_config_dirty = 1; + } +#if HAS_RADIO +#if HAS_FORCE_FREQ + if (ao_force_freq) { + ao_config.frequency = 434550; + ao_config.radio_cal = ao_radio_cal; + ao_xmemcpy(&ao_config.callsign, CODE_TO_XDATA(AO_CONFIG_DEFAULT_CALLSIGN), + sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1); + } +#endif + ao_config_set_radio(); +#endif + ao_config_loaded = 1; +} + +void +_ao_config_edit_start(void) +{ + ao_mutex_get(&ao_config_mutex); + _ao_config_get(); +} + +void +_ao_config_edit_finish(void) +{ + ao_config_dirty = 1; + ao_mutex_put(&ao_config_mutex); +} + +void +ao_config_get(void) +{ + _ao_config_edit_start(); + ao_mutex_put(&ao_config_mutex); +} + +void +ao_config_callsign_show(void) +{ + printf ("Callsign: \"%s\"\n", ao_config.callsign); +} + +void +ao_config_callsign_set(void) __reentrant +{ + uint8_t c; + static __xdata char callsign[AO_MAX_CALLSIGN + 1]; + + ao_xmemset(callsign, '\0', sizeof callsign); + ao_cmd_white(); + c = 0; + while (ao_cmd_lex_c != '\n') { + if (c < AO_MAX_CALLSIGN) + callsign[c++] = ao_cmd_lex_c; + else + ao_cmd_status = ao_cmd_lex_error; + ao_cmd_lex(); + } + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_xmemcpy(&ao_config.callsign, &callsign, + AO_MAX_CALLSIGN + 1); + _ao_config_edit_finish(); +} + +#if HAS_RADIO + +void +ao_config_frequency_show(void) __reentrant +{ + printf("Frequency: %ld\n", + ao_config.frequency); +} + +void +ao_config_frequency_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.frequency = ao_cmd_lex_u32; + ao_config_set_radio(); + _ao_config_edit_finish(); +#if HAS_RADIO_RECV + ao_radio_recv_abort(); +#endif +} +#endif + +#if HAS_FLIGHT + +void +ao_config_main_deploy_show(void) __reentrant +{ + printf("Main deploy: %d meters\n", + ao_config.main_deploy); +} + +void +ao_config_main_deploy_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.main_deploy = ao_cmd_lex_i; + _ao_config_edit_finish(); +} + +#if HAS_ACCEL +void +ao_config_accel_calibrate_show(void) __reentrant +{ + printf("Accel cal +1g: %d -1g: %d\n", + ao_config.accel_plus_g, ao_config.accel_minus_g); +#if HAS_GYRO + printf ("IMU cal along %d across %d through %d\n", + ao_config.accel_zero_along, + ao_config.accel_zero_across, + ao_config.accel_zero_through); +#endif +} + +#define ACCEL_CALIBRATE_SAMPLES 1024 +#define ACCEL_CALIBRATE_SHIFT 10 + +#if HAS_GYRO +static int16_t accel_cal_along; +static int16_t accel_cal_across; +static int16_t accel_cal_through; +#endif + +static int16_t +ao_config_accel_calibrate_auto(char *orientation) __reentrant +{ + uint16_t i; + int32_t accel_total; + uint8_t cal_data_ring; +#if HAS_GYRO + int32_t accel_along_total = 0; + int32_t accel_across_total = 0; + int32_t accel_through_total = 0; +#endif + + printf("Orient antenna %s and press a key...", orientation); + flush(); + (void) getchar(); + puts("\r\n"); flush(); + puts("Calibrating..."); flush(); + i = ACCEL_CALIBRATE_SAMPLES; + accel_total = 0; + cal_data_ring = ao_sample_data; + while (i) { + ao_sleep(DATA_TO_XDATA(&ao_sample_data)); + while (i && cal_data_ring != ao_sample_data) { + accel_total += (int32_t) ao_data_accel(&ao_data_ring[cal_data_ring]); +#if HAS_GYRO + accel_along_total += (int32_t) ao_data_along(&ao_data_ring[cal_data_ring]); + accel_across_total += (int32_t) ao_data_across(&ao_data_ring[cal_data_ring]); + accel_through_total += (int32_t) ao_data_through(&ao_data_ring[cal_data_ring]); +#endif + cal_data_ring = ao_data_ring_next(cal_data_ring); + i--; + } + } +#if HAS_GYRO + accel_cal_along = accel_along_total >> ACCEL_CALIBRATE_SHIFT; + accel_cal_across = accel_across_total >> ACCEL_CALIBRATE_SHIFT; + accel_cal_through = accel_through_total >> ACCEL_CALIBRATE_SHIFT; +#endif + return accel_total >> ACCEL_CALIBRATE_SHIFT; +} + +void +ao_config_accel_calibrate_set(void) __reentrant +{ + int16_t up, down; +#if HAS_GYRO + int16_t accel_along_up = 0, accel_along_down = 0; + int16_t accel_across_up = 0, accel_across_down = 0; + int16_t accel_through_up = 0, accel_through_down = 0; +#endif + + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + if (ao_cmd_lex_i == 0) { + up = ao_config_accel_calibrate_auto("up"); +#if HAS_GYRO + accel_along_up = accel_cal_along; + accel_across_up = accel_cal_across; + accel_through_up = accel_cal_through; +#endif + down = ao_config_accel_calibrate_auto("down"); +#if HAS_GYRO + accel_along_down = accel_cal_along; + accel_across_down = accel_cal_across; + accel_through_down = accel_cal_through; +#endif + } else { + up = ao_cmd_lex_i; + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + down = ao_cmd_lex_i; + } + if (up >= down) { + printf("Invalid accel: up (%d) down (%d)\n", + up, down); + return; + } + _ao_config_edit_start(); + ao_config.accel_plus_g = up; + ao_config.accel_minus_g = down; +#if HAS_GYRO + if (ao_cmd_lex_i == 0) { + ao_config.accel_zero_along = (accel_along_up + accel_along_down) / 2; + ao_config.accel_zero_across = (accel_across_up + accel_across_down) / 2; + ao_config.accel_zero_through = (accel_through_up + accel_through_down) / 2; + } +#endif + _ao_config_edit_finish(); +} +#endif /* HAS_ACCEL */ + +void +ao_config_apogee_delay_show(void) __reentrant +{ + printf("Apogee delay: %d seconds\n", + ao_config.apogee_delay); +} + +void +ao_config_apogee_delay_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.apogee_delay = ao_cmd_lex_i; + _ao_config_edit_finish(); +} + +void +ao_config_apogee_lockout_show(void) __reentrant +{ + printf ("Apogee lockout: %d seconds\n", + ao_config.apogee_lockout); +} + +void +ao_config_apogee_lockout_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.apogee_lockout = ao_cmd_lex_i; + _ao_config_edit_finish(); +} + +#endif /* HAS_FLIGHT */ + +#if HAS_RADIO +void +ao_config_radio_cal_show(void) __reentrant +{ + printf("Radio cal: %ld\n", ao_config.radio_cal); +} + +void +ao_config_radio_cal_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.radio_cal = ao_cmd_lex_u32; + ao_config_set_radio(); + _ao_config_edit_finish(); +} +#endif + +#if HAS_LOG +void +ao_config_log_show(void) __reentrant +{ + printf("Max flight log: %d kB\n", (int16_t) (ao_config.flight_log_max >> 10)); +} + +void +ao_config_log_set(void) __reentrant +{ + uint16_t block = (uint16_t) (ao_storage_block >> 10); + uint16_t log_max = (uint16_t) (ao_storage_log_max >> 10); + + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + if (ao_log_present()) + printf("Storage must be empty before changing log size\n"); + else if (block > 1024 && (ao_cmd_lex_i & (block - 1))) + printf("Flight log size must be multiple of %d kB\n", block); + else if (ao_cmd_lex_i > log_max) + printf("Flight log max %d kB\n", log_max); + else { + _ao_config_edit_start(); + ao_config.flight_log_max = (uint32_t) ao_cmd_lex_i << 10; + _ao_config_edit_finish(); + } +} +#endif /* HAS_LOG */ + +#if HAS_IGNITE +void +ao_config_ignite_mode_show(void) __reentrant +{ + printf("Ignite mode: %d\n", ao_config.ignite_mode); +} + +void +ao_config_ignite_mode_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.ignite_mode = ao_cmd_lex_i; + _ao_config_edit_finish(); +} +#endif + +#if HAS_ACCEL +void +ao_config_pad_orientation_show(void) __reentrant +{ + printf("Pad orientation: %d\n", ao_config.pad_orientation); +} + +#ifndef AO_ACCEL_INVERT +#define AO_ACCEL_INVERT 0x7fff +#endif + +void +ao_config_pad_orientation_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_cmd_lex_i &= 1; + if (ao_config.pad_orientation != ao_cmd_lex_i) { + int16_t t; + t = ao_config.accel_plus_g; + ao_config.accel_plus_g = AO_ACCEL_INVERT - ao_config.accel_minus_g; + ao_config.accel_minus_g = AO_ACCEL_INVERT - t; + } + ao_config.pad_orientation = ao_cmd_lex_i; + _ao_config_edit_finish(); +} +#endif + +#if HAS_RADIO +void +ao_config_radio_enable_show(void) __reentrant +{ + printf("Radio enable: %d\n", ao_config.radio_enable); +} + +void +ao_config_radio_enable_set(void) __reentrant +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.radio_enable = ao_cmd_lex_i; + _ao_config_edit_finish(); +} +#endif /* HAS_RADIO */ + +#if HAS_AES + +__xdata uint8_t ao_config_aes_seq = 1; + +void +ao_config_key_show(void) __reentrant +{ + uint8_t i; + printf("AES key: "); + for (i = 0; i < AO_AES_LEN; i++) + printf ("%02x", ao_config.aes_key[i]); + printf("\n"); +} + +void +ao_config_key_set(void) __reentrant +{ + uint8_t i; + + _ao_config_edit_start(); + for (i = 0; i < AO_AES_LEN; i++) { + ao_cmd_hexbyte(); + if (ao_cmd_status != ao_cmd_success) + break; + ao_config.aes_key[i] = ao_cmd_lex_i; + } + ++ao_config_aes_seq; + _ao_config_edit_finish(); +} +#endif + +#if HAS_APRS + +void +ao_config_aprs_show(void) +{ + printf ("APRS interval: %d\n", ao_config.aprs_interval); +} + +void +ao_config_aprs_set(void) +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.aprs_interval = ao_cmd_lex_i; + _ao_config_edit_finish(); +} + +#endif /* HAS_APRS */ + +#if HAS_RADIO_AMP + +void +ao_config_radio_amp_show(void) +{ + printf ("Radio amp setting: %d\n", ao_config.radio_amp); +} + +void +ao_config_radio_amp_set(void) +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.radio_amp = ao_cmd_lex_i; + _ao_config_edit_finish(); +} + +#endif + +#if HAS_RADIO_POWER + +void +ao_config_radio_power_show(void) +{ + printf ("Radio power setting: %d\n", ao_config.radio_power); +} + +void +ao_config_radio_power_set(void) +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.radio_power = ao_cmd_lex_i; + _ao_config_edit_finish(); +} + +#endif + +struct ao_config_var { + __code char *str; + void (*set)(void) __reentrant; + void (*show)(void) __reentrant; +}; + +static void +ao_config_help(void) __reentrant; + +static void +ao_config_show(void) __reentrant; + +#if HAS_EEPROM +static void +ao_config_save(void) __reentrant; +#endif + +__code struct ao_config_var ao_config_vars[] = { +#if HAS_FLIGHT + { "m \0Main deploy (m)", + ao_config_main_deploy_set, ao_config_main_deploy_show, }, + { "d \0Apogee delay (s)", + ao_config_apogee_delay_set, ao_config_apogee_delay_show }, + { "L \0Apogee detect lockout (s)", + ao_config_apogee_lockout_set, ao_config_apogee_lockout_show, }, +#endif /* HAS_FLIGHT */ +#if HAS_RADIO + { "F \0Frequency (kHz)", + ao_config_frequency_set, ao_config_frequency_show }, + { "c \0Callsign (8 char max)", + ao_config_callsign_set, ao_config_callsign_show }, + { "e <0 disable, 1 enable>\0Enable telemetry and RDF", + ao_config_radio_enable_set, ao_config_radio_enable_show }, + { "f \0Radio calib (cal = rf/(xtal/2^16))", + ao_config_radio_cal_set, ao_config_radio_cal_show }, +#if HAS_RADIO_POWER + { "p \0Radio power setting (0-255)", + ao_config_radio_power_set, ao_config_radio_power_show }, +#endif +#if HAS_RADIO_AMP + { "d \0Radio amplifier setting (0-3)", + ao_config_radio_amp_set, ao_config_radio_amp_show }, +#endif +#endif /* HAS_RADIO */ +#if HAS_ACCEL + { "a <+g> <-g>\0Accel calib (0 for auto)", + ao_config_accel_calibrate_set,ao_config_accel_calibrate_show }, + { "o <0 antenna up, 1 antenna down>\0Set pad orientation", + ao_config_pad_orientation_set,ao_config_pad_orientation_show }, +#endif /* HAS_ACCEL */ +#if HAS_LOG + { "l \0Flight log size (kB)", + ao_config_log_set, ao_config_log_show }, +#endif +#if HAS_IGNITE + { "i <0 dual, 1 apogee, 2 main>\0Set igniter mode", + ao_config_ignite_mode_set, ao_config_ignite_mode_show }, +#endif +#if HAS_AES + { "k <32 hex digits>\0Set AES encryption key", + ao_config_key_set, ao_config_key_show }, +#endif +#if AO_PYRO_NUM + { "P \0Configure pyro channels", + ao_pyro_set, ao_pyro_show }, +#endif +#if HAS_APRS + { "A \0APRS packet interval (0 disable)", + ao_config_aprs_set, ao_config_aprs_show }, +#endif + { "s\0Show", + ao_config_show, 0 }, +#if HAS_EEPROM + { "w\0Write to eeprom", + ao_config_save, 0 }, +#endif + { "?\0Help", + ao_config_help, 0 }, + { 0, 0, 0 } +}; + +void +ao_config_set(void) +{ + char c; + uint8_t cmd; + + ao_cmd_white(); + c = ao_cmd_lex_c; + ao_cmd_lex(); + for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++) + if (ao_config_vars[cmd].str[0] == c) { + (*ao_config_vars[cmd].set)(); + return; + } + ao_cmd_status = ao_cmd_syntax_error; +} + +static void +ao_config_help(void) __reentrant +{ + uint8_t cmd; + for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++) + printf("%-20s %s\n", + ao_config_vars[cmd].str, + ao_config_vars[cmd].str+1+ + strlen(ao_config_vars[cmd].str)); +} + +static void +ao_config_show(void) __reentrant +{ + uint8_t cmd; + ao_config_get(); + printf("Config version: %d.%d\n", + ao_config.major, ao_config.minor); + for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++) + if (ao_config_vars[cmd].show) + (*ao_config_vars[cmd].show)(); +#if HAS_MS5607 + ao_ms5607_info(); +#endif +} + +#if HAS_EEPROM +static void +ao_config_save(void) __reentrant +{ + uint8_t saved = 0; + ao_mutex_get(&ao_config_mutex); + if (ao_config_dirty) { + _ao_config_put(); + ao_config_dirty = 0; + saved = 1; + } + ao_mutex_put(&ao_config_mutex); + if (saved) + puts("Saved"); + else + puts("Nothing to save"); +} +#endif + +__code struct ao_cmds ao_config_cmds[] = { + { ao_config_set, "c \0Set config (? for help, s to show)" }, + { 0, NULL }, +}; + +void +ao_config_init(void) +{ + ao_cmd_register(&ao_config_cmds[0]); +} -- cgit v1.2.3 From 027b1470c7a2d007eaab5c8d49f772b0c7559b80 Mon Sep 17 00:00:00 2001 From: Keith Packard Date: Fri, 2 May 2014 12:26:07 -0700 Subject: altos: Add configurable beep tone This lets you directly set the mid-range beep tone; the high and low tones remain set off of that in the same ratio as before. Note that none of the cc1111 products get this feature as they don't have enough flash space anymore... Signed-off-by: Keith Packard --- src/cc1111/ao_pins.h | 5 +++++ src/kernel/ao.h | 5 ++++- src/kernel/ao_beep.h | 19 ++++++++++++++++--- src/kernel/ao_config.c | 35 +++++++++++++++++++++++++++++++++-- src/kernel/ao_telemetry.h | 6 +++--- src/telemini-v2.0/ao_pins.h | 1 + 6 files changed, 62 insertions(+), 9 deletions(-) (limited to 'src/kernel/ao_config.c') diff --git a/src/cc1111/ao_pins.h b/src/cc1111/ao_pins.h index 5b1586e0..91bf81d2 100644 --- a/src/cc1111/ao_pins.h +++ b/src/cc1111/ao_pins.h @@ -24,6 +24,7 @@ #define HAS_FLIGHT 1 #define HAS_USB 1 #define HAS_BEEP 1 + #define HAS_BEEP_CONFIG 0 #define HAS_GPS 1 #define HAS_SERIAL_1 1 #define HAS_ADC 1 @@ -58,6 +59,7 @@ #define HAS_FLIGHT 1 #define HAS_USB 1 #define HAS_BEEP 1 + #define HAS_BEEP_CONFIG 0 #define HAS_BATTERY_REPORT 1 #define HAS_GPS 1 #define HAS_SERIAL_1 1 @@ -95,6 +97,7 @@ #define HAS_FLIGHT 1 #define HAS_USB 1 #define HAS_BEEP 1 + #define HAS_BEEP_CONFIG 0 #define HAS_BATTERY_REPORT 1 #define HAS_GPS 1 #define HAS_SERIAL_1 1 @@ -212,6 +215,7 @@ #define HAS_FLIGHT 1 #define HAS_USB 1 #define HAS_BEEP 1 + #define HAS_BEEP_CONFIG 0 #define HAS_GPS 1 #define HAS_SERIAL_1 1 #define HAS_ADC 1 @@ -333,6 +337,7 @@ #define HAS_FLIGHT 0 #define HAS_USB 1 #define HAS_BEEP 1 + #define HAS_BEEP_CONFIG 0 #define HAS_SERIAL_1 1 #define HAS_SERIAL_1_ALT_1 1 #define HAS_SERIAL_1_ALT_2 0 diff --git a/src/kernel/ao.h b/src/kernel/ao.h index 29ad2603..9169bd84 100644 --- a/src/kernel/ao.h +++ b/src/kernel/ao.h @@ -750,7 +750,7 @@ extern __xdata uint8_t ao_force_freq; #endif #define AO_CONFIG_MAJOR 1 -#define AO_CONFIG_MINOR 15 +#define AO_CONFIG_MINOR 16 #define AO_AES_LEN 16 @@ -789,6 +789,9 @@ struct ao_config { int16_t accel_zero_across; /* minor version 15 */ int16_t accel_zero_through; /* minor version 15 */ #endif +#if HAS_BEEP + uint8_t mid_beep; /* minor version 16 */ +#endif }; #define AO_IGNITE_MODE_DUAL 0 diff --git a/src/kernel/ao_beep.h b/src/kernel/ao_beep.h index 55f61171..9d6ecf27 100644 --- a/src/kernel/ao_beep.h +++ b/src/kernel/ao_beep.h @@ -18,6 +18,12 @@ #ifndef _AO_BEEP_H_ #define _AO_BEEP_H_ +#ifndef HAS_BEEP_CONFIG +#if defined(USE_EEPROM_CONFIG) && USE_EEPROM_CONFIG || HAS_EEPROM +#define HAS_BEEP_CONFIG 1 +#endif +#endif + /* * ao_beep.c */ @@ -28,9 +34,16 @@ * frequency = 1/2 (24e6/32) / beep */ -#define AO_BEEP_LOW 150 /* 2500Hz */ -#define AO_BEEP_MID 94 /* 3989Hz */ -#define AO_BEEP_HIGH 75 /* 5000Hz */ +#define AO_BEEP_MID_DEFAULT 94 /* 3989Hz */ + +#if HAS_BEEP_CONFIG +#define AO_BEEP_MID ao_config.mid_beep +#else +#define AO_BEEP_MID AO_BEEP_MID_DEFAULT +#endif +#define AO_BEEP_LOW AO_BEEP_MID * 150 / 94 /* 2500Hz */ +#define AO_BEEP_HIGH AO_BEEP_MID * 75 / 94 /* 5000Hz */ + #define AO_BEEP_OFF 0 /* off */ #define AO_BEEP_g 240 /* 1562.5Hz */ diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c index 4482f673..411399d7 100644 --- a/src/kernel/ao_config.c +++ b/src/kernel/ao_config.c @@ -22,6 +22,9 @@ #include #include #endif +#if HAS_BEEP +#include +#endif __xdata struct ao_config ao_config; __pdata uint8_t ao_config_loaded; @@ -170,6 +173,10 @@ _ao_config_get(void) ao_config.accel_plus_g = 0; ao_config.accel_minus_g = 0; } +#endif +#if HAS_BEEP_CONFIG + if (minor < 16) + ao_config.mid_beep = AO_BEEP_MID_DEFAULT; #endif ao_config.minor = AO_CONFIG_MINOR; ao_config_dirty = 1; @@ -357,7 +364,7 @@ ao_config_accel_calibrate_set(void) __reentrant int16_t accel_across_up = 0, accel_across_down = 0; int16_t accel_through_up = 0, accel_through_down = 0; #endif - + ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; @@ -555,7 +562,7 @@ ao_config_radio_enable_set(void) __reentrant _ao_config_edit_finish(); } #endif /* HAS_RADIO */ - + #if HAS_AES __xdata uint8_t ao_config_aes_seq = 1; @@ -650,6 +657,26 @@ ao_config_radio_power_set(void) #endif +#if HAS_BEEP_CONFIG +void +ao_config_beep_show(void) +{ + printf ("Beeper setting: %d\n", ao_config.mid_beep); +} + +void +ao_config_beep_set(void) +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.mid_beep = ao_cmd_lex_i; + _ao_config_edit_finish(); +} +#endif + + struct ao_config_var { __code char *str; void (*set)(void) __reentrant; @@ -719,6 +746,10 @@ __code struct ao_config_var ao_config_vars[] = { #if HAS_APRS { "A \0APRS packet interval (0 disable)", ao_config_aprs_set, ao_config_aprs_show }, +#endif +#if HAS_BEEP_CONFIG + { "b \0Configure beeper tone (freq = 1/2 (24e6/32) / beep", + ao_config_beep_set, ao_config_beep_show }, #endif { "s\0Show", ao_config_show, 0 }, diff --git a/src/kernel/ao_telemetry.h b/src/kernel/ao_telemetry.h index 237a35ab..fe07c2af 100644 --- a/src/kernel/ao_telemetry.h +++ b/src/kernel/ao_telemetry.h @@ -154,7 +154,7 @@ struct ao_telemetry_companion { uint16_t companion_data[AO_COMPANION_MAX_CHANNELS]; /* 8 */ /* 32 */ }; - + #define AO_TELEMETRY_MEGA_SENSOR 0x08 struct ao_telemetry_mega_sensor { @@ -181,7 +181,7 @@ struct ao_telemetry_mega_sensor { int16_t mag_z; /* 30 */ /* 32 */ }; - + #define AO_TELEMETRY_MEGA_DATA 0x09 struct ao_telemetry_mega_data { @@ -231,7 +231,7 @@ struct ao_telemetry_metrum_sensor { uint8_t pad[6]; /* 26 */ /* 32 */ }; - + #define AO_TELEMETRY_METRUM_DATA 0x0B struct ao_telemetry_metrum_data { diff --git a/src/telemini-v2.0/ao_pins.h b/src/telemini-v2.0/ao_pins.h index dc18aff7..1b4f602f 100644 --- a/src/telemini-v2.0/ao_pins.h +++ b/src/telemini-v2.0/ao_pins.h @@ -24,6 +24,7 @@ #define HAS_USB 1 #define USB_FORCE_FLIGHT_IDLE 1 #define HAS_BEEP 1 +#define HAS_BEEP_CONFIG 0 #define HAS_BATTERY_REPORT 1 #define HAS_GPS 0 #define HAS_SERIAL_1 0 -- cgit v1.2.3 From 2625a464417c8475c66101757ca2c30cd6c74e0c Mon Sep 17 00:00:00 2001 From: Keith Packard Date: Wed, 21 May 2014 14:02:35 -0700 Subject: altos: Add config values for tracker start motion limits TeleGPS switches from 'pad' to 'drogue' states after the device moves a specified distance from the initial starting point. These values can be configured, and this is the configuration for them. Signed-off-by: Keith Packard --- src/kernel/ao.h | 6 +++++- src/kernel/ao_config.c | 50 ++++++++++++++++++++++++++++++++++++++++++++----- src/kernel/ao_tracker.h | 27 ++++++++++++++++++++++++++ 3 files changed, 77 insertions(+), 6 deletions(-) create mode 100644 src/kernel/ao_tracker.h (limited to 'src/kernel/ao_config.c') diff --git a/src/kernel/ao.h b/src/kernel/ao.h index b1f850ba..0ffc647a 100644 --- a/src/kernel/ao.h +++ b/src/kernel/ao.h @@ -753,7 +753,7 @@ extern __xdata uint8_t ao_force_freq; #endif #define AO_CONFIG_MAJOR 1 -#define AO_CONFIG_MINOR 16 +#define AO_CONFIG_MINOR 17 #define AO_AES_LEN 16 @@ -795,6 +795,10 @@ struct ao_config { #if HAS_BEEP uint8_t mid_beep; /* minor version 16 */ #endif +#if HAS_TRACKER + uint16_t tracker_start_horiz; /* minor version 17 */ + uint16_t tracker_start_vert; /* minor version 17 */ +#endif }; #define AO_IGNITE_MODE_DUAL 0 diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c index 411399d7..e5f8efba 100644 --- a/src/kernel/ao_config.c +++ b/src/kernel/ao_config.c @@ -25,6 +25,9 @@ #if HAS_BEEP #include #endif +#if HAS_TRACKER +#include +#endif __xdata struct ao_config ao_config; __pdata uint8_t ao_config_loaded; @@ -177,6 +180,12 @@ _ao_config_get(void) #if HAS_BEEP_CONFIG if (minor < 16) ao_config.mid_beep = AO_BEEP_MID_DEFAULT; +#endif +#if HAS_TRACKER + if (minor < 17) { + ao_config.tracker_start_horiz = AO_CONFIG_DEFAULT_TRACKER_START_HORIZ; + ao_config.tracker_start_vert = AO_CONFIG_DEFAULT_TRACKER_START_VERT; + } #endif ao_config.minor = AO_CONFIG_MINOR; ao_config_dirty = 1; @@ -676,6 +685,33 @@ ao_config_beep_set(void) } #endif +#if HAS_TRACKER +void +ao_config_tracker_show(void) +{ + printf ("Tracker setting: %d %d\n", + ao_config.tracker_start_horiz, + ao_config.tracker_start_vert); +} + +void +ao_config_tracker_set(void) +{ + uint16_t h, v; + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + h = ao_cmd_lex_i; + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + v = ao_cmd_lex_i; + _ao_config_edit_start(); + ao_config.tracker_start_horiz = h; + ao_config.tracker_start_vert = v; + _ao_config_edit_finish(); +} +#endif /* HAS_TRACKER */ struct ao_config_var { __code char *str; @@ -724,7 +760,7 @@ __code struct ao_config_var ao_config_vars[] = { #if HAS_ACCEL { "a <+g> <-g>\0Accel calib (0 for auto)", ao_config_accel_calibrate_set,ao_config_accel_calibrate_show }, - { "o <0 antenna up, 1 antenna down>\0Set pad orientation", + { "o <0 antenna up, 1 antenna down>\0Pad orientation", ao_config_pad_orientation_set,ao_config_pad_orientation_show }, #endif /* HAS_ACCEL */ #if HAS_LOG @@ -732,15 +768,15 @@ __code struct ao_config_var ao_config_vars[] = { ao_config_log_set, ao_config_log_show }, #endif #if HAS_IGNITE - { "i <0 dual, 1 apogee, 2 main>\0Set igniter mode", + { "i <0 dual, 1 apogee, 2 main>\0Igniter mode", ao_config_ignite_mode_set, ao_config_ignite_mode_show }, #endif #if HAS_AES - { "k <32 hex digits>\0Set AES encryption key", + { "k <32 hex digits>\0AES encryption key", ao_config_key_set, ao_config_key_show }, #endif #if AO_PYRO_NUM - { "P \0Configure pyro channels", + { "P \0Pyro channels", ao_pyro_set, ao_pyro_show }, #endif #if HAS_APRS @@ -748,8 +784,12 @@ __code struct ao_config_var ao_config_vars[] = { ao_config_aprs_set, ao_config_aprs_show }, #endif #if HAS_BEEP_CONFIG - { "b \0Configure beeper tone (freq = 1/2 (24e6/32) / beep", + { "b \0Beeper tone (freq = 1/2 (24e6/32) / beep", ao_config_beep_set, ao_config_beep_show }, +#endif +#if HAS_TRACKER + { "t \0Tracker start trigger distances", + ao_config_tracker_set, ao_config_tracker_show }, #endif { "s\0Show", ao_config_show, 0 }, diff --git a/src/kernel/ao_tracker.h b/src/kernel/ao_tracker.h new file mode 100644 index 00000000..43556965 --- /dev/null +++ b/src/kernel/ao_tracker.h @@ -0,0 +1,27 @@ +/* + * Copyright © 2014 Keith Packard + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. + */ + +#ifndef _AO_TRACKER_H_ +#define _AO_TRACKER_H_ + +#define AO_CONFIG_DEFAULT_TRACKER_START_HORIZ 1000 +#define AO_CONFIG_DEFAULT_TRACKER_START_VERT 100 + +void +ao_tracker_init(void); + +#endif /* _AO_TRACKER_H_ */ -- cgit v1.2.3 From ec3de3ac461f2380d23c5c5d948333a9a210c400 Mon Sep 17 00:00:00 2001 From: Keith Packard Date: Thu, 5 Jun 2014 21:35:41 -0700 Subject: altos: Fix config to set default log size for all devices with log Not just devices with flight Signed-off-by: Keith Packard --- src/kernel/ao_config.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/kernel/ao_config.c') diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c index e5f8efba..b4847cdd 100644 --- a/src/kernel/ao_config.c +++ b/src/kernel/ao_config.c @@ -133,7 +133,7 @@ _ao_config_get(void) ao_config.radio_cal = ao_radio_cal; #endif /* Fixups for minor version 4 */ -#if HAS_FLIGHT +#if HAS_LOG if (minor < 4) ao_config.flight_log_max = AO_CONFIG_DEFAULT_FLIGHT_LOG_MAX; #endif -- cgit v1.2.3 From da9575fce5ff4dfe83522e290973a01c43e4661f Mon Sep 17 00:00:00 2001 From: Keith Packard Date: Tue, 10 Jun 2014 09:42:43 -0700 Subject: altos: Make extra pyro channel firing time configurable This adds a 'I' parameter to set the extra pyro channel firing time (in ticks). This has no effect on the main/drogue channels. Signed-off-by: Keith Packard --- src/kernel/ao_config.c | 26 ++++++++++++++++++++++++++ src/kernel/ao_config.h | 5 ++++- src/kernel/ao_pyro.c | 2 +- 3 files changed, 31 insertions(+), 2 deletions(-) (limited to 'src/kernel/ao_config.c') diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c index b4847cdd..72170555 100644 --- a/src/kernel/ao_config.c +++ b/src/kernel/ao_config.c @@ -44,6 +44,7 @@ __xdata uint8_t ao_config_mutex; #define AO_CONFIG_DEFAULT_APOGEE_DELAY 0 #define AO_CONFIG_DEFAULT_IGNITE_MODE AO_IGNITE_MODE_DUAL #define AO_CONFIG_DEFAULT_PAD_ORIENTATION AO_PAD_ORIENTATION_ANTENNA_UP +#define AO_CONFIG_DEFAULT_PYRO_TIME AO_MS_TO_TICKS(50) #if HAS_EEPROM #ifndef USE_INTERNAL_FLASH #error Please define USE_INTERNAL_FLASH @@ -186,6 +187,10 @@ _ao_config_get(void) ao_config.tracker_start_horiz = AO_CONFIG_DEFAULT_TRACKER_START_HORIZ; ao_config.tracker_start_vert = AO_CONFIG_DEFAULT_TRACKER_START_VERT; } +#endif +#if AO_PYRO_NUM + if (minor < 18) + ao_config.pyro_time = AO_CONFIG_DEFAULT_PYRO_TIME; #endif ao_config.minor = AO_CONFIG_MINOR; ao_config_dirty = 1; @@ -713,6 +718,25 @@ ao_config_tracker_set(void) } #endif /* HAS_TRACKER */ +#if AO_PYRO_NUM +void +ao_config_pyro_time_show(void) +{ + printf ("Pyro time: %d\n", ao_config.pyro_time); +} + +void +ao_config_pyro_time_set(void) +{ + ao_cmd_decimal(); + if (ao_cmd_status != ao_cmd_success) + return; + _ao_config_edit_start(); + ao_config.pyro_time = ao_cmd_lex_i; + _ao_config_edit_finish(); +} +#endif + struct ao_config_var { __code char *str; void (*set)(void) __reentrant; @@ -778,6 +802,8 @@ __code struct ao_config_var ao_config_vars[] = { #if AO_PYRO_NUM { "P \0Pyro channels", ao_pyro_set, ao_pyro_show }, + { "I \0Pyro firing time", + ao_config_pyro_time_set, ao_config_pyro_time_show }, #endif #if HAS_APRS { "A \0APRS packet interval (0 disable)", diff --git a/src/kernel/ao_config.h b/src/kernel/ao_config.h index 7ad221c6..77f73fbe 100644 --- a/src/kernel/ao_config.h +++ b/src/kernel/ao_config.h @@ -53,7 +53,7 @@ #endif #define AO_CONFIG_MAJOR 1 -#define AO_CONFIG_MINOR 17 +#define AO_CONFIG_MINOR 18 #define AO_AES_LEN 16 @@ -99,6 +99,9 @@ struct ao_config { uint16_t tracker_start_horiz; /* minor version 17 */ uint16_t tracker_start_vert; /* minor version 17 */ #endif +#if AO_PYRO_NUM + uint16_t pyro_time; /* minor version 18 */ +#endif }; #define AO_IGNITE_MODE_DUAL 0 diff --git a/src/kernel/ao_pyro.c b/src/kernel/ao_pyro.c index 0ee7fbee..85d88d98 100644 --- a/src/kernel/ao_pyro.c +++ b/src/kernel/ao_pyro.c @@ -213,7 +213,7 @@ ao_pyro_pins_fire(uint16_t fire) if (fire & (1 << p)) ao_pyro_pin_set(p, 1); } - ao_delay(AO_MS_TO_TICKS(50)); + ao_delay(ao_config.pyro_time); for (p = 0; p < AO_PYRO_NUM; p++) { if (fire & (1 << p)) { ao_pyro_pin_set(p, 0); -- cgit v1.2.3 From 9d7f4fb6af0fee843191766858e39a481aeda347 Mon Sep 17 00:00:00 2001 From: Keith Packard Date: Tue, 10 Jun 2014 09:52:15 -0700 Subject: altos: Simplify tracker logic, removing boost detect This removes the ao_flight_state value from the tracker code and makes it simply log position information when the device has moved within the last 10 log intervals. This also changes the configuration parameters to define what 'motionless' means, and what interval to configure the GPS receiver for, log data and send telemetry. Signed-off-by: Keith Packard --- src/kernel/ao_config.c | 20 +-- src/kernel/ao_config.h | 4 +- src/kernel/ao_log_gps.c | 37 +----- src/kernel/ao_log_gps.h | 9 +- src/kernel/ao_tracker.c | 277 ++++++++++++++---------------------------- src/kernel/ao_tracker.h | 27 +--- src/telegps-v0.3/ao_telegps.c | 1 - src/telegps-v1.0/ao_telegps.c | 1 - 8 files changed, 113 insertions(+), 263 deletions(-) (limited to 'src/kernel/ao_config.c') diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c index 72170555..71445335 100644 --- a/src/kernel/ao_config.c +++ b/src/kernel/ao_config.c @@ -184,8 +184,8 @@ _ao_config_get(void) #endif #if HAS_TRACKER if (minor < 17) { - ao_config.tracker_start_horiz = AO_CONFIG_DEFAULT_TRACKER_START_HORIZ; - ao_config.tracker_start_vert = AO_CONFIG_DEFAULT_TRACKER_START_VERT; + ao_config.tracker_motion = AO_TRACKER_MOTION_DEFAULT; + ao_config.tracker_interval = AO_TRACKER_INTERVAL_DEFAULT; } #endif #if AO_PYRO_NUM @@ -695,25 +695,25 @@ void ao_config_tracker_show(void) { printf ("Tracker setting: %d %d\n", - ao_config.tracker_start_horiz, - ao_config.tracker_start_vert); + ao_config.tracker_motion, + ao_config.tracker_interval); } void ao_config_tracker_set(void) { - uint16_t h, v; + uint16_t m, i; ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - h = ao_cmd_lex_i; + m = ao_cmd_lex_i; ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - v = ao_cmd_lex_i; + i = ao_cmd_lex_i; _ao_config_edit_start(); - ao_config.tracker_start_horiz = h; - ao_config.tracker_start_vert = v; + ao_config.tracker_motion = m; + ao_config.tracker_interval = i; _ao_config_edit_finish(); } #endif /* HAS_TRACKER */ @@ -814,7 +814,7 @@ __code struct ao_config_var ao_config_vars[] = { ao_config_beep_set, ao_config_beep_show }, #endif #if HAS_TRACKER - { "t \0Tracker start trigger distances", + { "t \0Tracker configuration", ao_config_tracker_set, ao_config_tracker_show }, #endif { "s\0Show", diff --git a/src/kernel/ao_config.h b/src/kernel/ao_config.h index 77f73fbe..2b5cd352 100644 --- a/src/kernel/ao_config.h +++ b/src/kernel/ao_config.h @@ -96,8 +96,8 @@ struct ao_config { uint8_t mid_beep; /* minor version 16 */ #endif #if HAS_TRACKER - uint16_t tracker_start_horiz; /* minor version 17 */ - uint16_t tracker_start_vert; /* minor version 17 */ + uint16_t tracker_motion; /* minor version 17 */ + uint8_t tracker_interval; /* minor version 17 */ #endif #if AO_PYRO_NUM uint16_t pyro_time; /* minor version 18 */ diff --git a/src/kernel/ao_log_gps.c b/src/kernel/ao_log_gps.c index e9e573a5..8bf529f4 100644 --- a/src/kernel/ao_log_gps.c +++ b/src/kernel/ao_log_gps.c @@ -60,51 +60,17 @@ ao_log_gps(__xdata struct ao_log_gps *log) __reentrant return wrote; } - -static int32_t prev_lat, prev_lon; -static int16_t prev_alt; -static uint8_t has_prev, unmoving; - -#define GPS_SPARSE_UNMOVING_REPORTS 10 -#define GPS_SPARSE_UNMOVING_GROUND 10 -#define GPS_SPARSE_UNMOVING_AIR 10 - -uint8_t -ao_log_gps_should_log(int32_t lat, int32_t lon, int16_t alt) -{ - if (has_prev && ao_log_running) { - uint32_t h = ao_distance(prev_lat, prev_lon, lat, lon); - uint16_t v = alt > prev_alt ? (alt - prev_alt) : (prev_alt - alt); - - if (h < GPS_SPARSE_UNMOVING_GROUND && v < GPS_SPARSE_UNMOVING_AIR) { - if (unmoving < GPS_SPARSE_UNMOVING_REPORTS) - ++unmoving; - } else - unmoving = 0; - } else - unmoving = 0; - - prev_lat = lat; - prev_lon = lon; - prev_alt = alt; - has_prev = 1; - return unmoving >= GPS_SPARSE_UNMOVING_REPORTS; -} - void ao_log_gps_flight(void) { log.type = AO_LOG_FLIGHT; log.tick = ao_time(); log.u.flight.flight = ao_flight_number; - log.u.flight.start_altitude = ao_tracker_start_altitude; - log.u.flight.start_latitude = ao_tracker_start_latitude; - log.u.flight.start_longitude = ao_tracker_start_longitude; ao_log_gps(&log); } void -ao_log_gps_data(uint16_t tick, uint8_t state, struct ao_telemetry_location *gps_data) +ao_log_gps_data(uint16_t tick, struct ao_telemetry_location *gps_data) { log.tick = tick; log.type = AO_LOG_GPS_TIME; @@ -126,7 +92,6 @@ ao_log_gps_data(uint16_t tick, uint8_t state, struct ao_telemetry_location *gps_ log.u.gps.hdop = gps_data->hdop; log.u.gps.vdop = gps_data->vdop; log.u.gps.mode = gps_data->mode; - log.u.gps.state = state; ao_log_gps(&log); } diff --git a/src/kernel/ao_log_gps.h b/src/kernel/ao_log_gps.h index 733db19b..5851f4d1 100644 --- a/src/kernel/ao_log_gps.h +++ b/src/kernel/ao_log_gps.h @@ -18,6 +18,9 @@ #include "ao.h" #include "ao_telemetry.h" +#ifndef _AO_LOG_GPS_H_ +#define _AO_LOG_GPS_H_ + uint8_t ao_log_gps_should_log(int32_t lat, int32_t lon, int16_t alt); @@ -25,8 +28,6 @@ void ao_log_gps_flight(void); void -ao_log_gps_data(uint16_t tick, uint8_t state, struct ao_telemetry_location *gps_data); - -void -ao_log_gps_tracking(uint16_t tick, struct ao_telemetry_satellite *gps_tracking_data); +ao_log_gps_data(uint16_t tick, struct ao_telemetry_location *gps_data); +#endif /* _AO_LOG_GPS_H_ */ diff --git a/src/kernel/ao_tracker.c b/src/kernel/ao_tracker.c index cdf147cd..fb9e75d0 100644 --- a/src/kernel/ao_tracker.c +++ b/src/kernel/ao_tracker.c @@ -23,10 +23,7 @@ #include #include -enum ao_flight_state ao_flight_state; - -static uint8_t ao_tracker_force_telem; -static uint8_t ao_tracker_force_launch; +static uint8_t ao_tracker_force_telem; #if HAS_USB_CONNECT static inline uint8_t @@ -38,157 +35,22 @@ ao_usb_connected(void) #define ao_usb_connected() 1 #endif -#define STARTUP_AVERAGE 5 - -int32_t ao_tracker_start_latitude; -int32_t ao_tracker_start_longitude; -int16_t ao_tracker_start_altitude; - -struct ao_tracker_data ao_tracker_data[AO_TRACKER_RING]; -uint8_t ao_tracker_head; -static uint8_t ao_tracker_log_pos; - -static uint16_t telem_rate; -static uint8_t gps_rate; -static uint8_t telem_enabled; - -static int64_t lat_sum, lon_sum; -static int32_t alt_sum; -static int nsamples; - -static void -ao_tracker_state_update(struct ao_tracker_data *tracker) -{ - uint16_t new_telem_rate; - uint8_t new_gps_rate; - uint8_t new_telem_enabled; - uint32_t ground_distance; - int16_t height; - uint16_t speed; - - new_gps_rate = gps_rate; - new_telem_rate = telem_rate; - - new_telem_enabled = ao_tracker_force_telem || !ao_usb_connected(); - - /* Don't change anything if GPS isn't locked */ - if ((tracker->new & AO_GPS_NEW_DATA) && - (tracker->gps_data.flags & (AO_GPS_VALID|AO_GPS_COURSE_VALID)) == - (AO_GPS_VALID|AO_GPS_COURSE_VALID)) - { - switch (ao_flight_state) { - case ao_flight_startup: - new_telem_rate = AO_SEC_TO_TICKS(1); - new_gps_rate = 1; - - /* startup to pad when GPS locks */ - - lat_sum += tracker->gps_data.latitude; - lon_sum += tracker->gps_data.longitude; - alt_sum += tracker->gps_data.altitude; - - ++nsamples; - - if (nsamples >= STARTUP_AVERAGE) { - ao_flight_state = ao_flight_pad; - ao_wakeup(&ao_flight_state); - ao_tracker_start_latitude = lat_sum / nsamples; - ao_tracker_start_longitude = lon_sum / nsamples; - ao_tracker_start_altitude = alt_sum / nsamples; - } - break; - case ao_flight_pad: - new_telem_rate = AO_SEC_TO_TICKS(1); - new_gps_rate = 1; - - ground_distance = ao_distance(tracker->gps_data.latitude, - tracker->gps_data.longitude, - ao_tracker_start_latitude, - ao_tracker_start_longitude); - height = tracker->gps_data.altitude - ao_tracker_start_altitude; - if (height < 0) - height = -height; - - if (ground_distance >= ao_config.tracker_start_horiz || - height >= ao_config.tracker_start_vert || - ao_tracker_force_launch) - { - ao_flight_state = ao_flight_drogue; - ao_wakeup(&ao_flight_state); - ao_tracker_log_pos = ao_tracker_ring_next(ao_tracker_head); - ao_log_start(); - ao_log_gps_flight(); - } - break; - case ao_flight_drogue: - /* Modulate data rates based on speed (in cm/s) */ - if (tracker->gps_data.climb_rate < 0) - speed = -tracker->gps_data.climb_rate; - else - speed = tracker->gps_data.climb_rate; - speed += tracker->gps_data.ground_speed; - - if (speed < AO_TRACKER_NOT_MOVING) { - new_telem_rate = AO_SEC_TO_TICKS(10); - new_gps_rate = 10; - } else { - new_telem_rate = AO_SEC_TO_TICKS(1); - new_gps_rate = 1; - } - break; - default: - break; - } - } - - if (new_telem_rate != telem_rate || new_telem_enabled != telem_enabled) { - if (new_telem_enabled) - ao_telemetry_set_interval(new_telem_rate); - else - ao_telemetry_set_interval(0); - telem_rate = new_telem_rate; - telem_enabled = new_telem_enabled; - } - - if (new_gps_rate != gps_rate) { - ao_gps_set_rate(new_gps_rate); - gps_rate = new_gps_rate; - } -} - -#if HAS_LOG -static uint8_t ao_tracker_should_log; - -static void -ao_tracker_log(void) -{ - struct ao_tracker_data *tracker; - - if (ao_log_running) { - while (ao_tracker_log_pos != ao_tracker_head) { - tracker = &ao_tracker_data[ao_tracker_log_pos]; - if (tracker->new & AO_GPS_NEW_DATA) { - ao_tracker_should_log = ao_log_gps_should_log(tracker->gps_data.latitude, - tracker->gps_data.longitude, - tracker->gps_data.altitude); - if (ao_tracker_should_log) - ao_log_gps_data(tracker->tick, tracker->state, &tracker->gps_data); - } - if (tracker->new & AO_GPS_NEW_TRACKING) { - if (ao_tracker_should_log) - ao_log_gps_tracking(tracker->tick, &tracker->gps_tracking_data); - } - ao_tracker_log_pos = ao_tracker_ring_next(ao_tracker_log_pos); - } - } -} -#endif +static int32_t last_log_latitude, last_log_longitude; +static int16_t last_log_altitude; +static uint8_t unmoving; +static uint8_t log_started; +static struct ao_telemetry_location gps_data; +static uint8_t tracker_running; +static uint16_t tracker_interval; static void ao_tracker(void) { - uint8_t new; - struct ao_tracker_data *tracker; + uint8_t new; + int32_t ground_distance; + int16_t height; + uint16_t gps_tick; + uint8_t new_tracker_running; #if HAS_ADC ao_timer_set_adc_interval(100); @@ -197,45 +59,83 @@ ao_tracker(void) #if !HAS_USB_CONNECT ao_tracker_force_telem = 1; #endif - - nsamples = 0; - lat_sum = 0; - lon_sum = 0; - alt_sum = 0; - ao_log_scan(); + ao_log_start(); ao_rdf_set(1); - ao_telemetry_set_interval(0); - telem_rate = AO_SEC_TO_TICKS(1); - telem_enabled = 0; - gps_rate = 1; - ao_flight_state = ao_flight_startup; + tracker_interval = ao_config.tracker_interval; + ao_gps_set_rate(tracker_interval); + for (;;) { + + /** Wait for new GPS data + */ while (!(new = ao_gps_new)) ao_sleep(&ao_gps_new); - - /* Stick GPS data into the ring */ ao_mutex_get(&ao_gps_mutex); - tracker = &ao_tracker_data[ao_tracker_head]; - tracker->tick = ao_gps_tick; - tracker->new = new; - tracker->state = ao_flight_state; - tracker->gps_data = ao_gps_data; - tracker->gps_tracking_data = ao_gps_tracking_data; - ao_tracker_head = ao_tracker_ring_next(ao_tracker_head); - + gps_data = ao_gps_data; + gps_tick = ao_gps_tick; ao_gps_new = 0; ao_mutex_put(&ao_gps_mutex); - /* Update state based on current GPS data */ - ao_tracker_state_update(tracker); + new_tracker_running = ao_tracker_force_telem || !ao_usb_connected(); -#if HAS_LOG - /* Log all gps data */ - ao_tracker_log(); -#endif + if (ao_config.tracker_interval != tracker_interval) { + tracker_interval = ao_config.tracker_interval; + ao_gps_set_rate(tracker_interval); + + /* force telemetry interval to be reset */ + tracker_running = 0; + } + + if (new_tracker_running && !tracker_running) { + ao_telemetry_set_interval(AO_SEC_TO_TICKS(tracker_interval)); + } else if (!new_tracker_running && tracker_running) { + ao_telemetry_set_interval(0); + } + + tracker_running = new_tracker_running; + + if (!tracker_running) + continue; + + if (new & AO_GPS_NEW_DATA) { + if ((gps_data.flags & (AO_GPS_VALID|AO_GPS_COURSE_VALID)) == + (AO_GPS_VALID|AO_GPS_COURSE_VALID)) + { + if (log_started) { + ground_distance = ao_distance(gps_data.latitude, gps_data.longitude, + last_log_latitude, last_log_longitude); + height = last_log_altitude - gps_data.altitude; + if (height < 0) + height = -height; + if (ground_distance <= ao_config.tracker_motion && + height <= ao_config.tracker_motion) + { + if (unmoving < AO_TRACKER_MOTION_COUNT) + unmoving++; + } else + unmoving = 0; + } + } else { + if (!log_started) + continue; + if (unmoving < AO_TRACKER_MOTION_COUNT) + unmoving++; + } + + if (unmoving < AO_TRACKER_MOTION_COUNT) { + if (!log_started) { + ao_log_gps_flight(); + log_started = 1; + } + ao_log_gps_data(gps_tick, &gps_data); + last_log_latitude = gps_data.latitude; + last_log_longitude = gps_data.longitude; + last_log_altitude = gps_data.altitude; + } + } } } @@ -244,18 +144,23 @@ static struct ao_task ao_tracker_task; static void ao_tracker_set_telem(void) { - uint8_t telem, launch; + uint8_t telem; ao_cmd_hex(); telem = ao_cmd_lex_i; - ao_cmd_hex(); - launch = ao_cmd_lex_i; - if (ao_cmd_status == ao_cmd_success) { + if (ao_cmd_status == ao_cmd_success) ao_tracker_force_telem = telem; - ao_tracker_force_launch = launch; - } ao_cmd_status = ao_cmd_success; - printf ("flight %d force telem %d force launch %d\n", - ao_flight_number, ao_tracker_force_telem, ao_tracker_force_launch); + printf ("flight: %d\n", ao_flight_number); + printf ("force_telem: %d\n", ao_tracker_force_telem); + printf ("log_started: %d\n", log_started); + printf ("unmoving: %d\n", unmoving); + printf ("latitude: %ld\n", (long) gps_data.latitude); + printf ("longitude: %ld\n", (long) gps_data.longitude); + printf ("altitude: %d\n", gps_data.altitude); + printf ("log_running: %d\n", ao_log_running); + printf ("log_start_pos: %ld\n", (long) ao_log_start_pos); + printf ("log_cur_pos: %ld\n", (long) ao_log_current_pos); + printf ("log_end_pos: %ld\n", (long) ao_log_end_pos); } static const struct ao_cmds ao_tracker_cmds[] = { diff --git a/src/kernel/ao_tracker.h b/src/kernel/ao_tracker.h index 63bdaf2f..a0fd2f49 100644 --- a/src/kernel/ao_tracker.h +++ b/src/kernel/ao_tracker.h @@ -18,31 +18,12 @@ #ifndef _AO_TRACKER_H_ #define _AO_TRACKER_H_ -#define AO_CONFIG_DEFAULT_TRACKER_START_HORIZ 1000 -#define AO_CONFIG_DEFAULT_TRACKER_START_VERT 100 +/* Any motion more than this will result in a log entry */ -/* Speeds for the various modes, 2m/s seems reasonable for 'not moving' */ -#define AO_TRACKER_NOT_MOVING 200 +#define AO_TRACKER_MOTION_DEFAULT 10 +#define AO_TRACKER_INTERVAL_DEFAULT 1 -extern int32_t ao_tracker_start_latitude; -extern int32_t ao_tracker_start_longitude; -extern int16_t ao_tracker_start_altitude; - -#define AO_TRACKER_RING 4 - -struct ao_tracker_data { - uint16_t tick; - uint8_t new; - uint8_t state; - struct ao_telemetry_location gps_data; - struct ao_telemetry_satellite gps_tracking_data; -}; - -extern struct ao_tracker_data ao_tracker_data[AO_TRACKER_RING]; -extern uint8_t ao_tracker_head; - -#define ao_tracker_ring_next(n) (((n) + 1) & (AO_TRACKER_RING-1)) -#define ao_tracker_ring_prev(n) (((n) - 1) & (AO_TRACKER_RING-1)) +#define AO_TRACKER_MOTION_COUNT 10 void ao_tracker_init(void); diff --git a/src/telegps-v0.3/ao_telegps.c b/src/telegps-v0.3/ao_telegps.c index bc7eeea8..dd699ecf 100644 --- a/src/telegps-v0.3/ao_telegps.c +++ b/src/telegps-v0.3/ao_telegps.c @@ -52,7 +52,6 @@ main(void) ao_tracker_init(); ao_telemetry_init(); - ao_telemetry_set_interval(AO_SEC_TO_TICKS(1)); #if HAS_SAMPLE_PROFILE ao_sample_profile_init(); diff --git a/src/telegps-v1.0/ao_telegps.c b/src/telegps-v1.0/ao_telegps.c index 1185a5dd..7a71699b 100644 --- a/src/telegps-v1.0/ao_telegps.c +++ b/src/telegps-v1.0/ao_telegps.c @@ -55,7 +55,6 @@ main(void) ao_tracker_init(); ao_telemetry_init(); - ao_telemetry_set_interval(AO_SEC_TO_TICKS(1)); #if HAS_SAMPLE_PROFILE ao_sample_profile_init(); -- cgit v1.2.3