diff options
Diffstat (limited to 'src/kernel')
70 files changed, 1077 insertions, 801 deletions
diff --git a/src/kernel/ao.h b/src/kernel/ao.h index 0a3981d7..9baae8b4 100644 --- a/src/kernel/ao.h +++ b/src/kernel/ao.h @@ -23,22 +23,18 @@ #include <stdio.h> #include <string.h> #include <stddef.h> +#include <stdbool.h> #include <ao_pins.h> #include <ao_arch.h> -#define TRUE 1 -#define FALSE 0 +/* replace stdio macros with direct calls to our functions */ +#undef putchar +#undef getchar +#define putchar(c) ao_putchar(c) +#define getchar ao_getchar -/* Convert a __data pointer into an __xdata pointer */ -#ifndef DATA_TO_XDATA -#define DATA_TO_XDATA(a) (a) -#endif -#ifndef PDATA_TO_XDATA -#define PDATA_TO_XDATA(a) (a) -#endif -#ifndef CODE_TO_XDATA -#define CODE_TO_XDATA(a) (a) -#endif +extern int ao_putchar(char c); +extern char ao_getchar(void); #ifndef HAS_TASK #define HAS_TASK 1 @@ -86,6 +82,19 @@ void ao_panic(uint8_t reason); /* + * ao_romconfig.c + */ + +#define AO_ROMCONFIG_VERSION 2 + +extern AO_ROMCONFIG_SYMBOL uint16_t ao_romconfig_version; +extern AO_ROMCONFIG_SYMBOL uint16_t ao_romconfig_check; +extern AO_ROMCONFIG_SYMBOL uint16_t ao_serial_number; +#if HAS_RADIO +extern AO_ROMCONFIG_SYMBOL uint32_t ao_radio_cal; +#endif + +/* * ao_timer.c */ @@ -94,7 +103,7 @@ ao_panic(uint8_t reason); #define AO_TICK_SIGNED int16_t #endif -extern volatile __data AO_TICK_TYPE ao_tick_count; +extern volatile AO_TICK_TYPE ao_tick_count; /* Our timer runs at 100Hz */ #ifndef AO_HERTZ @@ -115,10 +124,6 @@ ao_delay(uint16_t ticks); void ao_timer_set_adc_interval(uint8_t interval); -/* Timer interrupt */ -void -ao_timer_isr(void) ao_arch_interrupt(9); - /* Initialize the timer */ void ao_timer_init(void); @@ -143,13 +148,13 @@ ao_clock_resume(void); #ifndef ao_mutex_get uint8_t -ao_mutex_try(__xdata uint8_t *ao_mutex, uint8_t task_id) __reentrant; +ao_mutex_try(uint8_t *ao_mutex, uint8_t task_id); void -ao_mutex_get(__xdata uint8_t *ao_mutex) __reentrant; +ao_mutex_get(uint8_t *ao_mutex); void -ao_mutex_put(__xdata uint8_t *ao_mutex) __reentrant; +ao_mutex_put(uint8_t *ao_mutex); #endif /* @@ -162,16 +167,14 @@ enum ao_cmd_status { ao_cmd_syntax_error = 2, }; -extern __pdata uint16_t ao_cmd_lex_i; -extern __pdata uint32_t ao_cmd_lex_u32; -extern __pdata char ao_cmd_lex_c; -extern __pdata enum ao_cmd_status ao_cmd_status; +extern char ao_cmd_lex_c; +extern enum ao_cmd_status ao_cmd_status; void -ao_put_string(__code char *s); +ao_put_string(const char *s); void -ao_cmd_readline(void); +ao_cmd_readline(const char *prompt); char ao_cmd_lex(void); @@ -191,29 +194,29 @@ ao_cmd_white(void); int8_t ao_cmd_hexchar(char c); -void +uint8_t ao_cmd_hexbyte(void); -void +uint32_t ao_cmd_hex(void); -void -ao_cmd_decimal(void) __reentrant; +uint32_t +ao_cmd_decimal(void); /* Read a single hex nibble off stdin. */ uint8_t ao_getnibble(void); uint8_t -ao_match_word(__code char *word); +ao_match_word(const char *word); struct ao_cmds { void (*func)(void); - __code char *help; + const char *help; }; void -ao_cmd_register(const __code struct ao_cmds *cmds); +ao_cmd_register(const struct ao_cmds *cmds); void ao_cmd_init(void); @@ -240,7 +243,7 @@ ao_cmd_filter(void); #include <ao_beep.h> #endif -#if LEDS_AVAILABLE +#if LEDS_AVAILABLE || HAS_LED #include <ao_led.h> #endif @@ -297,13 +300,13 @@ ao_report_init(void); #if HAS_BARO /* pressure from the sensor to altitude in meters */ alt_t -ao_pres_to_altitude(pres_t pres) __reentrant; +ao_pres_to_altitude(pres_t pres); pres_t -ao_altitude_to_pres(alt_t alt) __reentrant; +ao_altitude_to_pres(alt_t alt); int16_t -ao_temp_to_dC(int16_t temp) __reentrant; +ao_temp_to_dC(int16_t temp); #endif /* @@ -379,11 +382,11 @@ ao_spi_slave(void); #define AO_GPS_NEW_DATA 1 #define AO_GPS_NEW_TRACKING 2 -extern __xdata uint8_t ao_gps_new; -extern __pdata uint16_t ao_gps_tick; -extern __xdata uint8_t ao_gps_mutex; -extern __xdata struct ao_telemetry_location ao_gps_data; -extern __xdata struct ao_telemetry_satellite ao_gps_tracking_data; +extern uint8_t ao_gps_new; +extern uint16_t ao_gps_tick; +extern uint8_t ao_gps_mutex; +extern struct ao_telemetry_location ao_gps_data; +extern struct ao_telemetry_satellite ao_gps_tracking_data; struct ao_gps_orig { uint8_t year; @@ -423,13 +426,13 @@ void ao_gps(void); void -ao_gps_print(__xdata struct ao_gps_orig *gps_data); +ao_gps_print(struct ao_gps_orig *gps_data); void -ao_gps_tracking_print(__xdata struct ao_gps_tracking_orig *gps_tracking_data); +ao_gps_tracking_print(struct ao_gps_tracking_orig *gps_tracking_data); void -ao_gps_show(void) __reentrant; +ao_gps_show(void); void ao_gps_init(void); @@ -560,9 +563,9 @@ ao_telemetry_tiny_init(void); * ao_radio.c */ -extern __xdata uint8_t ao_radio_dma; +extern uint8_t ao_radio_dma; -extern __xdata int8_t ao_radio_rssi; +extern int8_t ao_radio_rssi; #ifdef PKT_APPEND_STATUS_1_CRC_OK #define AO_RADIO_STATUS_CRC_OK PKT_APPEND_STATUS_1_CRC_OK @@ -587,17 +590,14 @@ extern __xdata int8_t ao_radio_rssi; #define HAS_RADIO_RATE HAS_RADIO #endif -void -ao_radio_general_isr(void) ao_arch_interrupt(16); - #if HAS_RADIO_XMIT void -ao_radio_send(const __xdata void *d, uint8_t size) __reentrant; +ao_radio_send(const void *d, uint8_t size); #endif #if HAS_RADIO_RECV uint8_t -ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout) __reentrant; +ao_radio_recv(void *d, uint8_t size, uint8_t timeout); void ao_radio_recv_abort(void); @@ -675,14 +675,14 @@ union ao_monitor { #endif }; -extern __xdata union ao_monitor ao_monitor_ring[AO_MONITOR_RING]; +extern union ao_monitor ao_monitor_ring[AO_MONITOR_RING]; #define ao_monitor_ring_next(n) (((n) + 1) & (AO_MONITOR_RING - 1)) #define ao_monitor_ring_prev(n) (((n) - 1) & (AO_MONITOR_RING - 1)) -extern __xdata uint8_t ao_monitoring_mutex; -extern __data uint8_t ao_monitoring; -extern __data uint8_t ao_monitor_head; +extern uint8_t ao_monitoring_mutex; +extern uint8_t ao_monitoring; +extern uint8_t ao_monitor_head; void ao_monitor(void); @@ -700,7 +700,7 @@ void ao_monitor_enable(void); void -ao_monitor_init(void) __reentrant; +ao_monitor_init(void); #endif @@ -712,27 +712,27 @@ ao_monitor_init(void) __reentrant; struct ao_stdio { int (*_pollchar)(void); /* Called with interrupts blocked */ - void (*putchar)(char c) __reentrant; + void (*putchar)(char c); void (*flush)(void); uint8_t echo; }; -extern __xdata struct ao_stdio ao_stdios[]; -extern __pdata int8_t ao_cur_stdio; -extern __pdata int8_t ao_num_stdios; +extern struct ao_stdio ao_stdios[]; +extern int8_t ao_cur_stdio; +extern int8_t ao_num_stdios; void flush(void); -extern __xdata uint8_t ao_stdin_ready; +extern uint8_t ao_stdin_ready; uint8_t ao_echo(void); int8_t ao_add_stdio(int (*pollchar)(void), - void (*putchar)(char) __reentrant, - void (*flush)(void)) __reentrant; + void (*putchar)(char) , + void (*flush)(void)); /* * ao_ignite.c @@ -759,14 +759,14 @@ struct ao_ignition { uint8_t firing; }; -extern __code char * __code ao_igniter_status_names[]; +extern const char * const ao_igniter_status_names[]; -extern __xdata struct ao_ignition ao_ignition[2]; +extern struct ao_ignition ao_ignition[2]; enum ao_igniter_status ao_igniter_status(enum ao_igniter igniter); -extern __pdata uint8_t ao_igniter_present; +extern uint8_t ao_igniter_present; void ao_ignite_set_pins(void); @@ -787,7 +787,7 @@ ao_igniter_init(void); /* * Set this to force the frequency to 434.550MHz */ -extern __xdata uint8_t ao_force_freq; +extern uint8_t ao_force_freq; #endif /* @@ -887,8 +887,8 @@ union ao_log_single { uint8_t bytes[AO_LOG_SINGLE_SIZE]; }; -extern __xdata union ao_log_single ao_log_single_write_data; -extern __xdata union ao_log_single ao_log_single_read_data; +extern union ao_log_single ao_log_single_write_data; +extern union ao_log_single ao_log_single_read_data; void ao_log_single_extra_query(void); @@ -950,9 +950,6 @@ ao_terraui_init(void); */ #ifdef BATTERY_PIN -void -ao_battery_isr(void) ao_arch_interrupt(1); - uint16_t ao_battery_get(void); @@ -971,7 +968,7 @@ ao_sqrt(uint32_t op); * ao_freq.c */ -int32_t ao_freq_to_set(int32_t freq, int32_t cal) __reentrant; +int32_t ao_freq_to_set(int32_t freq, int32_t cal); /* * ao_ms5607.c diff --git a/src/kernel/ao_aes.h b/src/kernel/ao_aes.h index 5ae98424..f41b2e87 100644 --- a/src/kernel/ao_aes.h +++ b/src/kernel/ao_aes.h @@ -21,7 +21,7 @@ /* ao_aes.c */ -extern __xdata uint8_t ao_aes_mutex; +extern uint8_t ao_aes_mutex; /* AES keys and blocks are 128 bits */ @@ -40,14 +40,14 @@ void ao_aes_set_mode(enum ao_aes_mode mode); void -ao_aes_set_key(__xdata uint8_t *in); +ao_aes_set_key(uint8_t *in); void ao_aes_zero_iv(void); void -ao_aes_run(__xdata uint8_t *in, - __xdata uint8_t *out); +ao_aes_run(uint8_t *in, + uint8_t *out); void ao_aes_init(void); diff --git a/src/kernel/ao_balloon.c b/src/kernel/ao_balloon.c index 47b69e25..a5be8c16 100644 --- a/src/kernel/ao_balloon.c +++ b/src/kernel/ao_balloon.c @@ -34,16 +34,16 @@ #if HAS_SENSOR_ERRORS /* Any sensor can set this to mark the flight computer as 'broken' */ -__xdata uint8_t ao_sensor_errors; +uint8_t ao_sensor_errors; #endif -__pdata uint16_t ao_motor_number; /* number of motors burned so far */ +uint16_t ao_motor_number; /* number of motors burned so far */ /* Main flight thread. */ -__pdata enum ao_flight_state ao_flight_state; /* current flight state */ +enum ao_flight_state ao_flight_state; /* current flight state */ -__pdata uint8_t ao_flight_force_idle; +uint8_t ao_flight_force_idle; void ao_flight(void) @@ -96,7 +96,7 @@ ao_flight(void) ao_led_off(AO_LED_RED); } /* wakeup threads due to state change */ - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); break; case ao_flight_pad: @@ -118,7 +118,7 @@ ao_flight(void) ao_wakeup(&ao_gps_new); #endif - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } break; default: @@ -127,7 +127,7 @@ ao_flight(void) } } -static __xdata struct ao_task flight_task; +static struct ao_task flight_task; void ao_flight_init(void) diff --git a/src/kernel/ao_beep.h b/src/kernel/ao_beep.h index 1306af62..fdc150f1 100644 --- a/src/kernel/ao_beep.h +++ b/src/kernel/ao_beep.h @@ -85,7 +85,7 @@ ao_beep(uint8_t beep); /* Turn on the beeper for the specified time */ void -ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant; +ao_beep_for(uint8_t beep, uint16_t ticks); /* Initialize the beeper */ void diff --git a/src/kernel/ao_cmd.c b/src/kernel/ao_cmd.c index 7bb4654e..d1c049ac 100644 --- a/src/kernel/ao_cmd.c +++ b/src/kernel/ao_cmd.c @@ -19,10 +19,8 @@ #include "ao.h" #include "ao_task.h" -__pdata uint16_t ao_cmd_lex_i; -__pdata uint32_t ao_cmd_lex_u32; -__pdata char ao_cmd_lex_c; -__pdata enum ao_cmd_status ao_cmd_status; +char ao_cmd_lex_c; +enum ao_cmd_status ao_cmd_status; #ifndef AO_CMD_LEN #if AO_PYRO_NUM @@ -32,30 +30,26 @@ __pdata enum ao_cmd_status ao_cmd_status; #endif #endif -static __xdata char cmd_line[AO_CMD_LEN]; -static __pdata uint8_t cmd_len; -static __pdata uint8_t cmd_i; +static char cmd_line[AO_CMD_LEN]; +static uint8_t cmd_len; +static uint8_t cmd_i; + +static const char backspace[] = "\010 \010"; void -ao_put_string(__code char *s) +ao_put_string(const char *s) { char c; while ((c = *s++)) putchar(c); } -static void -backspace(void) -{ - ao_put_string ("\010 \010"); -} - void -ao_cmd_readline(void) +ao_cmd_readline(const char *prompt) { char c; if (ao_echo()) - ao_put_string("> "); + ao_put_string(prompt); cmd_len = 0; for (;;) { flush(); @@ -64,7 +58,7 @@ ao_cmd_readline(void) if (c == '\010' || c == '\177') { if (cmd_len != 0) { if (ao_echo()) - backspace(); + ao_put_string(backspace); --cmd_len; } continue; @@ -74,7 +68,7 @@ ao_cmd_readline(void) if (c == '\025') { while (cmd_len != 0) { if (ao_echo()) - backspace(); + ao_put_string(backspace); --cmd_len; } continue; @@ -174,55 +168,48 @@ ao_cmd_hexchar(char c) return -1; } -void -ao_cmd_hexbyte(void) +static uint32_t +get_hex(uint8_t lim) { + uint32_t result = 0; uint8_t i; - int8_t n; - ao_cmd_lex_i = 0; ao_cmd_white(); - for (i = 0; i < 2; i++) { - n = ao_cmd_hexchar(ao_cmd_lex_c); + for (i = 0; i < lim; i++) { + int8_t n = ao_cmd_hexchar(ao_cmd_lex_c); if (n < 0) { - ao_cmd_status = ao_cmd_syntax_error; + if (i == 0 || lim != 0xff) + ao_cmd_status = ao_cmd_lex_error; break; } - ao_cmd_lex_i = (ao_cmd_lex_i << 4) | n; + result = (result << 4) | n; ao_cmd_lex(); } + return result; } -void -ao_cmd_hex(void) +uint8_t +ao_cmd_hexbyte(void) { - __pdata uint8_t r = ao_cmd_lex_error; - int8_t n; + return get_hex(2); +} - ao_cmd_lex_i = 0; - ao_cmd_white(); - for(;;) { - n = ao_cmd_hexchar(ao_cmd_lex_c); - if (n < 0) - break; - ao_cmd_lex_i = (ao_cmd_lex_i << 4) | n; - r = ao_cmd_success; - ao_cmd_lex(); - } - if (r != ao_cmd_success) - ao_cmd_status = r; +uint32_t +ao_cmd_hex(void) +{ + return get_hex(0xff); } -void -ao_cmd_decimal(void) __reentrant +uint32_t +ao_cmd_decimal(void) { + uint32_t result = 0; uint8_t r = ao_cmd_lex_error; - ao_cmd_lex_u32 = 0; ao_cmd_white(); for(;;) { if ('0' <= ao_cmd_lex_c && ao_cmd_lex_c <= '9') - ao_cmd_lex_u32 = (ao_cmd_lex_u32 * 10) + (ao_cmd_lex_c - '0'); + result = result * 10 + (ao_cmd_lex_c - '0'); else break; r = ao_cmd_success; @@ -230,11 +217,11 @@ ao_cmd_decimal(void) __reentrant } if (r != ao_cmd_success) ao_cmd_status = r; - ao_cmd_lex_i = (uint16_t) ao_cmd_lex_u32; + return result; } uint8_t -ao_match_word(__code char *word) +ao_match_word(const char *word) { while (*word) { if (ao_cmd_lex_c != *word) { @@ -250,9 +237,9 @@ ao_match_word(__code char *word) static void echo(void) { - ao_cmd_hex(); + uint32_t v = ao_cmd_hex(); if (ao_cmd_status == ao_cmd_success) - ao_stdios[ao_cur_stdio].echo = ao_cmd_lex_i != 0; + ao_stdios[ao_cur_stdio].echo = v != 0; } static void @@ -321,16 +308,16 @@ version(void) #define NUM_CMDS 11 #endif -static __code struct ao_cmds *__xdata (ao_cmds[NUM_CMDS]); -static __pdata uint8_t ao_ncmds; +static const struct ao_cmds *(ao_cmds[NUM_CMDS]); +static uint8_t ao_ncmds; static void help(void) { - __pdata uint8_t cmds; - __pdata uint8_t cmd; - __code struct ao_cmds * __pdata cs; - __code const char *h; + uint8_t cmds; + uint8_t cmd; + const struct ao_cmds * cs; + const char *h; uint8_t e; for (cmds = 0; cmds < ao_ncmds; cmds++) { @@ -363,7 +350,7 @@ report(void) } void -ao_cmd_register(__code struct ao_cmds *cmds) +ao_cmd_register(const struct ao_cmds *cmds) { if (ao_ncmds >= NUM_CMDS) ao_panic(AO_PANIC_CMD); @@ -373,13 +360,13 @@ ao_cmd_register(__code struct ao_cmds *cmds) void ao_cmd(void) { - __pdata char c; + char c; uint8_t cmd, cmds; - __code struct ao_cmds * __xdata cs; - void (*__xdata func)(void); + const struct ao_cmds * cs; + void (*func)(void); for (;;) { - ao_cmd_readline(); + ao_cmd_readline("> "); ao_cmd_lex(); ao_cmd_white(); c = ao_cmd_lex_c; @@ -424,10 +411,10 @@ ao_loader(void) #endif #if HAS_TASK -__xdata struct ao_task ao_cmd_task; +struct ao_task ao_cmd_task; #endif -__code struct ao_cmds ao_base_cmds[] = { +const struct ao_cmds ao_base_cmds[] = { { help, "?\0Help" }, #if HAS_TASK_INFO && HAS_TASK { ao_task_info, "T\0Tasks" }, diff --git a/src/kernel/ao_companion.h b/src/kernel/ao_companion.h index 4c161455..bd702fe3 100644 --- a/src/kernel/ao_companion.h +++ b/src/kernel/ao_companion.h @@ -44,11 +44,11 @@ struct ao_companion_setup { uint8_t channels; }; -extern __pdata uint8_t ao_companion_running; -extern __xdata uint8_t ao_companion_mutex; -extern __xdata struct ao_companion_command ao_companion_command; -extern __xdata struct ao_companion_setup ao_companion_setup; -extern __xdata uint16_t ao_companion_data[AO_COMPANION_MAX_CHANNELS]; +extern uint8_t ao_companion_running; +extern uint8_t ao_companion_mutex; +extern struct ao_companion_command ao_companion_command; +extern struct ao_companion_setup ao_companion_setup; +extern uint16_t ao_companion_data[AO_COMPANION_MAX_CHANNELS]; void ao_companion_init(void); diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c index 86d4838f..596a0410 100644 --- a/src/kernel/ao_config.c +++ b/src/kernel/ao_config.c @@ -30,13 +30,13 @@ #include <ao_tracker.h> #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; +struct ao_config ao_config; +uint8_t ao_config_loaded; +uint8_t ao_config_dirty; +uint8_t ao_config_mutex; #if HAS_FORCE_FREQ -__xdata uint8_t ao_force_freq; +uint8_t ao_force_freq; #endif #ifndef AO_CONFIG_DEFAULT_APRS_INTERVAL @@ -100,7 +100,7 @@ ao_config_put(void) #if HAS_RADIO #if HAS_RADIO_FORWARD -__xdata uint32_t ao_send_radio_setting; +uint32_t ao_send_radio_setting; #endif void @@ -135,7 +135,7 @@ _ao_config_get(void) /* 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), + ao_xmemcpy(&ao_config.callsign, AO_CONFIG_DEFAULT_CALLSIGN, sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1); ao_config._legacy_radio_channel = 0; } @@ -246,7 +246,7 @@ _ao_config_get(void) #if HAS_RADIO_RATE ao_config.radio_rate = AO_CONFIG_DEFAULT_RADIO_RATE; #endif - ao_xmemcpy(&ao_config.callsign, CODE_TO_XDATA(AO_CONFIG_DEFAULT_CALLSIGN), + ao_xmemcpy(&ao_config.callsign, AO_CONFIG_DEFAULT_CALLSIGN, sizeof(AO_CONFIG_DEFAULT_CALLSIGN) - 1); } #endif @@ -283,10 +283,10 @@ ao_config_callsign_show(void) } void -ao_config_callsign_set(void) __reentrant +ao_config_callsign_set(void) { uint8_t c; - static __xdata char callsign[AO_MAX_CALLSIGN + 1]; + static char callsign[AO_MAX_CALLSIGN + 1]; ao_xmemset(callsign, '\0', sizeof callsign); ao_cmd_white(); @@ -309,20 +309,20 @@ ao_config_callsign_set(void) __reentrant #if HAS_RADIO void -ao_config_frequency_show(void) __reentrant +ao_config_frequency_show(void) { printf("Frequency: %ld\n", ao_config.frequency); } void -ao_config_frequency_set(void) __reentrant +ao_config_frequency_set(void) { - ao_cmd_decimal(); + uint32_t r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; _ao_config_edit_start(); - ao_config.frequency = ao_cmd_lex_u32; + ao_config.frequency = r; ao_config_set_radio(); _ao_config_edit_finish(); #if HAS_RADIO_RECV @@ -334,14 +334,14 @@ ao_config_frequency_set(void) __reentrant #if HAS_RADIO_FORWARD void -ao_config_send_frequency_show(void) __reentrant +ao_config_send_frequency_show(void) { printf("Send frequency: %ld\n", ao_config.send_frequency); } void -ao_config_send_frequency_set(void) __reentrant +ao_config_send_frequency_set(void) { ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) @@ -360,26 +360,26 @@ ao_config_send_frequency_set(void) __reentrant #if HAS_FLIGHT void -ao_config_main_deploy_show(void) __reentrant +ao_config_main_deploy_show(void) { printf("Main deploy: %d meters\n", ao_config.main_deploy); } void -ao_config_main_deploy_set(void) __reentrant +ao_config_main_deploy_set(void) { - ao_cmd_decimal(); + uint32_t r = 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.main_deploy = r; _ao_config_edit_finish(); } #if HAS_ACCEL void -ao_config_accel_calibrate_show(void) __reentrant +ao_config_accel_calibrate_show(void) { printf("Accel cal +1g: %d -1g: %d\n", ao_config.accel_plus_g, ao_config.accel_minus_g); @@ -401,7 +401,7 @@ static int16_t accel_cal_through; #endif static int16_t -ao_config_accel_calibrate_auto(char *orientation) __reentrant +ao_config_accel_calibrate_auto(char *orientation) { uint16_t i; int32_t accel_total; @@ -421,7 +421,7 @@ ao_config_accel_calibrate_auto(char *orientation) __reentrant accel_total = 0; cal_data_ring = ao_sample_data; while (i) { - ao_sleep(DATA_TO_XDATA(&ao_sample_data)); + ao_sleep(&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 @@ -442,19 +442,20 @@ ao_config_accel_calibrate_auto(char *orientation) __reentrant } void -ao_config_accel_calibrate_set(void) __reentrant +ao_config_accel_calibrate_set(void) { int16_t up, down; + uint16_t r; #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(); + r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - if (ao_cmd_lex_i == 0) { + if (r == 0) { up = ao_config_accel_calibrate_auto("up"); #if HAS_GYRO accel_along_up = accel_cal_along; @@ -468,11 +469,11 @@ ao_config_accel_calibrate_set(void) __reentrant accel_through_down = accel_cal_through; #endif } else { - up = ao_cmd_lex_i; - ao_cmd_decimal(); + up = r; + r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - down = ao_cmd_lex_i; + down = r; } if (up >= down) { printf("Invalid accel: up (%d) down (%d)\n", @@ -483,7 +484,7 @@ ao_config_accel_calibrate_set(void) __reentrant ao_config.accel_plus_g = up; ao_config.accel_minus_g = down; #if HAS_GYRO - if (ao_cmd_lex_i == 0) { + if (r == 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; @@ -494,38 +495,38 @@ ao_config_accel_calibrate_set(void) __reentrant #endif /* HAS_ACCEL */ void -ao_config_apogee_delay_show(void) __reentrant +ao_config_apogee_delay_show(void) { printf("Apogee delay: %d seconds\n", ao_config.apogee_delay); } void -ao_config_apogee_delay_set(void) __reentrant +ao_config_apogee_delay_set(void) { - ao_cmd_decimal(); + uint32_t r = 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.apogee_delay = r; _ao_config_edit_finish(); } void -ao_config_apogee_lockout_show(void) __reentrant +ao_config_apogee_lockout_show(void) { printf ("Apogee lockout: %d seconds\n", ao_config.apogee_lockout); } void -ao_config_apogee_lockout_set(void) __reentrant +ao_config_apogee_lockout_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.apogee_lockout = r; _ao_config_edit_finish(); } @@ -533,19 +534,19 @@ ao_config_apogee_lockout_set(void) __reentrant #if HAS_RADIO void -ao_config_radio_cal_show(void) __reentrant +ao_config_radio_cal_show(void) { printf("Radio cal: %ld\n", ao_config.radio_cal); } void -ao_config_radio_cal_set(void) __reentrant +ao_config_radio_cal_set(void) { - ao_cmd_decimal(); + uint32_t r = 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.radio_cal = r; ao_config_set_radio(); _ao_config_edit_finish(); } @@ -558,23 +559,23 @@ ao_config_radio_cal_set(void) __reentrant #endif void -ao_config_radio_rate_show(void) __reentrant +ao_config_radio_rate_show(void) { printf("Telemetry rate: %d\n", ao_config.radio_rate); } void -ao_config_radio_rate_set(void) __reentrant +ao_config_radio_rate_set(void) { - ao_cmd_decimal(); + uint16_t r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - if (AO_RADIO_RATE_MAX < ao_cmd_lex_i) { + if (AO_RADIO_RATE_MAX < r) { ao_cmd_status = ao_cmd_lex_error; return; } _ao_config_edit_start(); - ao_config.radio_rate = ao_cmd_lex_i; + ao_config.radio_rate = r; _ao_config_edit_finish(); #if HAS_TELEMETRY ao_telemetry_reset_interval(); @@ -588,7 +589,7 @@ ao_config_radio_rate_set(void) __reentrant #if HAS_LOG void -ao_config_log_show(void) __reentrant +ao_config_log_show(void) { printf("Max flight log: %d kB\n", (int16_t) (ao_config.flight_log_max >> 10)); #if FLIGHT_LOG_APPEND @@ -611,26 +612,27 @@ ao_config_log_fix_append(void) #endif void -ao_config_log_set(void) __reentrant +ao_config_log_set(void) { #if FLIGHT_LOG_APPEND printf("Flight log fixed size %d kB\n", ao_storage_log_max >> 10); #else uint16_t block = (uint16_t) (ao_storage_block >> 10); uint16_t log_max = (uint16_t) (ao_storage_log_max >> 10); + uint32_t r; - ao_cmd_decimal(); + r = 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))) + else if (block > 1024 && (r & (block - 1))) printf("Flight log size must be multiple of %d kB\n", block); - else if (ao_cmd_lex_i > log_max) + else if (r > 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.flight_log_max = r << 10; _ao_config_edit_finish(); } #endif @@ -639,26 +641,26 @@ ao_config_log_set(void) __reentrant #if HAS_IGNITE void -ao_config_ignite_mode_show(void) __reentrant +ao_config_ignite_mode_show(void) { printf("Ignite mode: %d\n", ao_config.ignite_mode); } void -ao_config_ignite_mode_set(void) __reentrant +ao_config_ignite_mode_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.ignite_mode = r; _ao_config_edit_finish(); } #endif #if HAS_ACCEL void -ao_config_pad_orientation_show(void) __reentrant +ao_config_pad_orientation_show(void) { printf("Pad orientation: %d\n", ao_config.pad_orientation); } @@ -668,39 +670,38 @@ ao_config_pad_orientation_show(void) __reentrant #endif void -ao_config_pad_orientation_set(void) __reentrant +ao_config_pad_orientation_set(void) { - ao_cmd_decimal(); + uint16_t r = ao_cmd_decimal() & 1; 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) { + if (ao_config.pad_orientation != r) { 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.pad_orientation = r; _ao_config_edit_finish(); } #endif #if HAS_RADIO void -ao_config_radio_enable_show(void) __reentrant +ao_config_radio_enable_show(void) { printf("Radio enable: %d\n", ao_config.radio_enable); } void -ao_config_radio_enable_set(void) __reentrant +ao_config_radio_enable_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.radio_enable = r; _ao_config_edit_finish(); #if HAS_TELEMETRY && HAS_RADIO_RATE ao_telemetry_reset_interval(); @@ -710,10 +711,10 @@ ao_config_radio_enable_set(void) __reentrant #if HAS_AES -__xdata uint8_t ao_config_aes_seq = 1; +uint8_t ao_config_aes_seq = 1; void -ao_config_key_show(void) __reentrant +ao_config_key_show(void) { uint8_t i; printf("AES key: "); @@ -723,16 +724,16 @@ ao_config_key_show(void) __reentrant } void -ao_config_key_set(void) __reentrant +ao_config_key_set(void) { uint8_t i; _ao_config_edit_start(); for (i = 0; i < AO_AES_LEN; i++) { - ao_cmd_hexbyte(); + uint8_t b = ao_cmd_hexbyte(); if (ao_cmd_status != ao_cmd_success) break; - ao_config.aes_key[i] = ao_cmd_lex_i; + ao_config.aes_key[i] = b; } ++ao_config_aes_seq; _ao_config_edit_finish(); @@ -750,11 +751,11 @@ ao_config_aprs_show(void) void ao_config_aprs_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.aprs_interval = r; _ao_config_edit_finish(); ao_telemetry_reset_interval(); } @@ -772,11 +773,11 @@ ao_config_radio_amp_show(void) void ao_config_radio_amp_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.radio_amp = r; _ao_config_edit_finish(); } @@ -793,11 +794,11 @@ ao_config_radio_power_show(void) void ao_config_radio_power_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.radio_power = r; _ao_config_edit_finish(); } @@ -813,11 +814,11 @@ ao_config_beep_show(void) void ao_config_beep_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.mid_beep = r; _ao_config_edit_finish(); } #endif @@ -835,14 +836,12 @@ void ao_config_tracker_set(void) { uint16_t m, i; - ao_cmd_decimal(); + m = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - m = ao_cmd_lex_i; - ao_cmd_decimal(); + i = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - i = ao_cmd_lex_i; _ao_config_edit_start(); ao_config.tracker_motion = m; ao_config.tracker_interval = i; @@ -863,11 +862,11 @@ ao_config_pyro_time_show(void) void ao_config_pyro_time_set(void) { - ao_cmd_decimal(); + uint16_t r = 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.pyro_time = r; _ao_config_edit_finish(); } #endif @@ -883,26 +882,26 @@ ao_config_aprs_ssid_show(void) void ao_config_aprs_ssid_set(void) { - ao_cmd_decimal(); + uint16_t r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - if (15 < ao_cmd_lex_i) { + if (15 < r) { ao_cmd_status = ao_cmd_lex_error; return; } _ao_config_edit_start(); - ao_config.aprs_ssid = ao_cmd_lex_i; + ao_config.aprs_ssid = r; _ao_config_edit_finish(); } void ao_config_aprs_format_set(void) { - ao_cmd_decimal(); + uint16_t r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; _ao_config_edit_start(); - ao_config.aprs_format = ao_cmd_lex_i != 0; + ao_config.aprs_format = r != 0; _ao_config_edit_finish(); } @@ -923,11 +922,11 @@ ao_config_pad_box_show(void) void ao_config_pad_box_set(void) { - ao_cmd_decimal(); + uint16_t r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; _ao_config_edit_start(); - ao_config.pad_box = ao_cmd_lex_i; + ao_config.pad_box = r; _ao_config_edit_finish(); } @@ -940,33 +939,33 @@ ao_config_pad_idle_show(void) void ao_config_pad_idle_set(void) { - ao_cmd_decimal(); + uint16_t r = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; _ao_config_edit_start(); - ao_config.pad_idle = ao_cmd_lex_i; + ao_config.pad_idle = r; _ao_config_edit_finish(); } #endif struct ao_config_var { - __code char *str; - void (*set)(void) __reentrant; - void (*show)(void) __reentrant; + const char *str; + void (*set)(void); + void (*show)(void); }; static void -ao_config_help(void) __reentrant; +ao_config_help(void); static void -ao_config_show(void) __reentrant; +ao_config_show(void); #if HAS_EEPROM static void -ao_config_save(void) __reentrant; +ao_config_save(void); #endif -__code struct ao_config_var ao_config_vars[] = { +const struct ao_config_var ao_config_vars[] = { #if HAS_FLIGHT { "m <meters>\0Main deploy (m)", ao_config_main_deploy_set, ao_config_main_deploy_show, }, @@ -1078,7 +1077,7 @@ ao_config_set(void) } static void -ao_config_help(void) __reentrant +ao_config_help(void) { uint8_t cmd; for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++) @@ -1089,7 +1088,7 @@ ao_config_help(void) __reentrant } static void -ao_config_show(void) __reentrant +ao_config_show(void) { uint8_t cmd; ao_config_get(); @@ -1105,7 +1104,7 @@ ao_config_show(void) __reentrant #if HAS_EEPROM static void -ao_config_save(void) __reentrant +ao_config_save(void) { uint8_t saved = 0; ao_mutex_get(&ao_config_mutex); @@ -1122,7 +1121,7 @@ ao_config_save(void) __reentrant } #endif -__code struct ao_cmds ao_config_cmds[] = { +const struct ao_cmds ao_config_cmds[] = { { ao_config_set, "c <var> <value>\0Set config (? for help, s to show)" }, { 0, NULL }, }; diff --git a/src/kernel/ao_config.h b/src/kernel/ao_config.h index f730c73c..41aafcca 100644 --- a/src/kernel/ao_config.h +++ b/src/kernel/ao_config.h @@ -62,7 +62,7 @@ #define AO_AES_LEN 16 -extern __xdata uint8_t ao_config_aes_seq; +extern uint8_t ao_config_aes_seq; struct ao_config { uint8_t major; @@ -130,7 +130,7 @@ struct ao_config { #define AO_CONFIG_DEFAULT_APRS_FORMAT AO_APRS_FORMAT_COMPRESSED #if HAS_RADIO_FORWARD -extern __xdata uint32_t ao_send_radio_setting; +extern uint32_t ao_send_radio_setting; #endif #define AO_IGNITE_MODE_DUAL 0 @@ -151,8 +151,8 @@ extern __xdata uint32_t ao_send_radio_setting; /* Make sure AO_CONFIG_MAX_SIZE is big enough */ typedef uint8_t config_check_space[(int) (AO_CONFIG_MAX_SIZE - sizeof (struct ao_config))]; -extern __xdata struct ao_config ao_config; -extern __pdata uint8_t ao_config_loaded; +extern struct ao_config ao_config; +extern uint8_t ao_config_loaded; void _ao_config_edit_start(void); diff --git a/src/kernel/ao_convert.c b/src/kernel/ao_convert.c index 1cd62345..f3e523ec 100644 --- a/src/kernel/ao_convert.c +++ b/src/kernel/ao_convert.c @@ -30,7 +30,7 @@ static const ao_v_t altitude_table[] = { #define ALT_FRAC_MASK (ALT_FRAC_SCALE - 1) ao_v_t -ao_pres_to_altitude(int16_t pres) __reentrant +ao_pres_to_altitude(int16_t pres) { uint8_t o; int16_t part; @@ -46,7 +46,7 @@ ao_pres_to_altitude(int16_t pres) __reentrant #if AO_NEED_ALTITUDE_TO_PRES int16_t -ao_altitude_to_pres(ao_v_t alt) __reentrant +ao_altitude_to_pres(ao_v_t alt) { ao_v_t span, sub_span; uint8_t l, h, m; @@ -74,7 +74,7 @@ ao_altitude_to_pres(ao_v_t alt) __reentrant #if 0 int16_t -ao_temp_to_dC(int16_t temp) __reentrant +ao_temp_to_dC(int16_t temp) { int16_t ret; diff --git a/src/kernel/ao_data.c b/src/kernel/ao_data.c index 35d42b8f..536ffa2b 100644 --- a/src/kernel/ao_data.c +++ b/src/kernel/ao_data.c @@ -19,13 +19,13 @@ #include <ao.h> #include <ao_data.h> -volatile __xdata struct ao_data ao_data_ring[AO_DATA_RING]; -volatile __data uint8_t ao_data_head; -volatile __data uint8_t ao_data_present; +volatile struct ao_data ao_data_ring[AO_DATA_RING]; +volatile uint8_t ao_data_head; +volatile uint8_t ao_data_present; #ifndef ao_data_count void -ao_data_get(__xdata struct ao_data *packet) +ao_data_get(struct ao_data *packet) { #if HAS_FLIGHT uint8_t i = ao_data_ring_prev(ao_sample_data); diff --git a/src/kernel/ao_data.h b/src/kernel/ao_data.h index 88d0e916..3918f4e0 100644 --- a/src/kernel/ao_data.h +++ b/src/kernel/ao_data.h @@ -62,9 +62,16 @@ #define AO_DATA_MMA655X 0 #endif +#if HAS_ADXL375 +#include <ao_adxl375.h> +#define AO_DATA_ADXL375 (1 << 4) +#else +#define AO_DATA_ADXL375 0 +#endif + #ifdef AO_DATA_RING -#define AO_DATA_ALL (AO_DATA_ADC|AO_DATA_MS5607|AO_DATA_MPU6000|AO_DATA_HMC5883|AO_DATA_MMA655X|AO_DATA_MPU9250) +#define AO_DATA_ALL (AO_DATA_ADC|AO_DATA_MS5607|AO_DATA_MPU6000|AO_DATA_HMC5883|AO_DATA_MMA655X|AO_DATA_MPU9250|AO_DATA_ADXL375) struct ao_data { uint16_t tick; @@ -90,6 +97,9 @@ struct ao_data { #if HAS_MMA655X uint16_t mma655x; #endif +#if HAS_ADXL375 + struct ao_adxl375_sample adxl375; +#endif }; #define ao_data_ring_next(n) (((n) + 1) & (AO_DATA_RING - 1)) @@ -97,12 +107,12 @@ struct ao_data { /* Get a copy of the last complete sample set */ void -ao_data_get(__xdata struct ao_data *packet); +ao_data_get(struct ao_data *packet); -extern volatile __xdata struct ao_data ao_data_ring[AO_DATA_RING]; -extern volatile __data uint8_t ao_data_head; -extern volatile __data uint8_t ao_data_present; -extern volatile __data uint8_t ao_data_count; +extern volatile struct ao_data ao_data_ring[AO_DATA_RING]; +extern volatile uint8_t ao_data_head; +extern volatile uint8_t ao_data_present; +extern volatile uint8_t ao_data_count; /* * Mark a section of data as ready, check for data complete @@ -113,9 +123,7 @@ extern volatile __data uint8_t ao_data_count; * Wait until it is time to write a sensor sample; this is * signaled by the timer tick */ -#define AO_DATA_WAIT() do { \ - ao_sleep(DATA_TO_XDATA ((void *) &ao_data_count)); \ - } while (0) +#define AO_DATA_WAIT() ao_sleep((void *) &ao_data_count) #endif /* AO_DATA_RING */ @@ -295,6 +303,27 @@ typedef int16_t accel_t; #endif +#if !HAS_ACCEL && HAS_ADXL375 + +#define HAS_ACCEL 1 + +typedef int16_t accel_t; + +#ifndef AO_ADXL375_INVERT +#error AO_ADXL375_INVERT not defined +#endif + +#define ao_data_accel(packet) ((packet)->adxl375.AO_ADXL375_AXIS) +#if AO_ADXL375_INVERT +#define ao_data_accel_cook(packet) (-ao_data_accel(packet)) +#else +#define ao_data_accel_cook(packet) ao_data_accel(packet) +#endif +#define ao_data_set_accel(packet, accel) (ao_data_accel(packet) = (accel)) +#define ao_data_accel_invert(accel) (-(accel)) + +#endif /* HAS_ADXL375 */ + #if !HAS_ACCEL && HAS_MPU6000 #define HAS_ACCEL 1 @@ -402,4 +431,35 @@ typedef int16_t ao_mag_t; /* in raw sample units */ #endif +#ifdef AO_DATA_RING + +static inline void +ao_data_fill(int head) { + if (ao_data_present == AO_DATA_ALL) { +#if HAS_MS5607 + ao_data_ring[head].ms5607_raw = ao_ms5607_current; +#endif +#if HAS_MMA655X + ao_data_ring[head].mma655x = ao_mma655x_current; +#endif +#if HAS_HMC5883 + ao_data_ring[head].hmc5883 = ao_hmc5883_current; +#endif +#if HAS_MPU6000 + ao_data_ring[head].mpu6000 = ao_mpu6000_current; +#endif +#if HAS_MPU9250 + ao_data_ring[head].mpu9250 = ao_mpu9250_current; +#endif +#if HAS_ADXL375 + ao_data_ring[head].adxl375 = ao_adxl375_current; +#endif + ao_data_ring[head].tick = ao_tick_count; + ao_data_head = ao_data_ring_next(head); + ao_wakeup((void *) &ao_data_head); + } +} + +#endif + #endif /* _AO_DATA_H_ */ diff --git a/src/kernel/ao_ee_fake.c b/src/kernel/ao_ee_fake.c index 84c13000..cef0a438 100644 --- a/src/kernel/ao_ee_fake.c +++ b/src/kernel/ao_ee_fake.c @@ -23,7 +23,7 @@ * wants to call these functions */ uint8_t -ao_ee_write_config(uint8_t *buf, uint16_t len) __reentrant +ao_ee_write_config(uint8_t *buf, uint16_t len) { (void) buf; (void) len; @@ -31,7 +31,7 @@ ao_ee_write_config(uint8_t *buf, uint16_t len) __reentrant } uint8_t -ao_ee_read_config(uint8_t *buf, uint16_t len) __reentrant +ao_ee_read_config(uint8_t *buf, uint16_t len) { ao_xmemset(buf, '\0', len); return 1; diff --git a/src/kernel/ao_eeprom.h b/src/kernel/ao_eeprom.h index bd8b6725..f258c48c 100644 --- a/src/kernel/ao_eeprom.h +++ b/src/kernel/ao_eeprom.h @@ -26,13 +26,13 @@ extern const ao_pos_t ao_eeprom_total; */ uint8_t -ao_eeprom_write(ao_pos_t pos32, __xdata void *v, uint16_t len); +ao_eeprom_write(ao_pos_t pos32, void *v, uint16_t len); /* * Read from eeprom */ uint8_t -ao_eeprom_read(ao_pos_t pos, __xdata void *v, uint16_t len); +ao_eeprom_read(ao_pos_t pos, void *v, uint16_t len); /* * Initialize eeprom diff --git a/src/kernel/ao_fake_flight.c b/src/kernel/ao_fake_flight.c index 5880cf2b..ec8691e9 100644 --- a/src/kernel/ao_fake_flight.c +++ b/src/kernel/ao_fake_flight.c @@ -54,7 +54,7 @@ ao_fake_data_read(void) uint8_t *d = (void *) &ao_fake_next; if (getchar() == 0) - return FALSE; + return false; for (i = 0; i < sizeof (struct ao_data); i++) *d++ = getchar(); if (!ao_fake_has_offset) { @@ -64,7 +64,7 @@ ao_fake_data_read(void) } else ao_fake_next.tick += ao_fake_tick_offset; ao_fake_has_next = 1; - return TRUE; + return true; } static void @@ -118,10 +118,10 @@ ao_fake_calib_read(void) ) { printf ("Calibration data major version mismatch %d.%d <= %d.%d\n", ao_calib.major, ao_calib.minor, AO_FAKE_CALIB_MAJOR, AO_FAKE_CALIB_MINOR); - return FALSE; + return false; } ao_fake_calib_set(&ao_calib); - return TRUE; + return true; } static void @@ -133,14 +133,12 @@ ao_fake_flight(void) enum ao_flight_state my_state = ao_flight_invalid; int i; - ao_cmd_hex(); + calib_size = ao_cmd_hex(); if (ao_cmd_status != ao_cmd_success) return; - calib_size = ao_cmd_lex_i; - ao_cmd_hex(); + data_size = ao_cmd_hex(); if (ao_cmd_status != ao_cmd_success) return; - data_size = ao_cmd_lex_i; if ((unsigned) calib_size != sizeof (struct ao_fake_calib)) { printf ("calib size %d larger than actual size %d\n", calib_size, sizeof (struct ao_fake_calib)); diff --git a/src/kernel/ao_flight.c b/src/kernel/ao_flight.c index c2700d20..f72efa06 100644 --- a/src/kernel/ao_flight.c +++ b/src/kernel/ao_flight.c @@ -47,28 +47,28 @@ /* Main flight thread. */ -__pdata enum ao_flight_state ao_flight_state; /* current flight state */ -__pdata uint16_t ao_boost_tick; /* time of most recent boost detect */ -__pdata uint16_t ao_launch_tick; /* time of first boost detect */ -__pdata uint16_t ao_motor_number; /* number of motors burned so far */ +enum ao_flight_state ao_flight_state; /* current flight state */ +uint16_t ao_boost_tick; /* time of most recent boost detect */ +uint16_t ao_launch_tick; /* time of first boost detect */ +uint16_t ao_motor_number; /* number of motors burned so far */ #if HAS_SENSOR_ERRORS /* Any sensor can set this to mark the flight computer as 'broken' */ -__xdata uint8_t ao_sensor_errors; +uint8_t ao_sensor_errors; #endif /* * track min/max data over a long interval to detect * resting */ -static __data uint16_t ao_interval_end; -static __data ao_v_t ao_interval_min_height; -static __data ao_v_t ao_interval_max_height; +static uint16_t ao_interval_end; +static ao_v_t ao_interval_min_height; +static ao_v_t ao_interval_max_height; #if HAS_ACCEL -static __data ao_v_t ao_coast_avg_accel; +static ao_v_t ao_coast_avg_accel; #endif -__pdata uint8_t ao_flight_force_idle; +uint8_t ao_flight_force_idle; /* We also have a clock, which can be used to sanity check things in * case of other failures @@ -175,7 +175,7 @@ ao_flight(void) #endif } /* wakeup threads due to state change */ - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); break; case ao_flight_pad: @@ -219,7 +219,7 @@ ao_flight(void) ao_wakeup(&ao_gps_new); #endif - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } break; case ao_flight_boost: @@ -244,7 +244,7 @@ ao_flight(void) ao_flight_state = ao_flight_coast; #endif ++ao_motor_number; - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } break; #if HAS_ACCEL @@ -257,7 +257,7 @@ ao_flight(void) if (ao_speed < AO_MS_TO_SPEED(AO_MAX_BARO_SPEED)) { ao_flight_state = ao_flight_coast; - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } else goto check_re_boost; break; @@ -306,7 +306,7 @@ ao_flight(void) /* and enter drogue state */ ao_flight_state = ao_flight_drogue; - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } #if HAS_ACCEL else { @@ -315,7 +315,7 @@ ao_flight(void) if (ao_coast_avg_accel > AO_MSS_TO_ACCEL(20)) { ao_boost_tick = ao_sample_tick; ao_flight_state = ao_flight_boost; - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } } #endif @@ -352,7 +352,7 @@ ao_flight(void) ao_interval_min_height = ao_interval_max_height = ao_avg_height; ao_flight_state = ao_flight_main; - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } break; @@ -379,7 +379,7 @@ ao_flight(void) ao_timer_set_adc_interval(0); #endif - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } ao_interval_min_height = ao_interval_max_height = ao_avg_height; ao_interval_end = ao_sample_tick + AO_INTERVAL_TICKS; @@ -463,7 +463,7 @@ ao_orient_test_select(void) ao_orient_test = !ao_orient_test; } -__code struct ao_cmds ao_flight_cmds[] = { +const struct ao_cmds ao_flight_cmds[] = { { ao_flight_dump, "F\0Dump flight status" }, { ao_gyro_test, "G\0Test gyro code" }, { ao_orient_test_select,"O\0Test orientation code" }, @@ -471,7 +471,7 @@ __code struct ao_cmds ao_flight_cmds[] = { }; #endif -static __xdata struct ao_task flight_task; +static struct ao_task flight_task; void ao_flight_init(void) diff --git a/src/kernel/ao_flight.h b/src/kernel/ao_flight.h index 005c7e84..af6b0c55 100644 --- a/src/kernel/ao_flight.h +++ b/src/kernel/ao_flight.h @@ -38,21 +38,21 @@ enum ao_flight_state { ao_flight_test = 10 }; -extern __pdata enum ao_flight_state ao_flight_state; -extern __pdata uint16_t ao_boost_tick; -extern __pdata uint16_t ao_launch_tick; -extern __pdata uint16_t ao_motor_number; +extern enum ao_flight_state ao_flight_state; +extern uint16_t ao_boost_tick; +extern uint16_t ao_launch_tick; +extern uint16_t ao_motor_number; #if HAS_IMU || HAS_MMA655X #define HAS_SENSOR_ERRORS 1 #endif #if HAS_SENSOR_ERRORS -extern __xdata uint8_t ao_sensor_errors; +extern uint8_t ao_sensor_errors; #endif -extern __pdata uint16_t ao_launch_time; -extern __pdata uint8_t ao_flight_force_idle; +extern uint16_t ao_launch_time; +extern uint8_t ao_flight_force_idle; /* Flight thread */ void diff --git a/src/kernel/ao_flight_nano.c b/src/kernel/ao_flight_nano.c index d849dc64..96d47fac 100644 --- a/src/kernel/ao_flight_nano.c +++ b/src/kernel/ao_flight_nano.c @@ -20,18 +20,18 @@ /* Main flight thread. */ -__pdata enum ao_flight_state ao_flight_state; /* current flight state */ -__pdata uint16_t ao_launch_tick; /* time of launch detect */ +enum ao_flight_state ao_flight_state; /* current flight state */ +uint16_t ao_launch_tick; /* time of launch detect */ /* * track min/max data over a long interval to detect * resting */ -__pdata uint16_t ao_interval_end; -__pdata alt_t ao_interval_min_height; -__pdata alt_t ao_interval_max_height; +uint16_t ao_interval_end; +alt_t ao_interval_min_height; +alt_t ao_interval_max_height; -__pdata uint8_t ao_flight_force_idle; +uint8_t ao_flight_force_idle; /* Landing is detected by getting constant readings from both pressure and accelerometer * for a fairly long time (AO_INTERVAL_TICKS) @@ -70,7 +70,7 @@ ao_flight_nano(void) ao_led_off(AO_LED_RED); /* wakeup threads due to state change */ - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); break; case ao_flight_pad: if (ao_height> AO_M_TO_HEIGHT(20)) { @@ -80,7 +80,7 @@ ao_flight_nano(void) /* start logging data */ ao_log_start(); - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } break; case ao_flight_drogue: @@ -101,7 +101,7 @@ ao_flight_nano(void) /* turn off the ADC capture */ ao_timer_set_adc_interval(0); - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } ao_interval_min_height = ao_interval_max_height = ao_height; ao_interval_end = ao_sample_tick + AO_INTERVAL_TICKS; @@ -111,7 +111,7 @@ ao_flight_nano(void) } } -static __xdata struct ao_task flight_task; +static struct ao_task flight_task; void ao_flight_nano_init(void) diff --git a/src/kernel/ao_forward.c b/src/kernel/ao_forward.c index 721b52d0..6f664b60 100644 --- a/src/kernel/ao_forward.c +++ b/src/kernel/ao_forward.c @@ -23,11 +23,11 @@ static void ao_monitor_forward(void) { uint32_t recv_radio_setting; - static __xdata struct ao_telemetry_all_recv packet; + static struct ao_telemetry_all_recv packet; for (;;) { while (ao_monitoring) - ao_sleep(DATA_TO_XDATA(&ao_monitoring)); + ao_sleep(&ao_monitoring); if (!ao_radio_recv(&packet, sizeof(packet), 0)) continue; @@ -40,10 +40,10 @@ ao_monitor_forward(void) } } -static __xdata struct ao_task ao_monitor_forward_task; +static struct ao_task ao_monitor_forward_task; void -ao_monitor_forward_init(void) __reentrant +ao_monitor_forward_init(void) { ao_add_task(&ao_monitor_forward_task, ao_monitor_forward, "monitor_forward"); } diff --git a/src/kernel/ao_forward.h b/src/kernel/ao_forward.h index 2fe28f66..5b21bf3c 100644 --- a/src/kernel/ao_forward.h +++ b/src/kernel/ao_forward.h @@ -20,6 +20,6 @@ #define _AO_FORWARD_H_ void -ao_monitor_forward_init(void) __reentrant; +ao_monitor_forward_init(void); #endif /* _AO_FORWARD_H_ */ diff --git a/src/kernel/ao_freq.c b/src/kernel/ao_freq.c index 6478dae2..81640ce8 100644 --- a/src/kernel/ao_freq.c +++ b/src/kernel/ao_freq.c @@ -26,11 +26,11 @@ * frequency, and updating the radio setting along the way */ -int32_t ao_freq_to_set(int32_t freq, int32_t cal) __reentrant +int32_t ao_freq_to_set(int32_t freq, int32_t cal) { - static __pdata int32_t set; - static __pdata uint8_t neg; - static __pdata int32_t error; + static int32_t set; + static uint8_t neg; + static int32_t error; set = 0; neg = 0; diff --git a/src/kernel/ao_gps_print.c b/src/kernel/ao_gps_print.c index b1183bad..6dfd1bdd 100644 --- a/src/kernel/ao_gps_print.c +++ b/src/kernel/ao_gps_print.c @@ -26,7 +26,7 @@ #endif void -ao_gps_print(__xdata struct ao_gps_orig *gps_data) __reentrant +ao_gps_print(struct ao_gps_orig *gps_data) { char state; @@ -82,10 +82,10 @@ ao_gps_print(__xdata struct ao_gps_orig *gps_data) __reentrant } void -ao_gps_tracking_print(__xdata struct ao_gps_tracking_orig *gps_tracking_data) __reentrant +ao_gps_tracking_print(struct ao_gps_tracking_orig *gps_tracking_data) { uint8_t c, n, v; - __xdata struct ao_gps_sat_orig *sat; + struct ao_gps_sat_orig *sat; n = gps_tracking_data->channels; if (n == 0) diff --git a/src/kernel/ao_gps_report.c b/src/kernel/ao_gps_report.c index 75c2f367..0ef9a725 100644 --- a/src/kernel/ao_gps_report.c +++ b/src/kernel/ao_gps_report.c @@ -21,9 +21,9 @@ void ao_gps_report(void) { - static __xdata struct ao_log_record gps_log; - static __xdata struct ao_telemetry_location gps_data; - static __xdata struct ao_telemetry_satellite gps_tracking_data; + static struct ao_log_record gps_log; + static struct ao_telemetry_location gps_data; + static struct ao_telemetry_satellite gps_tracking_data; uint8_t date_reported = 0; uint8_t new; @@ -85,7 +85,7 @@ ao_gps_report(void) } } -__xdata struct ao_task ao_gps_report_task; +struct ao_task ao_gps_report_task; void ao_gps_report_init(void) diff --git a/src/kernel/ao_gps_report_mega.c b/src/kernel/ao_gps_report_mega.c index 85614b85..37f1beaa 100644 --- a/src/kernel/ao_gps_report_mega.c +++ b/src/kernel/ao_gps_report_mega.c @@ -59,9 +59,9 @@ ao_gps_sparse_should_log(int32_t lat, int32_t lon, int16_t alt) void ao_gps_report_mega(void) { - static __xdata struct ao_log_mega gps_log; - static __xdata struct ao_telemetry_location gps_data; - static __xdata struct ao_telemetry_satellite gps_tracking_data; + static struct ao_log_mega gps_log; + static struct ao_telemetry_location gps_data; + static struct ao_telemetry_satellite gps_tracking_data; uint8_t new; uint8_t c, n, i; @@ -125,7 +125,7 @@ ao_gps_report_mega(void) } } -__xdata struct ao_task ao_gps_report_mega_task; +struct ao_task ao_gps_report_mega_task; void ao_gps_report_mega_init(void) diff --git a/src/kernel/ao_gps_report_metrum.c b/src/kernel/ao_gps_report_metrum.c index 523fb17f..06863fe4 100644 --- a/src/kernel/ao_gps_report_metrum.c +++ b/src/kernel/ao_gps_report_metrum.c @@ -22,9 +22,9 @@ void ao_gps_report_metrum(void) { - static __xdata struct ao_log_metrum gps_log; - static __xdata struct ao_telemetry_location gps_data; - static __xdata struct ao_telemetry_satellite gps_tracking_data; + static struct ao_log_metrum gps_log; + static struct ao_telemetry_location gps_data; + static struct ao_telemetry_satellite gps_tracking_data; uint8_t c, n, i; uint8_t svid; uint8_t new; @@ -88,7 +88,7 @@ ao_gps_report_metrum(void) } } -__xdata struct ao_task ao_gps_report_metrum_task; +struct ao_task ao_gps_report_metrum_task; void ao_gps_report_metrum_init(void) diff --git a/src/kernel/ao_gps_show.c b/src/kernel/ao_gps_show.c index ec197769..ab29e5e5 100644 --- a/src/kernel/ao_gps_show.c +++ b/src/kernel/ao_gps_show.c @@ -23,7 +23,7 @@ #include <ao_data.h> void -ao_gps_show(void) __reentrant +ao_gps_show(void) { uint8_t i; ao_mutex_get(&ao_gps_mutex); diff --git a/src/kernel/ao_host.h b/src/kernel/ao_host.h index 50583f52..592de54c 100644 --- a/src/kernel/ao_host.h +++ b/src/kernel/ao_host.h @@ -41,15 +41,11 @@ struct ao_adc { int16_t sense_m; /* main continuity sense */ }; -#define __pdata -#define __data -#define __xdata -#define __code -#define __reentrant - -#define DATA_TO_XDATA(a) (a) -#define PDATA_TO_XDATA(a) (a) -#define CODE_TO_XDATA(a) (a) +#define const + +#define a (a) +#define a (a) +#define a (a) enum ao_flight_state { ao_flight_startup = 0, diff --git a/src/kernel/ao_ignite.c b/src/kernel/ao_ignite.c index 52d9d77e..a6ff9979 100644 --- a/src/kernel/ao_ignite.c +++ b/src/kernel/ao_ignite.c @@ -23,7 +23,7 @@ #endif #if HAS_IGNITE -__xdata struct ao_ignition ao_ignition[2]; +struct ao_ignition ao_ignition[2]; void ao_ignite(enum ao_igniter igniter) @@ -42,9 +42,9 @@ ao_ignite(enum ao_igniter igniter) enum ao_igniter_status ao_igniter_status(enum ao_igniter igniter) { - __xdata struct ao_data packet; - __pdata int16_t value; - __pdata uint8_t request, firing, fired; + struct ao_data packet; + int16_t value; + uint8_t request, firing, fired; ao_arch_critical( ao_data_get(&packet); @@ -72,10 +72,8 @@ ao_igniter_status(enum ao_igniter igniter) return ao_igniter_unknown; } -#ifndef AO_IGNITER_SET_DROGUE -#define AO_IGNITER_SET_DROGUE(v) AO_IGNITER_DROGUE = (v) -#define AO_IGNITER_SET_MAIN(v) AO_IGNITER_MAIN = (v) -#endif +#define AO_IGNITER_SET_DROGUE(v) ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v) +#define AO_IGNITER_SET_MAIN(v) ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v) #ifndef AO_IGNITER_FIRE_TIME #define AO_IGNITER_FIRE_TIME AO_MS_TO_TICKS(50) @@ -141,7 +139,7 @@ ao_igniter_fire(enum ao_igniter igniter) void ao_igniter(void) { - __xdata enum ao_igniter igniter; + enum ao_igniter igniter; ao_config_get(); for (;;) { @@ -187,13 +185,13 @@ ao_ignite_manual(void) ao_cmd_status = ao_cmd_syntax_error; } -__code char * __code ao_igniter_status_names[] = { +const char * const ao_igniter_status_names[] = { "unknown", "ready", "active", "open" }; #if HAS_IGNITE void -ao_ignite_print_status(enum ao_igniter igniter, __code char *name) __reentrant +ao_ignite_print_status(enum ao_igniter igniter, const char *name) { enum ao_igniter_status status = ao_igniter_status(igniter); printf("Igniter: %6s Status: %s\n", @@ -214,20 +212,20 @@ ao_ignite_test(void) #endif } -__code struct ao_cmds ao_ignite_cmds[] = { +const struct ao_cmds ao_ignite_cmds[] = { { ao_ignite_manual, "i <key> {main|drogue}\0Fire igniter. <key> is doit with D&I" }, { ao_ignite_test, "t\0Test igniter" }, { 0, NULL }, }; #if HAS_IGNITE -__xdata struct ao_task ao_igniter_task; +struct ao_task ao_igniter_task; void ao_ignite_set_pins(void) { - ao_enable_output(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, 0); - ao_enable_output(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, 0); + ao_enable_output(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, 0); + ao_enable_output(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, 0); } #endif diff --git a/src/kernel/ao_int64.c b/src/kernel/ao_int64.c index fdea61c0..dffb8556 100644 --- a/src/kernel/ao_int64.c +++ b/src/kernel/ao_int64.c @@ -18,7 +18,7 @@ #include <ao_int64.h> -void ao_plus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t *b) __FATTR { +void ao_plus64(ao_int64_t *r, ao_int64_t *a, ao_int64_t *b) __FATTR { __LOCAL uint32_t t; r->high = a->high + b->high; @@ -28,7 +28,7 @@ void ao_plus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t r->low = t; } -void ao_minus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t *b) __FATTR { +void ao_minus64(ao_int64_t *r, ao_int64_t *a, ao_int64_t *b) __FATTR { __LOCAL uint32_t t; r->high = a->high - b->high; @@ -38,7 +38,7 @@ void ao_minus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t r->low = t; } -void ao_rshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATTR { +void ao_rshift64(ao_int64_t *r, ao_int64_t *a, uint8_t d) __FATTR { if (d < 32) { r->low = a->low >> d; if (d) @@ -51,7 +51,7 @@ void ao_rshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATT } } -void ao_lshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATTR { +void ao_lshift64(ao_int64_t *r, ao_int64_t *a, uint8_t d) __FATTR { if (d < 32) { r->high = a->high << d; if (d) @@ -64,7 +64,7 @@ void ao_lshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATT } } -static void ao_umul64_32_32(__ARG ao_int64_t *r, uint32_t a, uint32_t b) __reentrant { +static void ao_umul64_32_32(__ARG ao_int64_t *r, uint32_t a, uint32_t b) { __LOCAL uint32_t s; __LOCAL ao_int64_t t; r->low = (uint32_t) (uint16_t) a * (uint16_t) b; @@ -83,7 +83,7 @@ static void ao_umul64_32_32(__ARG ao_int64_t *r, uint32_t a, uint32_t b) __reent ao_plus64(r, r, &t); } -void ao_neg64(__pdata ao_int64_t *r, __pdata ao_int64_t *a) __FATTR { +void ao_neg64(ao_int64_t *r, ao_int64_t *a) __FATTR { r->high = ~a->high; if (!(r->low = ~a->low + 1)) r->high++; @@ -105,7 +105,7 @@ void ao_mul64_32_32(__ARG ao_int64_t *r, int32_t a, int32_t b) __FATTR { ao_neg64(r, r); } -static void ao_umul64(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG ao_int64_t *b) __reentrant { +static void ao_umul64(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG ao_int64_t *b) { __LOCAL ao_int64_t r2, r3; ao_umul64_32_32(&r2, a->high, b->low); @@ -135,7 +135,7 @@ void ao_mul64(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG ao_int64_t *b) __F ao_neg64(r, r); } -static void ao_umul64_64_16(__ARG ao_int64_t *r, __ARG ao_int64_t *a, uint16_t b) __reentrant { +static void ao_umul64_64_16(__ARG ao_int64_t *r, __ARG ao_int64_t *a, uint16_t b) { __LOCAL uint32_t h; h = a->high * b; diff --git a/src/kernel/ao_int64.h b/src/kernel/ao_int64.h index 11c16404..3014182a 100644 --- a/src/kernel/ao_int64.h +++ b/src/kernel/ao_int64.h @@ -27,14 +27,14 @@ typedef struct { } ao_int64_t; #define __FATTR -#define __ARG __pdata -#define __LOCAL static __pdata - -void ao_plus64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, __pdata ao_int64_t *ao_64b) __FATTR; -void ao_minus64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, __pdata ao_int64_t *ao_64b) __FATTR; -void ao_neg64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a) __FATTR; -void ao_rshift64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, uint8_t d) __FATTR; -void ao_lshift64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, uint8_t d) __FATTR; +#define __ARG +#define __LOCAL static + +void ao_plus64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, ao_int64_t *ao_64b) __FATTR; +void ao_minus64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, ao_int64_t *ao_64b) __FATTR; +void ao_neg64(ao_int64_t *ao_64r, ao_int64_t *ao_64a) __FATTR; +void ao_rshift64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, uint8_t d) __FATTR; +void ao_lshift64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, uint8_t d) __FATTR; void ao_mul64_32_32(__ARG ao_int64_t *r, __ARG int32_t a, __ARG int32_t b) __FATTR; void ao_mul64_64_16(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG uint16_t b) __FATTR; void ao_mul64(__ARG ao_int64_t * __ARG r, __ARG ao_int64_t * __ARG a, __ARG ao_int64_t *__ARG b) __FATTR; diff --git a/src/kernel/ao_kalman.c b/src/kernel/ao_kalman.c index e4cc6d4b..4f4ffe8f 100644 --- a/src/kernel/ao_kalman.c +++ b/src/kernel/ao_kalman.c @@ -24,9 +24,9 @@ #include "ao_sample.h" #include "ao_kalman.h" -static __pdata ao_k_t ao_k_height; -static __pdata ao_k_t ao_k_speed; -static __pdata ao_k_t ao_k_accel; +static ao_k_t ao_k_height; +static ao_k_t ao_k_speed; +static ao_k_t ao_k_accel; #define AO_K_STEP_100 to_fix_v(0.01) #define AO_K_STEP_2_2_100 to_fix_v(0.00005) @@ -37,24 +37,24 @@ static __pdata ao_k_t ao_k_accel; #define AO_K_STEP_1 to_fix_v(1) #define AO_K_STEP_2_2_1 to_fix_v(0.5) -__pdata ao_v_t ao_height; -__pdata ao_v_t ao_speed; -__pdata ao_v_t ao_accel; -__xdata ao_v_t ao_max_height; -static __pdata ao_k_t ao_avg_height_scaled; -__xdata ao_v_t ao_avg_height; +ao_v_t ao_height; +ao_v_t ao_speed; +ao_v_t ao_accel; +ao_v_t ao_max_height; +static ao_k_t ao_avg_height_scaled; +ao_v_t ao_avg_height; -__pdata ao_v_t ao_error_h; +ao_v_t ao_error_h; #if !HAS_ACCEL || AO_FLIGHT_TEST #define AO_ERROR_H_SQ_AVG 1 #endif #if AO_ERROR_H_SQ_AVG -__pdata ao_v_t ao_error_h_sq_avg; +ao_v_t ao_error_h_sq_avg; #endif #if HAS_ACCEL -__pdata ao_v_t ao_error_a; +ao_v_t ao_error_a; #endif static void diff --git a/src/kernel/ao_led.h b/src/kernel/ao_led.h index 7de09237..5d982ca6 100644 --- a/src/kernel/ao_led.h +++ b/src/kernel/ao_led.h @@ -26,7 +26,7 @@ #define AO_LED_NONE 0 #ifndef AO_LED_TYPE -#define AO_LED_TYPE uint8_t +#define AO_LED_TYPE uint32_t #endif /* Turn on the specified LEDs */ @@ -51,10 +51,208 @@ ao_led_toggle(AO_LED_TYPE colors); /* Turn on the specified LEDs for the indicated interval */ void -ao_led_for(AO_LED_TYPE colors, uint16_t ticks) __reentrant; +ao_led_for(AO_LED_TYPE colors, uint16_t ticks); /* Initialize the LEDs */ void -ao_led_init(AO_LED_TYPE enable); +ao_led_init(void); + +#ifdef LED_0_PORT +#define AO_LED_0 (1 << 0) +#else +#define AO_LED_0 0 +#endif +#ifdef LED_1_PORT +#define AO_LED_1 (1 << 1) +#else +#define AO_LED_1 0 +#endif +#ifdef LED_2_PORT +#define AO_LED_2 (1 << 2) +#else +#define AO_LED_2 0 +#endif +#ifdef LED_3_PORT +#define AO_LED_3 (1 << 3) +#else +#define AO_LED_3 0 +#endif +#ifdef LED_4_PORT +#define AO_LED_4 (1 << 4) +#else +#define AO_LED_4 0 +#endif +#ifdef LED_5_PORT +#define AO_LED_5 (1 << 5) +#else +#define AO_LED_5 0 +#endif +#ifdef LED_6_PORT +#define AO_LED_6 (1 << 6) +#else +#define AO_LED_6 0 +#endif +#ifdef LED_7_PORT +#define AO_LED_7 (1 << 7) +#else +#define AO_LED_7 0 +#endif +#ifdef LED_8_PORT +#define AO_LED_8 (1 << 8) +#else +#define AO_LED_8 0 +#endif +#ifdef LED_9_PORT +#define AO_LED_9 (1 << 9) +#else +#define AO_LED_9 0 +#endif +#ifdef LED_10_PORT +#define AO_LED_10 (1 << 10) +#else +#define AO_LED_10 0 +#endif +#ifdef LED_11_PORT +#define AO_LED_11 (1 << 11) +#else +#define AO_LED_11 0 +#endif +#ifdef LED_12_PORT +#define AO_LED_12 (1 << 12) +#else +#define AO_LED_12 0 +#endif +#ifdef LED_13_PORT +#define AO_LED_13 (1 << 13) +#else +#define AO_LED_13 0 +#endif +#ifdef LED_14_PORT +#define AO_LED_14 (1 << 14) +#else +#define AO_LED_14 0 +#endif +#ifdef LED_15_PORT +#define AO_LED_15 (1 << 15) +#else +#define AO_LED_15 0 +#endif +#ifdef LED_16_PORT +#define AO_LED_16 (1 << 16) +#else +#define AO_LED_16 0 +#endif +#ifdef LED_17_PORT +#define AO_LED_17 (1 << 17) +#else +#define AO_LED_17 0 +#endif +#ifdef LED_18_PORT +#define AO_LED_18 (1 << 18) +#else +#define AO_LED_18 0 +#endif +#ifdef LED_19_PORT +#define AO_LED_19 (1 << 19) +#else +#define AO_LED_19 0 +#endif +#ifdef LED_20_PORT +#define AO_LED_20 (1 << 20) +#else +#define AO_LED_20 0 +#endif +#ifdef LED_21_PORT +#define AO_LED_21 (1 << 21) +#else +#define AO_LED_21 0 +#endif +#ifdef LED_22_PORT +#define AO_LED_22 (1 << 22) +#else +#define AO_LED_22 0 +#endif +#ifdef LED_23_PORT +#define AO_LED_23 (1 << 23) +#else +#define AO_LED_23 0 +#endif +#ifdef LED_24_PORT +#define AO_LED_24 (1 << 24) +#else +#define AO_LED_24 0 +#endif +#ifdef LED_25_PORT +#define AO_LED_25 (1 << 25) +#else +#define AO_LED_25 0 +#endif +#ifdef LED_26_PORT +#define AO_LED_26 (1 << 26) +#else +#define AO_LED_26 0 +#endif +#ifdef LED_27_PORT +#define AO_LED_27 (1 << 27) +#else +#define AO_LED_27 0 +#endif +#ifdef LED_28_PORT +#define AO_LED_28 (1 << 28) +#else +#define AO_LED_28 0 +#endif +#ifdef LED_29_PORT +#define AO_LED_29 (1 << 29) +#else +#define AO_LED_29 0 +#endif +#ifdef LED_30_PORT +#define AO_LED_30 (1 << 30) +#else +#define AO_LED_30 0 +#endif +#ifdef LED_31_PORT +#define AO_LED_31 (1 << 31) +#else +#define AO_LED_31 0 +#endif + +#define AO_LEDS_AVAILABLE (AO_LED_0 | \ + AO_LED_1 | \ + AO_LED_2 | \ + AO_LED_3 | \ + AO_LED_4 | \ + AO_LED_5 | \ + AO_LED_6 | \ + AO_LED_7 | \ + AO_LED_8 | \ + AO_LED_9 | \ + AO_LED_10 | \ + AO_LED_11 | \ + AO_LED_12 | \ + AO_LED_13 | \ + AO_LED_14 | \ + AO_LED_15 | \ + AO_LED_16 | \ + AO_LED_17 | \ + AO_LED_18 | \ + AO_LED_19 | \ + AO_LED_20 | \ + AO_LED_21 | \ + AO_LED_22 | \ + AO_LED_23 | \ + AO_LED_24 | \ + AO_LED_25 | \ + AO_LED_26 | \ + AO_LED_27 | \ + AO_LED_28 | \ + AO_LED_29 | \ + AO_LED_30 | \ + AO_LED_31) + +#ifndef LEDS_AVAILABLE +#define LEDS_AVAILABLE AO_LEDS_AVAILABLE +#endif #endif /* _AO_LED_H_ */ diff --git a/src/kernel/ao_log.c b/src/kernel/ao_log.c index 5fb086ce..fac211cf 100644 --- a/src/kernel/ao_log.c +++ b/src/kernel/ao_log.c @@ -23,13 +23,13 @@ #include <ao_tracker.h> #endif -__xdata uint8_t ao_log_mutex; -__pdata uint32_t ao_log_current_pos; -__pdata uint32_t ao_log_end_pos; -__pdata uint32_t ao_log_start_pos; -__xdata uint8_t ao_log_running; -__pdata enum ao_flight_state ao_log_state; -__xdata int16_t ao_flight_number; +uint8_t ao_log_mutex; +uint32_t ao_log_current_pos; +uint32_t ao_log_end_pos; +uint32_t ao_log_start_pos; +uint8_t ao_log_running; +enum ao_flight_state ao_log_state; +int16_t ao_flight_number; void ao_log_flush(void) @@ -47,7 +47,7 @@ struct ao_log_erase { uint16_t flight; }; -static __xdata struct ao_log_erase erase; +static struct ao_log_erase erase; #ifndef LOG_MAX_ERASE #define LOG_MAX_ERASE 16 @@ -117,10 +117,10 @@ ao_log_erase_mark(void) * structure. */ -__xdata ao_log_type ao_log_data; +ao_log_type ao_log_data; static uint8_t -ao_log_csum(__xdata uint8_t *b) __reentrant +ao_log_csum(uint8_t *b) { uint8_t sum = 0x5a; uint8_t i; @@ -131,12 +131,12 @@ ao_log_csum(__xdata uint8_t *b) __reentrant } uint8_t -ao_log_write(__xdata ao_log_type *log) __reentrant +ao_log_write(ao_log_type *log) { uint8_t wrote = 0; /* set checksum */ log->csum = 0; - log->csum = ao_log_csum((__xdata uint8_t *) log); + log->csum = ao_log_csum((uint8_t *) log); ao_mutex_get(&ao_log_mutex); { if (ao_log_current_pos >= ao_log_end_pos && ao_log_running) ao_log_stop(); @@ -223,7 +223,7 @@ ao_log_max_flight(void) } static void -ao_log_erase(uint8_t slot) __reentrant +ao_log_erase(uint8_t slot) { uint32_t log_current_pos, log_end_pos; @@ -232,7 +232,7 @@ ao_log_erase(uint8_t slot) __reentrant log_end_pos = log_current_pos + ao_config.flight_log_max; while (log_current_pos < log_end_pos) { uint8_t i; - static __xdata uint8_t b; + static uint8_t b; /* * Check to see if we've reached the end of @@ -252,7 +252,7 @@ ao_log_erase(uint8_t slot) __reentrant } static void -ao_log_find_max_erase_flight(void) __reentrant +ao_log_find_max_erase_flight(void) { uint8_t log_slot; @@ -273,7 +273,7 @@ ao_log_find_max_erase_flight(void) __reentrant } uint8_t -ao_log_scan(void) __reentrant +ao_log_scan(void) { uint8_t log_slot; uint8_t log_slots; @@ -402,11 +402,11 @@ ao_log_full(void) #endif #if LOG_ADC -static __xdata struct ao_task ao_log_task; +static struct ao_task ao_log_task; #endif void -ao_log_list(void) __reentrant +ao_log_list(void) { uint8_t slot; uint8_t slots; @@ -426,7 +426,7 @@ ao_log_list(void) __reentrant } void -ao_log_delete(void) __reentrant +ao_log_delete(void) { uint8_t slot; uint8_t slots; @@ -437,10 +437,9 @@ ao_log_delete(void) __reentrant cmd_flight = -1; ao_cmd_lex(); } - ao_cmd_decimal(); + cmd_flight *= ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - cmd_flight *= (int16_t) ao_cmd_lex_i; slots = ao_log_slots(); /* Look for the flight log matching the requested flight */ @@ -462,7 +461,7 @@ ao_log_delete(void) __reentrant printf("No such flight: %d\n", cmd_flight); } -__code struct ao_cmds ao_log_cmds[] = { +const struct ao_cmds ao_log_cmds[] = { { ao_log_list, "l\0List logs" }, { ao_log_delete, "d <flight-number>\0Delete flight" }, { 0, NULL }, diff --git a/src/kernel/ao_log.h b/src/kernel/ao_log.h index e2f1e0e4..a9715962 100644 --- a/src/kernel/ao_log.h +++ b/src/kernel/ao_log.h @@ -29,13 +29,13 @@ * the log. Tasks may wait for this to be initialized * by sleeping on this variable. */ -extern __xdata int16_t ao_flight_number; -extern __xdata uint8_t ao_log_mutex; -extern __pdata uint32_t ao_log_current_pos; -extern __pdata uint32_t ao_log_end_pos; -extern __pdata uint32_t ao_log_start_pos; -extern __xdata uint8_t ao_log_running; -extern __pdata enum ao_flight_state ao_log_state; +extern int16_t ao_flight_number; +extern uint8_t ao_log_mutex; +extern uint32_t ao_log_current_pos; +extern uint32_t ao_log_end_pos; +extern uint32_t ao_log_start_pos; +extern uint8_t ao_log_running; +extern enum ao_flight_state ao_log_state; /* required functions from the underlying log system */ @@ -90,7 +90,7 @@ ao_log(void); /* Figure out the current flight number */ uint8_t -ao_log_scan(void) __reentrant; +ao_log_scan(void); /* Return the position of the start of the given log slot */ uint32_t @@ -507,14 +507,14 @@ typedef struct ao_log_record ao_log_type; #endif #ifndef AO_LOG_UNCOMMON -extern __xdata ao_log_type ao_log_data; +extern ao_log_type ao_log_data; #define AO_LOG_SIZE sizeof(ao_log_type) /* Write a record to the eeprom log */ uint8_t -ao_log_write(__xdata ao_log_type *log) __reentrant; +ao_log_write(ao_log_type *log); #endif void diff --git a/src/kernel/ao_log_big.c b/src/kernel/ao_log_big.c index 7d7332e9..2a8cd63d 100644 --- a/src/kernel/ao_log_big.c +++ b/src/kernel/ao_log_big.c @@ -18,7 +18,7 @@ #include "ao.h" -static __data uint8_t ao_log_data_pos; +static uint8_t ao_log_data_pos; /* a hack to make sure that ao_log_records fill the eeprom block in even units */ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_record))] ; @@ -32,7 +32,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_record))] ; void ao_log(void) { - __pdata uint16_t next_sensor, next_other; + uint16_t next_sensor, next_other; ao_storage_setup(); diff --git a/src/kernel/ao_log_fireone.c b/src/kernel/ao_log_fireone.c index 1a82673d..3dd52a16 100644 --- a/src/kernel/ao_log_fireone.c +++ b/src/kernel/ao_log_fireone.c @@ -21,12 +21,12 @@ #include <ao_data.h> #include <ao_flight.h> -static __xdata struct ao_log_firetwo log; +static struct ao_log_firetwo log; -__code uint8_t ao_log_format = AO_LOG_FORMAT_TELEFIRETWO; +const uint8_t ao_log_format = AO_LOG_FORMAT_TELEFIRETWO; static uint8_t -ao_log_csum(__xdata uint8_t *b) __reentrant +ao_log_csum(uint8_t *b) { uint8_t sum = 0x5a; uint8_t i; @@ -37,12 +37,12 @@ ao_log_csum(__xdata uint8_t *b) __reentrant } uint8_t -ao_log_firetwo(__xdata struct ao_log_firetwo *log) __reentrant +ao_log_firetwo(struct ao_log_firetwo *log) { uint8_t wrote = 0; /* set checksum */ log->csum = 0; - log->csum = ao_log_csum((__xdata uint8_t *) log); + log->csum = ao_log_csum((uint8_t *) log); ao_mutex_get(&ao_log_mutex); { if (ao_log_current_pos >= ao_log_end_pos && ao_log_running) ao_log_stop(); @@ -66,7 +66,7 @@ ao_log_dump_check_data(void) } #if HAS_ADC -static __data uint8_t ao_log_data_pos; +static uint8_t ao_log_data_pos; /* a hack to make sure that ao_log_metrums fill the eeprom block in even units */ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_firetwo))] ; diff --git a/src/kernel/ao_log_mega.c b/src/kernel/ao_log_mega.c index 0ae4e536..341ff715 100644 --- a/src/kernel/ao_log_mega.c +++ b/src/kernel/ao_log_mega.c @@ -22,7 +22,7 @@ #include <ao_flight.h> #if HAS_FLIGHT -static __data uint8_t ao_log_data_pos; +static uint8_t ao_log_data_pos; /* a hack to make sure that ao_log_megas fill the eeprom block in even units */ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mega))] ; @@ -36,7 +36,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mega))] ; void ao_log(void) { - __pdata uint16_t next_sensor, next_other; + uint16_t next_sensor, next_other; uint8_t i; ao_storage_setup(); diff --git a/src/kernel/ao_log_metrum.c b/src/kernel/ao_log_metrum.c index 34729070..18fb9ffb 100644 --- a/src/kernel/ao_log_metrum.c +++ b/src/kernel/ao_log_metrum.c @@ -22,7 +22,7 @@ #include <ao_flight.h> #if HAS_ADC -static __data uint8_t ao_log_data_pos; +static uint8_t ao_log_data_pos; /* a hack to make sure that ao_log_metrums fill the eeprom block in even units */ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_metrum))] ; @@ -36,7 +36,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_metrum))] ; void ao_log(void) { - __pdata uint16_t next_sensor, next_other; + uint16_t next_sensor, next_other; ao_storage_setup(); diff --git a/src/kernel/ao_log_mini.c b/src/kernel/ao_log_mini.c index 12c5d6bb..03bf2265 100644 --- a/src/kernel/ao_log_mini.c +++ b/src/kernel/ao_log_mini.c @@ -21,7 +21,7 @@ #include <ao_data.h> #include <ao_flight.h> -static __data uint8_t ao_log_data_pos; +static uint8_t ao_log_data_pos; /* a hack to make sure that ao_log_minis fill the eeprom block in even units */ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mini))] ; @@ -34,7 +34,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mini))] ; void ao_log(void) { - __pdata uint16_t next_sensor; + uint16_t next_sensor; ao_storage_setup(); diff --git a/src/kernel/ao_log_single.c b/src/kernel/ao_log_single.c index 63768e1a..a2b63c8d 100644 --- a/src/kernel/ao_log_single.c +++ b/src/kernel/ao_log_single.c @@ -26,16 +26,16 @@ #include "ao.h" #include "ao_product.h" -static __xdata struct ao_task ao_log_single_task; +static struct ao_task ao_log_single_task; -__xdata uint8_t ao_log_running; -__xdata uint8_t ao_log_mutex; -__pdata uint32_t ao_log_start_pos; -__pdata uint32_t ao_log_end_pos; -__pdata uint32_t ao_log_current_pos; +uint8_t ao_log_running; +uint8_t ao_log_mutex; +uint32_t ao_log_start_pos; +uint32_t ao_log_end_pos; +uint32_t ao_log_current_pos; -__xdata union ao_log_single ao_log_single_write_data; -__xdata union ao_log_single ao_log_single_read_data; +union ao_log_single ao_log_single_write_data; +union ao_log_single ao_log_single_read_data; uint8_t ao_log_single_write(void) @@ -59,7 +59,7 @@ ao_log_single_write(void) static uint8_t ao_log_single_valid(void) { - __xdata uint8_t *d = ao_log_single_read_data.bytes; + uint8_t *d = ao_log_single_read_data.bytes; uint8_t i; for (i = 0; i < AO_LOG_SINGLE_SIZE; i++) if (*d++ != 0xff) @@ -118,10 +118,11 @@ ao_log_single_restart(void) void ao_log_single_set(void) { + uint16_t r; printf("Logging currently %s\n", ao_log_running ? "on" : "off"); - ao_cmd_hex(); + r = ao_cmd_hex(); if (ao_cmd_status == ao_cmd_success) { - if (ao_cmd_lex_i) { + if (r) { printf("Logging from %ld to %ld\n", ao_log_current_pos, ao_log_end_pos); ao_log_single_start(); } else { @@ -136,13 +137,12 @@ void ao_log_single_delete(void) { uint32_t pos; - - ao_cmd_hex(); + uint16_t r = ao_cmd_hex(); if (ao_cmd_status != ao_cmd_success) return; - if (ao_cmd_lex_i != 1) { + if (r != 1) { ao_cmd_status = ao_cmd_syntax_error; - printf("No such flight: %d\n", ao_cmd_lex_i); + printf("No such flight: %d\n", r); return; } ao_log_single_stop(); @@ -153,7 +153,7 @@ ao_log_single_delete(void) } ao_log_current_pos = ao_log_start_pos = 0; if (pos == 0) - printf("No such flight: %d\n", ao_cmd_lex_i); + printf("No such flight: %d\n", r); else printf ("Erased\n"); } diff --git a/src/kernel/ao_log_telem.c b/src/kernel/ao_log_telem.c index 1305a84d..8c0b88e4 100644 --- a/src/kernel/ao_log_telem.c +++ b/src/kernel/ao_log_telem.c @@ -20,13 +20,13 @@ #include <ao_flight.h> #include <ao_sample.h> -__code uint8_t ao_log_format = AO_LOG_FORMAT_TELEMETRY; +const uint8_t ao_log_format = AO_LOG_FORMAT_TELEMETRY; -static __data uint8_t ao_log_monitor_pos; -__pdata enum ao_flight_state ao_flight_state; -__xdata int16_t ao_max_height; /* max of ao_height */ -__pdata int16_t sense_d, sense_m; -__pdata uint8_t ao_igniter_present; +static uint8_t ao_log_monitor_pos; +enum ao_flight_state ao_flight_state; +int16_t ao_max_height; /* max of ao_height */ +int16_t sense_d, sense_m; +uint8_t ao_igniter_present; static void ao_log_telem_track() { @@ -50,7 +50,7 @@ ao_log_telem_track() { ao_flight_state = ao_log_single_write_data.telemetry.sensor.state; if (ao_flight_state == ao_flight_pad) ao_max_height = 0; - ao_wakeup(DATA_TO_XDATA(&ao_flight_state)); + ao_wakeup(&ao_flight_state); } } } @@ -111,7 +111,7 @@ ao_log_single(void) ao_log_telem_track(); } /* Wait for more telemetry data to arrive */ - ao_sleep(DATA_TO_XDATA(&ao_monitor_head)); + ao_sleep(&ao_monitor_head); } } } diff --git a/src/kernel/ao_log_telescience.c b/src/kernel/ao_log_telescience.c index 3f514f18..a21af71d 100644 --- a/src/kernel/ao_log_telescience.c +++ b/src/kernel/ao_log_telescience.c @@ -23,12 +23,12 @@ static uint8_t ao_log_data_pos; -__code uint8_t ao_log_format = AO_LOG_FORMAT_TELESCIENCE; +const uint8_t ao_log_format = AO_LOG_FORMAT_TELESCIENCE; static void -ao_log_telescience_csum(void) __reentrant +ao_log_telescience_csum(void) { - __xdata uint8_t *b = ao_log_single_write_data.bytes; + uint8_t *b = ao_log_single_write_data.bytes; uint8_t sum = 0x5a; uint8_t i; diff --git a/src/kernel/ao_log_tiny.c b/src/kernel/ao_log_tiny.c index 0b8e39d6..53003111 100644 --- a/src/kernel/ao_log_tiny.c +++ b/src/kernel/ao_log_tiny.c @@ -18,7 +18,7 @@ #include "ao.h" -static __data uint16_t ao_log_tiny_interval; +static uint16_t ao_log_tiny_interval; #define AO_LOG_TINY_INTERVAL_DEFAULT AO_MS_TO_TICKS(1000) #if USE_FAST_ASCENT_LOG @@ -41,13 +41,13 @@ static void ao_log_tiny_data(uint16_t d) if (ao_log_current_pos >= ao_log_end_pos && ao_log_running) ao_log_stop(); if (ao_log_running) { - ao_storage_write(ao_log_current_pos, DATA_TO_XDATA(&d), 2); + ao_storage_write(ao_log_current_pos, &d, 2); ao_log_current_pos += 2; } } -static __xdata uint16_t ao_log_pad_ring[AO_PAD_RING]; -static __pdata uint8_t ao_log_pad_ring_pos; +static uint16_t ao_log_pad_ring[AO_PAD_RING]; +static uint8_t ao_log_pad_ring_pos; #define ao_pad_ring_next(n) (((n) + 1) & (AO_PAD_RING - 1)) @@ -102,7 +102,7 @@ ao_log(void) /* * Add in pending sample data */ - ao_sleep(DATA_TO_XDATA(&ao_sample_data)); + ao_sleep(&ao_sample_data); while (ao_log_data != ao_sample_data) { sum += ao_data_pres(&ao_data_ring[ao_log_data]); count++; @@ -150,7 +150,7 @@ ao_log(void) int16_t ao_log_flight(uint8_t slot) { - static __xdata uint16_t flight; + static uint16_t flight; (void) slot; ao_storage_read(0, &flight, 2); diff --git a/src/kernel/ao_monitor.c b/src/kernel/ao_monitor.c index 7cbee288..3f1ff217 100644 --- a/src/kernel/ao_monitor.c +++ b/src/kernel/ao_monitor.c @@ -36,15 +36,15 @@ #error Must define AO_MONITOR_LED #endif -__xdata uint8_t ao_monitoring_mutex; -__data uint8_t ao_monitoring; -static __data uint8_t ao_monitor_disabled; -static __data uint8_t ao_internal_monitoring; -static __data uint8_t ao_external_monitoring; +uint8_t ao_monitoring_mutex; +uint8_t ao_monitoring; +static uint8_t ao_monitor_disabled; +static uint8_t ao_internal_monitoring; +static uint8_t ao_external_monitoring; -__xdata union ao_monitor ao_monitor_ring[AO_MONITOR_RING]; +union ao_monitor ao_monitor_ring[AO_MONITOR_RING]; -__data uint8_t ao_monitor_head; +uint8_t ao_monitor_head; static void _ao_monitor_adjust(void) @@ -59,7 +59,7 @@ _ao_monitor_adjust(void) else ao_monitoring = ao_internal_monitoring; } - ao_wakeup(DATA_TO_XDATA(&ao_monitoring)); + ao_wakeup(&ao_monitoring); } void @@ -70,7 +70,7 @@ ao_monitor_get(void) for (;;) { switch (ao_monitoring) { case 0: - ao_sleep(DATA_TO_XDATA(&ao_monitoring)); + ao_sleep(&ao_monitoring); continue; #if LEGACY_MONITOR case AO_MONITORING_ORIG: @@ -86,12 +86,12 @@ ao_monitor_get(void) if (!ao_radio_recv(&ao_monitor_ring[ao_monitor_head], size + 2, 0)) continue; ao_monitor_head = ao_monitor_ring_next(ao_monitor_head); - ao_wakeup(DATA_TO_XDATA(&ao_monitor_head)); + ao_wakeup(&ao_monitor_head); } } #if AO_MONITOR_LED -__xdata struct ao_task ao_monitor_blink_task; +struct ao_task ao_monitor_blink_task; void ao_monitor_blink(void) @@ -100,7 +100,7 @@ ao_monitor_blink(void) uint8_t *recv; #endif for (;;) { - ao_sleep(DATA_TO_XDATA(&ao_monitor_head)); + ao_sleep(&ao_monitor_head); #ifdef AO_MONITOR_BAD recv = (uint8_t *) &ao_monitor_ring[ao_monitor_ring_prev(ao_monitor_head)]; if (ao_monitoring && !(recv[ao_monitoring + 1] & AO_RADIO_STATUS_CRC_OK)) @@ -125,7 +125,7 @@ void ao_monitor_put(void) { #if LEGACY_MONITOR - __xdata char callsign[AO_MAX_CALLSIGN+1]; + char callsign[AO_MAX_CALLSIGN+1]; #endif #if LEGACY_MONITOR || HAS_RSSI int16_t rssi; @@ -133,7 +133,7 @@ ao_monitor_put(void) uint8_t ao_monitor_tail; uint8_t state; uint8_t sum, byte; - __xdata union ao_monitor *m; + union ao_monitor *m; #define recv_raw ((m->raw)) #define recv_orig ((m->orig)) @@ -142,9 +142,9 @@ ao_monitor_put(void) ao_monitor_tail = ao_monitor_head; for (;;) { while (!ao_external_monitoring) - ao_sleep(DATA_TO_XDATA(&ao_external_monitoring)); + ao_sleep(&ao_external_monitoring); while (ao_monitor_tail == ao_monitor_head && ao_external_monitoring) - ao_sleep(DATA_TO_XDATA(&ao_monitor_head)); + ao_sleep(&ao_monitor_head); if (!ao_external_monitoring) continue; m = &ao_monitor_ring[ao_monitor_tail]; @@ -266,10 +266,10 @@ ao_monitor_put(void) } } -__xdata struct ao_task ao_monitor_put_task; +struct ao_task ao_monitor_put_task; #endif -__xdata struct ao_task ao_monitor_get_task; +struct ao_task ao_monitor_get_task; void ao_monitor_set(uint8_t monitoring) @@ -296,21 +296,20 @@ ao_monitor_enable(void) static void set_monitor(void) { - ao_cmd_hex(); - ao_external_monitoring = ao_cmd_lex_i; - ao_wakeup(DATA_TO_XDATA(&ao_external_monitoring)); - ao_wakeup(DATA_TO_XDATA(&ao_monitor_head)); + ao_external_monitoring = ao_cmd_hex(); + ao_wakeup(&ao_external_monitoring); + ao_wakeup(&ao_monitor_head); _ao_monitor_adjust(); } -__code struct ao_cmds ao_monitor_cmds[] = { +const struct ao_cmds ao_monitor_cmds[] = { { set_monitor, "m <0 off, 1 old, 20 std>\0Set radio monitoring" }, { 0, NULL }, }; #endif void -ao_monitor_init(void) __reentrant +ao_monitor_init(void) { #if HAS_MONITOR_PUT ao_cmd_register(&ao_monitor_cmds[0]); diff --git a/src/kernel/ao_mutex.c b/src/kernel/ao_mutex.c index ff73e3bc..4ef1a9ba 100644 --- a/src/kernel/ao_mutex.c +++ b/src/kernel/ao_mutex.c @@ -25,7 +25,7 @@ #if HAS_MUTEX_TRY uint8_t -ao_mutex_try(__xdata uint8_t *mutex, uint8_t task_id) __reentrant +ao_mutex_try(uint8_t *mutex, uint8_t task_id) { uint8_t ret; if (*mutex == task_id) @@ -42,7 +42,7 @@ ao_mutex_try(__xdata uint8_t *mutex, uint8_t task_id) __reentrant #endif void -ao_mutex_get(__xdata uint8_t *mutex) __reentrant +ao_mutex_get(uint8_t *mutex) { if (*mutex == ao_cur_task->task_id) ao_panic(AO_PANIC_MUTEX); @@ -54,7 +54,7 @@ ao_mutex_get(__xdata uint8_t *mutex) __reentrant } void -ao_mutex_put(__xdata uint8_t *mutex) __reentrant +ao_mutex_put(uint8_t *mutex) { if (*mutex != ao_cur_task->task_id) ao_panic(AO_PANIC_MUTEX); diff --git a/src/kernel/ao_notask.c b/src/kernel/ao_notask.c index 7207353a..a5bdc8a7 100644 --- a/src/kernel/ao_notask.c +++ b/src/kernel/ao_notask.c @@ -21,7 +21,7 @@ static volatile void *ao_wchan; uint8_t -ao_sleep(__xdata void *wchan) +ao_sleep(void *wchan) { #if 1 ao_wchan = wchan; @@ -55,7 +55,7 @@ ao_delay(uint16_t ticks) #endif void -ao_wakeup(__xdata void *wchan) +ao_wakeup(void *wchan) { (void) wchan; ao_wchan = 0; diff --git a/src/kernel/ao_notask.h b/src/kernel/ao_notask.h index a4446726..ce622b63 100644 --- a/src/kernel/ao_notask.h +++ b/src/kernel/ao_notask.h @@ -20,9 +20,9 @@ #define _AO_NOTASK_H_ uint8_t -ao_sleep(__xdata void *wchan); +ao_sleep(void *wchan); void -ao_wakeup(__xdata void *wchan); +ao_wakeup(void *wchan); #endif /* _AO_NOTASK_H_ */ diff --git a/src/kernel/ao_packet.h b/src/kernel/ao_packet.h index 9d99b0e6..24cd7b13 100644 --- a/src/kernel/ao_packet.h +++ b/src/kernel/ao_packet.h @@ -43,13 +43,13 @@ struct ao_packet_recv { uint8_t status; }; -extern __xdata struct ao_packet_recv ao_rx_packet; -extern __xdata struct ao_packet ao_tx_packet; -extern __xdata struct ao_task ao_packet_task; -extern __xdata uint8_t ao_packet_enable; -extern __xdata uint8_t ao_packet_master_sleeping; -extern __pdata uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used; -extern __xdata uint8_t ao_packet_restart; +extern struct ao_packet_recv ao_rx_packet; +extern struct ao_packet ao_tx_packet; +extern struct ao_task ao_packet_task; +extern uint8_t ao_packet_enable; +extern uint8_t ao_packet_master_sleeping; +extern uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used; +extern uint8_t ao_packet_restart; void ao_packet_send(void); @@ -61,7 +61,7 @@ void ao_packet_flush(void); void -ao_packet_putchar(char c) __reentrant; +ao_packet_putchar(char c); int _ao_packet_pollchar(void); @@ -69,7 +69,7 @@ _ao_packet_pollchar(void); #if PACKET_HAS_MASTER /* ao_packet_master.c */ -extern __xdata int8_t ao_packet_last_rssi; +extern int8_t ao_packet_last_rssi; void ao_packet_master_init(void); diff --git a/src/kernel/ao_power.c b/src/kernel/ao_power.c index bf59ab53..8c490604 100644 --- a/src/kernel/ao_power.c +++ b/src/kernel/ao_power.c @@ -26,7 +26,7 @@ ao_power_register(struct ao_power *power) { if (power->registered) return; - power->registered = TRUE; + power->registered = true; if (tail) { tail->next = power; power->prev = tail; @@ -44,7 +44,7 @@ ao_power_unregister(struct ao_power *power) { if (!power->registered) return; - power->registered = FALSE; + power->registered = false; if (power->prev) power->prev->next = power->next; else diff --git a/src/kernel/ao_product.c b/src/kernel/ao_product.c index 4c2d83ef..72488654 100644 --- a/src/kernel/ao_product.c +++ b/src/kernel/ao_product.c @@ -61,7 +61,7 @@ const char ao_product[] = AO_iProduct_STRING; #define NUM_INTERFACES (AO_USB_HAS_INT + 1) /* USB descriptors in one giant block of bytes */ -AO_ROMCONFIG_SYMBOL(0x00aa) uint8_t ao_usb_descriptors [] = +AO_ROMCONFIG_SYMBOL uint8_t ao_usb_descriptors [] = { /* Device descriptor */ 0x12, diff --git a/src/kernel/ao_pyro.c b/src/kernel/ao_pyro.c index 527112ac..30d1518f 100644 --- a/src/kernel/ao_pyro.c +++ b/src/kernel/ao_pyro.c @@ -38,8 +38,8 @@ enum ao_igniter_status ao_pyro_status(uint8_t p) { - __xdata struct ao_data packet; - __pdata int16_t value; + struct ao_data packet; + int16_t value; ao_arch_critical( ao_data_get(&packet); @@ -205,9 +205,9 @@ ao_pyro_ready(struct ao_pyro *pyro) default: continue; } - return FALSE; + return false; } - return TRUE; + return true; } #ifndef AO_FLIGHT_TEST @@ -216,28 +216,28 @@ ao_pyro_pin_set(uint8_t p, uint8_t v) { switch (p) { #if AO_PYRO_NUM > 0 - case 0: ao_gpio_set(AO_PYRO_PORT_0, AO_PYRO_PIN_0, AO_PYRO_0, v); break; + case 0: ao_gpio_set(AO_PYRO_PORT_0, AO_PYRO_PIN_0, v); break; #endif #if AO_PYRO_NUM > 1 - case 1: ao_gpio_set(AO_PYRO_PORT_1, AO_PYRO_PIN_1, AO_PYRO_1, v); break; + case 1: ao_gpio_set(AO_PYRO_PORT_1, AO_PYRO_PIN_1, v); break; #endif #if AO_PYRO_NUM > 2 - case 2: ao_gpio_set(AO_PYRO_PORT_2, AO_PYRO_PIN_2, AO_PYRO_2, v); break; + case 2: ao_gpio_set(AO_PYRO_PORT_2, AO_PYRO_PIN_2, v); break; #endif #if AO_PYRO_NUM > 3 - case 3: ao_gpio_set(AO_PYRO_PORT_3, AO_PYRO_PIN_3, AO_PYRO_3, v); break; + case 3: ao_gpio_set(AO_PYRO_PORT_3, AO_PYRO_PIN_3, v); break; #endif #if AO_PYRO_NUM > 4 - case 4: ao_gpio_set(AO_PYRO_PORT_4, AO_PYRO_PIN_4, AO_PYRO_4, v); break; + case 4: ao_gpio_set(AO_PYRO_PORT_4, AO_PYRO_PIN_4, v); break; #endif #if AO_PYRO_NUM > 5 - case 5: ao_gpio_set(AO_PYRO_PORT_5, AO_PYRO_PIN_5, AO_PYRO_5, v); break; + case 5: ao_gpio_set(AO_PYRO_PORT_5, AO_PYRO_PIN_5, v); break; #endif #if AO_PYRO_NUM > 6 - case 6: ao_gpio_set(AO_PYRO_PORT_6, AO_PYRO_PIN_6, AO_PYRO_6, v); break; + case 6: ao_gpio_set(AO_PYRO_PORT_6, AO_PYRO_PIN_6, v); break; #endif #if AO_PYRO_NUM > 7 - case 7: ao_gpio_set(AO_PYRO_PORT_7, AO_PYRO_PIN_7, AO_PYRO_7, v); break; + case 7: ao_gpio_set(AO_PYRO_PORT_7, AO_PYRO_PIN_7, v); break; #endif default: break; } @@ -404,7 +404,7 @@ ao_pyro(void) ao_exit(); } -__xdata struct ao_task ao_pyro_task; +struct ao_task ao_pyro_task; static void @@ -484,10 +484,9 @@ ao_pyro_set(void) } #endif - ao_cmd_decimal(); + p = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - p = ao_cmd_lex_i; if (AO_PYRO_NUM <= p) { printf ("invalid pyro channel %d\n", p); return; @@ -516,25 +515,23 @@ ao_pyro_set(void) } pyro_tmp.flags |= ao_pyro_values[v].flag; if (ao_pyro_values[v].offset != NO_VALUE) { - uint8_t negative = 0; + int16_t r = 1; ao_cmd_white(); if (ao_cmd_lex_c == '-') { - negative = 1; + r = -1; ao_cmd_lex(); } - ao_cmd_decimal(); + r *= ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; if (ao_pyro_values[v].flag & AO_PYRO_8_BIT_VALUE) { - if (negative) { + if (r < 0) { ao_cmd_status = ao_cmd_syntax_error; return; } - *((uint8_t *) ((char *) &pyro_tmp + ao_pyro_values[v].offset)) = ao_cmd_lex_i; + *((uint8_t *) ((char *) &pyro_tmp + ao_pyro_values[v].offset)) = r; } else { - if (negative) - ao_cmd_lex_i = -ao_cmd_lex_i; - *((int16_t *) (void *) ((char *) &pyro_tmp + ao_pyro_values[v].offset)) = ao_cmd_lex_i; + *((int16_t *) (void *) ((char *) &pyro_tmp + ao_pyro_values[v].offset)) = r; } } } @@ -558,28 +555,28 @@ void ao_pyro_init(void) { #if AO_PYRO_NUM > 0 - ao_enable_output(AO_PYRO_PORT_0, AO_PYRO_PIN_0, AO_PYRO_0, 0); + ao_enable_output(AO_PYRO_PORT_0, AO_PYRO_PIN_0, 0); #endif #if AO_PYRO_NUM > 1 - ao_enable_output(AO_PYRO_PORT_1, AO_PYRO_PIN_1, AO_PYRO_1, 0); + ao_enable_output(AO_PYRO_PORT_1, AO_PYRO_PIN_1, 0); #endif #if AO_PYRO_NUM > 2 - ao_enable_output(AO_PYRO_PORT_2, AO_PYRO_PIN_2, AO_PYRO_2, 0); + ao_enable_output(AO_PYRO_PORT_2, AO_PYRO_PIN_2, 0); #endif #if AO_PYRO_NUM > 3 - ao_enable_output(AO_PYRO_PORT_3, AO_PYRO_PIN_3, AO_PYRO_3, 0); + ao_enable_output(AO_PYRO_PORT_3, AO_PYRO_PIN_3, 0); #endif #if AO_PYRO_NUM > 4 - ao_enable_output(AO_PYRO_PORT_4, AO_PYRO_PIN_4, AO_PYRO_4, 0); + ao_enable_output(AO_PYRO_PORT_4, AO_PYRO_PIN_4, 0); #endif #if AO_PYRO_NUM > 5 - ao_enable_output(AO_PYRO_PORT_5, AO_PYRO_PIN_5, AO_PYRO_5, 0); + ao_enable_output(AO_PYRO_PORT_5, AO_PYRO_PIN_5, 0); #endif #if AO_PYRO_NUM > 6 - ao_enable_output(AO_PYRO_PORT_6, AO_PYRO_PIN_6, AO_PYRO_6, 0); + ao_enable_output(AO_PYRO_PORT_6, AO_PYRO_PIN_6, 0); #endif #if AO_PYRO_NUM > 7 - ao_enable_output(AO_PYRO_PORT_7, AO_PYRO_PIN_7, AO_PYRO_7, 0); + ao_enable_output(AO_PYRO_PORT_7, AO_PYRO_PIN_7, 0); #endif ao_add_task(&ao_pyro_task, ao_pyro, "pyro"); } diff --git a/src/kernel/ao_radio_cmac.c b/src/kernel/ao_radio_cmac.c index 92b365a2..155fce35 100644 --- a/src/kernel/ao_radio_cmac.c +++ b/src/kernel/ao_radio_cmac.c @@ -19,9 +19,9 @@ #include <ao.h> #include <ao_radio_cmac.h> -static __xdata uint8_t ao_radio_cmac_mutex; -__pdata int8_t ao_radio_cmac_rssi; -static __xdata uint8_t cmac_data[AO_CMAC_MAX_LEN + AO_CMAC_KEY_LEN + 2 + AO_CMAC_KEY_LEN]; +static uint8_t ao_radio_cmac_mutex; +int8_t ao_radio_cmac_rssi; +static uint8_t cmac_data[AO_CMAC_MAX_LEN + AO_CMAC_KEY_LEN + 2 + AO_CMAC_KEY_LEN]; static uint8_t round_len(uint8_t len) @@ -45,7 +45,7 @@ round_len(uint8_t len) * Sign and deliver the data sitting in the cmac buffer */ static void -radio_cmac_send(uint8_t len) __reentrant +radio_cmac_send(uint8_t len) { uint8_t i; @@ -77,7 +77,7 @@ radio_cmac_send(uint8_t len) __reentrant */ static int8_t -radio_cmac_recv(uint8_t len, uint16_t timeout) __reentrant +radio_cmac_recv(uint8_t len, uint16_t timeout) { uint8_t i; @@ -127,7 +127,7 @@ radio_cmac_recv(uint8_t len, uint16_t timeout) __reentrant } int8_t -ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant +ao_radio_cmac_send(void *packet, uint8_t len) { if (len > AO_CMAC_MAX_LEN) return AO_RADIO_CMAC_LEN_ERROR; @@ -145,7 +145,7 @@ ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant } int8_t -ao_radio_cmac_recv(__xdata void *packet, uint8_t len, uint16_t timeout) __reentrant +ao_radio_cmac_recv(void *packet, uint8_t len, uint16_t timeout) { int8_t i; if (len > AO_CMAC_MAX_LEN) diff --git a/src/kernel/ao_radio_cmac.h b/src/kernel/ao_radio_cmac.h index 74fe8c60..5fd6e105 100644 --- a/src/kernel/ao_radio_cmac.h +++ b/src/kernel/ao_radio_cmac.h @@ -24,10 +24,10 @@ #define AO_CMAC_KEY_LEN AO_AES_LEN #define AO_CMAC_MAX_LEN (128 - AO_CMAC_KEY_LEN) -extern __pdata int8_t ao_radio_cmac_rssi; +extern int8_t ao_radio_cmac_rssi; int8_t -ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant; +ao_radio_cmac_send(void *packet, uint8_t len); #define AO_RADIO_CMAC_OK 0 #define AO_RADIO_CMAC_LEN_ERROR -1 @@ -36,7 +36,7 @@ ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant; #define AO_RADIO_CMAC_TIMEOUT -4 int8_t -ao_radio_cmac_recv(__xdata void *packet, uint8_t len, uint16_t timeout) __reentrant; +ao_radio_cmac_recv(void *packet, uint8_t len, uint16_t timeout); void ao_radio_cmac_init(void); diff --git a/src/kernel/ao_radio_cmac_cmd.c b/src/kernel/ao_radio_cmac_cmd.c index 6d29f392..1433e96d 100644 --- a/src/kernel/ao_radio_cmac_cmd.c +++ b/src/kernel/ao_radio_cmac_cmd.c @@ -20,7 +20,7 @@ #include <ao_radio_cmac_cmd.h> #include <ao_radio_cmac.h> -static __xdata uint8_t cmac_data[AO_CMAC_MAX_LEN]; +static uint8_t cmac_data[AO_CMAC_MAX_LEN]; static uint8_t getnibble(void) @@ -45,21 +45,19 @@ getbyte(void) } static void -radio_cmac_send_cmd(void) __reentrant +radio_cmac_send_cmd(void) { uint8_t i; uint8_t len; - ao_cmd_decimal(); + len = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - len = ao_cmd_lex_i; if (len > AO_CMAC_MAX_LEN) { ao_cmd_status = ao_cmd_syntax_error; return; } flush(); - len = ao_cmd_lex_i; for (i = 0; i < len; i++) { cmac_data[i] = getbyte(); if (ao_cmd_status != ao_cmd_success) @@ -69,19 +67,17 @@ radio_cmac_send_cmd(void) __reentrant } static void -radio_cmac_recv_cmd(void) __reentrant +radio_cmac_recv_cmd(void) { uint8_t len, i; uint16_t timeout; - ao_cmd_decimal(); + len = ao_cmd_decimal(); if (ao_cmd_status != ao_cmd_success) return; - len = ao_cmd_lex_i; - ao_cmd_decimal(); + timeout = AO_MS_TO_TICKS(ao_cmd_decimal()); if (ao_cmd_status != ao_cmd_success) return; - timeout = AO_MS_TO_TICKS(ao_cmd_lex_i); i = ao_radio_cmac_recv(cmac_data, len, timeout); if (i == AO_RADIO_CMAC_OK) { printf ("PACKET "); @@ -92,7 +88,7 @@ radio_cmac_recv_cmd(void) __reentrant printf ("ERROR %d %d\n", i, ao_radio_cmac_rssi); } -static __code struct ao_cmds ao_radio_cmac_cmds[] = { +static const struct ao_cmds ao_radio_cmac_cmds[] = { { radio_cmac_send_cmd, "s <length>\0Send AES-CMAC packet. Bytes to send follow on next line" }, { radio_cmac_recv_cmd, "S <length> <timeout>\0Receive AES-CMAC packet. Timeout in ms" }, { 0, NULL }, diff --git a/src/kernel/ao_report.c b/src/kernel/ao_report.c index af48b390..08967af8 100644 --- a/src/kernel/ao_report.c +++ b/src/kernel/ao_report.c @@ -58,7 +58,7 @@ static const uint8_t flight_reports[] = { #endif #define pause(time) ao_delay(time) -static __pdata enum ao_flight_state ao_report_state; +static enum ao_flight_state ao_report_state; /* * Farnsworth spacing @@ -115,7 +115,7 @@ static __pdata enum ao_flight_state ao_report_state; */ static void -ao_report_beep(void) __reentrant +ao_report_beep(void) { uint8_t r = flight_reports[ao_flight_state]; uint8_t l = r & 7; @@ -134,7 +134,7 @@ ao_report_beep(void) __reentrant } static void -ao_report_digit(uint8_t digit) __reentrant +ao_report_digit(uint8_t digit) { if (!digit) { mid(AO_MS_TO_TICKS(500)); @@ -151,8 +151,8 @@ ao_report_digit(uint8_t digit) __reentrant static void ao_report_number(int16_t n) { - __xdata uint8_t digits[10]; - __pdata uint8_t ndigits, i; + uint8_t digits[10]; + uint8_t ndigits, i; if (n < 0) n = 0; @@ -178,12 +178,12 @@ ao_report_altitude(void) static void ao_report_battery(void) { - __xdata struct ao_data packet; + struct ao_data packet; for (;;) { ao_data_get(&packet); if (packet.adc.v_batt != 0) break; - ao_sleep(DATA_TO_XDATA(&ao_sample_data)); + ao_sleep(&ao_sample_data); } ao_report_number(ao_battery_decivolt(packet.adc.v_batt)); } @@ -204,7 +204,7 @@ ao_report_igniter(void) } static void -ao_report_continuity(void) __reentrant +ao_report_continuity(void) { uint8_t c; @@ -281,11 +281,11 @@ ao_report(void) } #endif while (ao_report_state == ao_flight_state) - ao_sleep(DATA_TO_XDATA(&ao_flight_state)); + ao_sleep(&ao_flight_state); } } -static __xdata struct ao_task ao_report_task; +static struct ao_task ao_report_task; void ao_report_init(void) diff --git a/src/kernel/ao_report_micro.c b/src/kernel/ao_report_micro.c index 9c7afdc5..efada54b 100644 --- a/src/kernel/ao_report_micro.c +++ b/src/kernel/ao_report_micro.c @@ -23,7 +23,7 @@ #define pause(time) ao_delay(time) static void -ao_report_digit(uint8_t digit) __reentrant +ao_report_digit(uint8_t digit) { if (!digit) { mid(AO_MS_TO_TICKS(1000)); @@ -40,9 +40,9 @@ ao_report_digit(uint8_t digit) __reentrant void ao_report_altitude(void) { - __pdata alt_t agl = ao_max_height; - static __xdata uint8_t digits[11]; - __pdata uint8_t ndigits, i; + alt_t agl = ao_max_height; + static uint8_t digits[11]; + uint8_t ndigits, i; if (agl < 0) agl = 0; diff --git a/src/kernel/ao_romconfig.c b/src/kernel/ao_romconfig.c new file mode 100644 index 00000000..b75142f5 --- /dev/null +++ b/src/kernel/ao_romconfig.c @@ -0,0 +1,26 @@ +/* + * Copyright © 2011 Keith Packard <keithp@keithp.com> + * + * 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; either version 2 of the License, or + * (at your option) any later version. + * + * 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" + +AO_ROMCONFIG_SYMBOL uint16_t ao_romconfig_version = AO_ROMCONFIG_VERSION; +AO_ROMCONFIG_SYMBOL uint16_t ao_romconfig_check = ~AO_ROMCONFIG_VERSION; +AO_ROMCONFIG_SYMBOL uint16_t ao_serial_number = 0; +#if HAS_RADIO +AO_ROMCONFIG_SYMBOL uint32_t ao_radio_cal = AO_RADIO_CAL_DEFAULT; +#endif diff --git a/src/kernel/ao_rssi.c b/src/kernel/ao_rssi.c index 66fb8b57..aacc38b2 100644 --- a/src/kernel/ao_rssi.c +++ b/src/kernel/ao_rssi.c @@ -18,9 +18,9 @@ #include "ao.h" -static __xdata uint16_t ao_rssi_time; -static __pdata uint16_t ao_rssi_delay; -static __pdata AO_LED_TYPE ao_rssi_led; +static uint16_t ao_rssi_time; +static uint16_t ao_rssi_delay; +static AO_LED_TYPE ao_rssi_led; void ao_rssi(void) @@ -43,7 +43,7 @@ ao_rssi_set(int16_t rssi_value) ao_wakeup(&ao_rssi_time); } -__xdata struct ao_task ao_rssi_task; +struct ao_task ao_rssi_task; void ao_rssi_init(AO_LED_TYPE rssi_led) diff --git a/src/kernel/ao_sample.c b/src/kernel/ao_sample.c index f8012e34..9cba36c1 100644 --- a/src/kernel/ao_sample.c +++ b/src/kernel/ao_sample.c @@ -35,63 +35,63 @@ #define ACCEL_TYPE int16_t #endif -__pdata uint16_t ao_sample_tick; /* time of last data */ -__pdata pres_t ao_sample_pres; -__pdata alt_t ao_sample_alt; -__pdata alt_t ao_sample_height; +uint16_t ao_sample_tick; /* time of last data */ +pres_t ao_sample_pres; +alt_t ao_sample_alt; +alt_t ao_sample_height; #if HAS_ACCEL -__pdata accel_t ao_sample_accel; +accel_t ao_sample_accel; #endif #if HAS_GYRO -__pdata accel_t ao_sample_accel_along; -__pdata accel_t ao_sample_accel_across; -__pdata accel_t ao_sample_accel_through; -__pdata gyro_t ao_sample_roll; -__pdata gyro_t ao_sample_pitch; -__pdata gyro_t ao_sample_yaw; -__pdata angle_t ao_sample_orient; -__pdata angle_t ao_sample_orients[AO_NUM_ORIENT]; -__pdata uint8_t ao_sample_orient_pos; +accel_t ao_sample_accel_along; +accel_t ao_sample_accel_across; +accel_t ao_sample_accel_through; +gyro_t ao_sample_roll; +gyro_t ao_sample_pitch; +gyro_t ao_sample_yaw; +angle_t ao_sample_orient; +angle_t ao_sample_orients[AO_NUM_ORIENT]; +uint8_t ao_sample_orient_pos; #endif -__data uint8_t ao_sample_data; +uint8_t ao_sample_data; /* * Sensor calibration values */ -__pdata pres_t ao_ground_pres; /* startup pressure */ -__pdata alt_t ao_ground_height; /* MSL of ao_ground_pres */ +pres_t ao_ground_pres; /* startup pressure */ +alt_t ao_ground_height; /* MSL of ao_ground_pres */ #if HAS_ACCEL -__pdata accel_t ao_ground_accel; /* startup acceleration */ -__pdata accel_t ao_accel_2g; /* factory accel calibration */ -__pdata int32_t ao_accel_scale; /* sensor to m/s² conversion */ +accel_t ao_ground_accel; /* startup acceleration */ +accel_t ao_accel_2g; /* factory accel calibration */ +int32_t ao_accel_scale; /* sensor to m/s² conversion */ #endif #if HAS_GYRO -__pdata accel_t ao_ground_accel_along; -__pdata accel_t ao_ground_accel_across; -__pdata accel_t ao_ground_accel_through; -__pdata int32_t ao_ground_pitch; -__pdata int32_t ao_ground_yaw; -__pdata int32_t ao_ground_roll; +accel_t ao_ground_accel_along; +accel_t ao_ground_accel_across; +accel_t ao_ground_accel_through; +int32_t ao_ground_pitch; +int32_t ao_ground_yaw; +int32_t ao_ground_roll; #endif -static __pdata uint8_t ao_preflight; /* in preflight mode */ +static uint8_t ao_preflight; /* in preflight mode */ -static __pdata uint16_t nsamples; -__pdata int32_t ao_sample_pres_sum; +static uint16_t nsamples; +int32_t ao_sample_pres_sum; #if HAS_ACCEL -__pdata int32_t ao_sample_accel_sum; +int32_t ao_sample_accel_sum; #endif #if HAS_GYRO -__pdata int32_t ao_sample_accel_along_sum; -__pdata int32_t ao_sample_accel_across_sum; -__pdata int32_t ao_sample_accel_through_sum; -__pdata int32_t ao_sample_pitch_sum; -__pdata int32_t ao_sample_yaw_sum; -__pdata int32_t ao_sample_roll_sum; +int32_t ao_sample_accel_along_sum; +int32_t ao_sample_accel_across_sum; +int32_t ao_sample_accel_through_sum; +int32_t ao_sample_pitch_sum; +int32_t ao_sample_yaw_sum; +int32_t ao_sample_roll_sum; static struct ao_quaternion ao_rotation; #endif @@ -277,7 +277,7 @@ ao_sample_preflight(void) ao_accel_scale = to_fix_32(GRAVITY * 2 * 16) / ao_accel_2g; #endif ao_sample_preflight_set(); - ao_preflight = FALSE; + ao_preflight = false; } } @@ -321,10 +321,10 @@ static gyro_t inline ao_gyro(void) { uint8_t ao_sample(void) { - ao_wakeup(DATA_TO_XDATA(&ao_sample_data)); - ao_sleep((void *) DATA_TO_XDATA(&ao_data_head)); + ao_wakeup(&ao_sample_data); + ao_sleep((void *) &ao_data_head); while (ao_sample_data != ao_data_head) { - __xdata struct ao_data *ao_data; + struct ao_data *ao_data; /* Capture a sample */ ao_data = (struct ao_data *) &ao_data_ring[ao_sample_data]; @@ -398,5 +398,5 @@ ao_sample_init(void) ao_sample_set_all_orients(); #endif ao_sample_data = ao_data_head; - ao_preflight = TRUE; + ao_preflight = true; } diff --git a/src/kernel/ao_sample.h b/src/kernel/ao_sample.h index 5ae389be..4c51a58c 100644 --- a/src/kernel/ao_sample.h +++ b/src/kernel/ao_sample.h @@ -115,46 +115,46 @@ typedef int16_t ao_v_t; #define AO_MS_TO_SPEED(ms) ((ao_v_t) ((ms) * 16)) #define AO_MSS_TO_ACCEL(mss) ((ao_v_t) ((mss) * 16)) -extern __pdata uint16_t ao_sample_tick; /* time of last data */ -extern __data uint8_t ao_sample_adc; /* Ring position of last processed sample */ -extern __data uint8_t ao_sample_data; /* Ring position of last processed sample */ +extern uint16_t ao_sample_tick; /* time of last data */ +extern uint8_t ao_sample_adc; /* Ring position of last processed sample */ +extern uint8_t ao_sample_data; /* Ring position of last processed sample */ #if HAS_BARO -extern __pdata pres_t ao_sample_pres; /* most recent pressure sensor reading */ -extern __pdata alt_t ao_sample_alt; /* MSL of ao_sample_pres */ -extern __pdata alt_t ao_sample_height; /* AGL of ao_sample_pres */ -extern __pdata pres_t ao_ground_pres; /* startup pressure */ -extern __pdata alt_t ao_ground_height; /* MSL of ao_ground_pres */ +extern pres_t ao_sample_pres; /* most recent pressure sensor reading */ +extern alt_t ao_sample_alt; /* MSL of ao_sample_pres */ +extern alt_t ao_sample_height; /* AGL of ao_sample_pres */ +extern pres_t ao_ground_pres; /* startup pressure */ +extern alt_t ao_ground_height; /* MSL of ao_ground_pres */ #endif #if HAS_ACCEL -extern __pdata accel_t ao_sample_accel; /* most recent accel sensor reading */ -extern __pdata accel_t ao_ground_accel; /* startup acceleration */ -extern __pdata accel_t ao_accel_2g; /* factory accel calibration */ -extern __pdata int32_t ao_accel_scale; /* sensor to m/s² conversion */ +extern accel_t ao_sample_accel; /* most recent accel sensor reading */ +extern accel_t ao_ground_accel; /* startup acceleration */ +extern accel_t ao_accel_2g; /* factory accel calibration */ +extern int32_t ao_accel_scale; /* sensor to m/s² conversion */ #endif #if HAS_GYRO -extern __pdata accel_t ao_ground_accel_along; -extern __pdata accel_t ao_ground_accel_across; -extern __pdata accel_t ao_ground_accel_through; -extern __pdata int32_t ao_ground_pitch; /* * 512 */ -extern __pdata int32_t ao_ground_yaw; /* * 512 */ -extern __pdata int32_t ao_ground_roll; /* * 512 */ -extern __pdata accel_t ao_sample_accel_along; -extern __pdata accel_t ao_sample_accel_across; -extern __pdata accel_t ao_sample_accel_through; -extern __pdata gyro_t ao_sample_roll; -extern __pdata gyro_t ao_sample_pitch; -extern __pdata gyro_t ao_sample_yaw; +extern accel_t ao_ground_accel_along; +extern accel_t ao_ground_accel_across; +extern accel_t ao_ground_accel_through; +extern int32_t ao_ground_pitch; /* * 512 */ +extern int32_t ao_ground_yaw; /* * 512 */ +extern int32_t ao_ground_roll; /* * 512 */ +extern accel_t ao_sample_accel_along; +extern accel_t ao_sample_accel_across; +extern accel_t ao_sample_accel_through; +extern gyro_t ao_sample_roll; +extern gyro_t ao_sample_pitch; +extern gyro_t ao_sample_yaw; #define AO_NUM_ORIENT 64 -extern __pdata angle_t ao_sample_orient; -extern __pdata angle_t ao_sample_orients[AO_NUM_ORIENT]; -extern __pdata uint8_t ao_sample_orient_pos; +extern angle_t ao_sample_orient; +extern angle_t ao_sample_orients[AO_NUM_ORIENT]; +extern uint8_t ao_sample_orient_pos; #endif void ao_sample_init(void); -/* returns FALSE in preflight mode, TRUE in flight mode */ +/* returns false in preflight mode, true in flight mode */ uint8_t ao_sample(void); /* @@ -176,19 +176,19 @@ uint8_t ao_sample(void); #define from_fix(x) ((x) >> 16) -extern __pdata ao_v_t ao_height; /* meters */ -extern __pdata ao_v_t ao_speed; /* m/s * 16 */ -extern __pdata ao_v_t ao_accel; /* m/s² * 16 */ -extern __xdata ao_v_t ao_max_height; /* max of ao_height */ -extern __xdata ao_v_t ao_avg_height; /* running average of height */ +extern ao_v_t ao_height; /* meters */ +extern ao_v_t ao_speed; /* m/s * 16 */ +extern ao_v_t ao_accel; /* m/s² * 16 */ +extern ao_v_t ao_max_height; /* max of ao_height */ +extern ao_v_t ao_avg_height; /* running average of height */ -extern __pdata ao_v_t ao_error_h; +extern ao_v_t ao_error_h; #if !HAS_ACCEL -extern __pdata ao_v_t ao_error_h_sq_avg; +extern ao_v_t ao_error_h_sq_avg; #endif #if HAS_ACCEL -extern __pdata ao_v_t ao_error_a; +extern ao_v_t ao_error_a; #endif #endif diff --git a/src/kernel/ao_sample_profile.c b/src/kernel/ao_sample_profile.c index 4819a161..b9d0e07f 100644 --- a/src/kernel/ao_sample_profile.c +++ b/src/kernel/ao_sample_profile.c @@ -160,7 +160,7 @@ ao_sample_profile_cmd(void) } } -static __code struct ao_cmds ao_sample_profile_cmds[] = { +static const struct ao_cmds ao_sample_profile_cmds[] = { { ao_sample_profile_cmd, "S <1 start,0 stop, d dump,c clear>\0Sample profile" }, { 0, NULL } }; diff --git a/src/kernel/ao_send_packet.c b/src/kernel/ao_send_packet.c index c8a1d46e..cae25151 100644 --- a/src/kernel/ao_send_packet.c +++ b/src/kernel/ao_send_packet.c @@ -20,17 +20,16 @@ #define AO_MAX_SEND 128 -static __xdata uint8_t ao_send[AO_MAX_SEND]; +static uint8_t ao_send[AO_MAX_SEND]; static void ao_send_packet(void) { - __pdata uint16_t count; + uint16_t count; uint8_t b; - __pdata uint8_t i; + uint8_t i; - ao_cmd_hex(); - count = ao_cmd_lex_i; + count = ao_cmd_hex(); if (ao_cmd_status != ao_cmd_success) return; if (count > AO_MAX_SEND - 2) { @@ -47,7 +46,7 @@ ao_send_packet(void) ao_radio_send(ao_send, count); } -static __code struct ao_cmds ao_send_packet_cmds[] = { +static const struct ao_cmds ao_send_packet_cmds[] = { { ao_send_packet, "S <len>\0Send packet. Data on next line" }, { 0, NULL } }; diff --git a/src/kernel/ao_serial.h b/src/kernel/ao_serial.h index ef3e93d7..440b562b 100644 --- a/src/kernel/ao_serial.h +++ b/src/kernel/ao_serial.h @@ -26,8 +26,8 @@ #define AO_SERIAL_SPEED_115200 4 #if HAS_SERIAL_0 -extern volatile __xdata struct ao_fifo ao_serial0_rx_fifo; -extern volatile __xdata struct ao_fifo ao_serial0_tx_fifo; +extern volatile struct ao_fifo ao_serial0_rx_fifo; +extern volatile struct ao_fifo ao_serial0_tx_fifo; char ao_serial0_getchar(void); @@ -49,8 +49,8 @@ ao_serial0_set_speed(uint8_t speed); #endif #if HAS_SERIAL_1 -extern volatile __xdata struct ao_fifo ao_serial1_rx_fifo; -extern volatile __xdata struct ao_fifo ao_serial1_tx_fifo; +extern volatile struct ao_fifo ao_serial1_rx_fifo; +extern volatile struct ao_fifo ao_serial1_tx_fifo; char ao_serial1_getchar(void); @@ -72,8 +72,8 @@ ao_serial1_set_speed(uint8_t speed); #endif #if HAS_SERIAL_2 -extern volatile __xdata struct ao_fifo ao_serial2_rx_fifo; -extern volatile __xdata struct ao_fifo ao_serial2_tx_fifo; +extern volatile struct ao_fifo ao_serial2_rx_fifo; +extern volatile struct ao_fifo ao_serial2_tx_fifo; char ao_serial2_getchar(void); @@ -95,8 +95,8 @@ ao_serial2_set_speed(uint8_t speed); #endif #if HAS_SERIAL_3 -extern volatile __xdata struct ao_fifo ao_serial3_rx_fifo; -extern volatile __xdata struct ao_fifo ao_serial3_tx_fifo; +extern volatile struct ao_fifo ao_serial3_rx_fifo; +extern volatile struct ao_fifo ao_serial3_tx_fifo; char ao_serial3_getchar(void); diff --git a/src/kernel/ao_stdio.c b/src/kernel/ao_stdio.c index dc09b5c7..c3b51d12 100644 --- a/src/kernel/ao_stdio.c +++ b/src/kernel/ao_stdio.c @@ -72,18 +72,18 @@ #define AO_NUM_STDIOS (HAS_USB + PACKET_HAS_SLAVE + USE_SERIAL_STDIN + CONSOLE_STDIN) -__xdata struct ao_stdio ao_stdios[AO_NUM_STDIOS]; +struct ao_stdio ao_stdios[AO_NUM_STDIOS]; #if AO_NUM_STDIOS > 1 -__pdata int8_t ao_cur_stdio; -__pdata int8_t ao_num_stdios; +int8_t ao_cur_stdio; +int8_t ao_num_stdios; #else -__pdata int8_t ao_cur_stdio; +int8_t ao_cur_stdio; #define ao_cur_stdio 0 #define ao_num_stdios 0 #endif -void +int ao_putchar(char c) { #if LOW_LEVEL_DEBUG @@ -92,12 +92,13 @@ ao_putchar(char c) if (c == '\n') ao_debug_out('\r'); ao_debug_out(c); - return; + return 0; } #endif if (c == '\n') (*ao_stdios[ao_cur_stdio].putchar)('\r'); (*ao_stdios[ao_cur_stdio].putchar)(c); + return 0; } void @@ -107,10 +108,10 @@ flush(void) ao_stdios[ao_cur_stdio].flush(); } -__xdata uint8_t ao_stdin_ready; +uint8_t ao_stdin_ready; char -ao_getchar(void) __reentrant +ao_getchar(void) { int c; int8_t stdio; @@ -144,7 +145,7 @@ ao_echo(void) int8_t ao_add_stdio(int (*_pollchar)(void), void (*putchar)(char), - void (*flush)(void)) __reentrant + void (*flush)(void)) { if (ao_num_stdios == AO_NUM_STDIOS) ao_panic(AO_PANIC_STDIO); @@ -158,3 +159,33 @@ ao_add_stdio(int (*_pollchar)(void), return 0; #endif } + +/* + * Basic I/O functions to support newlib tinystdio package + */ + +static int +ao_putc(char c, FILE *ignore) +{ + (void) ignore; + return ao_putchar(c); +} + +static int +ao_getc(FILE *ignore) +{ + (void) ignore; + return ao_getchar(); +} + +static int +ao_flushc(FILE *ignore) +{ + (void) ignore; + flush(); + return 0; +} + +static FILE __stdio = FDEV_SETUP_STREAM(ao_putc, ao_getc, ao_flushc, _FDEV_SETUP_RW); + +FILE *const __iob[3] = { &__stdio, &__stdio, &__stdio }; diff --git a/src/kernel/ao_storage.c b/src/kernel/ao_storage.c index 400751de..890bdcae 100644 --- a/src/kernel/ao_storage.c +++ b/src/kernel/ao_storage.c @@ -20,7 +20,7 @@ #include <ao_storage.h> uint8_t -ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant +ao_storage_read(ao_pos_t pos, void *buf, uint16_t len) { #ifdef CC1111 return ao_storage_device_read(pos, buf, len); @@ -54,7 +54,7 @@ ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant } uint8_t -ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant +ao_storage_write(ao_pos_t pos, void *buf, uint16_t len) { #ifdef CC1111 return ao_storage_device_write(pos, buf, len); @@ -87,20 +87,21 @@ ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant #endif } -static __xdata uint8_t storage_data[128]; +static uint8_t storage_data[128]; static void -ao_storage_dump(void) __reentrant +ao_storage_dump(void) { + uint32_t block; uint8_t i, j; - ao_cmd_hex(); + block = ao_cmd_hex(); if (ao_cmd_status != ao_cmd_success) return; for (i = 0; ; i += 8) { - if (ao_storage_read(((uint32_t) (ao_cmd_lex_i) << 8) + i, - storage_data, - 8)) { + if (ao_storage_read((block << 8) + i, + storage_data, + 8)) { ao_cmd_put16((uint16_t) i); for (j = 0; j < 8; j++) { putchar(' '); @@ -118,28 +119,24 @@ ao_storage_dump(void) __reentrant /* not enough space for this today */ static void -ao_storage_store(void) __reentrant +ao_storage_store(void) { uint16_t block; uint8_t i; uint16_t len; - static __xdata uint8_t b; + uint8_t b; uint32_t addr; - ao_cmd_hex(); - block = ao_cmd_lex_i; - ao_cmd_hex(); - i = ao_cmd_lex_i; + block = ao_cmd_hex(); + i = ao_cmd_hex(); addr = ((uint32_t) block << 8) | i; - ao_cmd_hex(); - len = ao_cmd_lex_i; + len = ao_cmd_hex(); if (ao_cmd_status != ao_cmd_success) return; while (len--) { - ao_cmd_hex(); + b = ao_cmd_hexbyte(); if (ao_cmd_status != ao_cmd_success) return; - b = ao_cmd_lex_i; ao_storage_write(addr, &b, 1); addr++; } @@ -147,16 +144,16 @@ ao_storage_store(void) __reentrant #endif void -ao_storage_zap(void) __reentrant +ao_storage_zap(void) { - ao_cmd_hex(); + uint32_t v = ao_cmd_hex(); if (ao_cmd_status != ao_cmd_success) return; - ao_storage_erase((uint32_t) ao_cmd_lex_i << 8); + ao_storage_erase((uint32_t) v << 8); } void -ao_storage_zapall(void) __reentrant +ao_storage_zapall(void) { uint32_t pos; @@ -272,7 +269,7 @@ ao_storage_incr_check_block(uint32_t pos) } static uint8_t -ao_storage_test_block(uint32_t pos) __reentrant +ao_storage_test_block(uint32_t pos) { ao_storage_erase(pos); printf(" erase"); flush(); @@ -299,7 +296,7 @@ ao_storage_test_block(uint32_t pos) __reentrant } static void -ao_storage_test(void) __reentrant +ao_storage_test(void) { uint32_t pos; @@ -316,7 +313,7 @@ ao_storage_test(void) __reentrant #endif /* AO_STORAGE_TEST */ void -ao_storage_info(void) __reentrant +ao_storage_info(void) { ao_storage_setup(); printf("Storage size: %ld\n", (long) ao_storage_total); @@ -324,7 +321,7 @@ ao_storage_info(void) __reentrant ao_storage_device_info(); } -__code struct ao_cmds ao_storage_cmds[] = { +const struct ao_cmds ao_storage_cmds[] = { { ao_storage_info, "f\0Show storage" }, { ao_storage_dump, "e <block>\0Dump flash" }, #if HAS_STORAGE_DEBUG diff --git a/src/kernel/ao_storage.h b/src/kernel/ao_storage.h index 59b137ad..cf37a824 100644 --- a/src/kernel/ao_storage.h +++ b/src/kernel/ao_storage.h @@ -31,10 +31,10 @@ typedef ao_storage_pos_t ao_pos_t; /* Total bytes of available storage */ -extern __pdata ao_pos_t ao_storage_total; +extern ao_pos_t ao_storage_total; /* Block size - device is erased in these units. At least 256 bytes */ -extern __pdata ao_pos_t ao_storage_block; +extern ao_pos_t ao_storage_block; #ifndef USE_STORAGE_CONFIG #define USE_STORAGE_CONFIG 1 @@ -42,7 +42,7 @@ extern __pdata ao_pos_t ao_storage_block; #if USE_STORAGE_CONFIG /* Byte offset of config block. Will be ao_storage_block bytes long */ -extern __pdata ao_pos_t ao_storage_config; +extern ao_pos_t ao_storage_config; #define ao_storage_log_max ao_storage_config #else @@ -50,27 +50,27 @@ extern __pdata ao_pos_t ao_storage_config; #endif /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */ -extern __pdata uint16_t ao_storage_unit; +extern uint16_t ao_storage_unit; /* Initialize above values. Can only be called once the OS is running */ void -ao_storage_setup(void) __reentrant; +ao_storage_setup(void); /* Write data. Returns 0 on failure, 1 on success */ uint8_t -ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant; +ao_storage_write(ao_pos_t pos, void *buf, uint16_t len); /* Read data. Returns 0 on failure, 1 on success */ uint8_t -ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant; +ao_storage_read(ao_pos_t pos, void *buf, uint16_t len); /* Erase a block of storage. This always clears ao_storage_block bytes */ uint8_t -ao_storage_erase(ao_pos_t pos) __reentrant; +ao_storage_erase(ao_pos_t pos); /* Flush any pending writes to stable storage */ void -ao_storage_flush(void) __reentrant; +ao_storage_flush(void); /* Initialize the storage code */ void @@ -82,11 +82,11 @@ ao_storage_init(void); /* Read data within a storage unit */ uint8_t -ao_storage_device_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant; +ao_storage_device_read(ao_pos_t pos, void *buf, uint16_t len); /* Write data within a storage unit */ uint8_t -ao_storage_device_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant; +ao_storage_device_write(ao_pos_t pos, void *buf, uint16_t len); /* Initialize low-level device bits */ void @@ -94,6 +94,6 @@ ao_storage_device_init(void); /* Print out information about flash chips */ void -ao_storage_device_info(void) __reentrant; +ao_storage_device_info(void); #endif /* _AO_STORAGE_H_ */ diff --git a/src/kernel/ao_task.c b/src/kernel/ao_task.c index de23ea02..dc5c1913 100644 --- a/src/kernel/ao_task.c +++ b/src/kernel/ao_task.c @@ -29,12 +29,12 @@ #define AO_NO_TASK_INDEX 0xff -__xdata struct ao_task * __xdata ao_tasks[AO_NUM_TASKS]; -__data uint8_t ao_num_tasks; -__xdata struct ao_task *__data ao_cur_task; +struct ao_task * ao_tasks[AO_NUM_TASKS]; +uint8_t ao_num_tasks; +struct ao_task *ao_cur_task; #if !HAS_TASK_QUEUE -static __data uint8_t ao_cur_task_index; +static uint8_t ao_cur_task_index; #endif #ifdef ao_arch_task_globals @@ -290,7 +290,7 @@ ao_task_validate(void) #endif /* HAS_TASK_QUEUE */ void -ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name) __reentrant +ao_add_task(struct ao_task * task, void (*start)(void), const char *name) { uint8_t task_id; uint8_t t; @@ -321,7 +321,7 @@ ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *nam ); } -__data uint8_t ao_task_minimize_latency; +uint8_t ao_task_minimize_latency; /* Task switching function. This must not use any stack variables */ void @@ -382,7 +382,7 @@ ao_yield(void) ao_arch_naked_define ao_cur_task = ao_list_first_entry(&run_queue, struct ao_task, queue); #else { - __pdata uint8_t ao_last_task_index = ao_cur_task_index; + uint8_t ao_last_task_index = ao_cur_task_index; for (;;) { ++ao_cur_task_index; if (ao_cur_task_index == ao_num_tasks) @@ -418,7 +418,7 @@ ao_yield(void) ao_arch_naked_define } uint8_t -ao_sleep(__xdata void *wchan) +ao_sleep(void *wchan) { #if HAS_TASK_QUEUE uint32_t flags; @@ -439,7 +439,7 @@ ao_sleep(__xdata void *wchan) } void -ao_wakeup(__xdata void *wchan) __reentrant +ao_wakeup(void *wchan) { ao_validate_cur_stack(); #if HAS_TASK_QUEUE @@ -470,7 +470,7 @@ ao_wakeup(__xdata void *wchan) __reentrant } uint8_t -ao_sleep_for(__xdata void *wchan, uint16_t timeout) +ao_sleep_for(void *wchan, uint16_t timeout) { uint8_t ret; if (timeout) { @@ -504,7 +504,7 @@ ao_sleep_for(__xdata void *wchan, uint16_t timeout) return ret; } -static __xdata uint8_t ao_forever; +static uint8_t ao_forever; void ao_delay(uint16_t ticks) @@ -541,7 +541,7 @@ void ao_task_info(void) { uint8_t i; - __xdata struct ao_task *task; + struct ao_task *task; uint16_t now = ao_time(); for (i = 0; i < ao_num_tasks; i++) { @@ -569,4 +569,5 @@ ao_start_scheduler(void) ao_arch_start_scheduler(); #endif ao_yield(); + __builtin_unreachable(); } diff --git a/src/kernel/ao_task.h b/src/kernel/ao_task.h index 7549b598..709e10c6 100644 --- a/src/kernel/ao_task.h +++ b/src/kernel/ao_task.h @@ -27,23 +27,21 @@ #endif /* arm stacks must be 32-bit aligned */ +#ifndef AO_STACK_ALIGNMENT #ifdef __arm__ #define AO_STACK_ALIGNMENT __attribute__ ((aligned(4))) -#endif -#ifdef SDCC +#else #define AO_STACK_ALIGNMENT #endif -#ifdef __AVR__ -#define AO_STACK_ALIGNMENT #endif /* An AltOS task */ struct ao_task { - __xdata void *wchan; /* current wait channel (NULL if running) */ + void *wchan; /* current wait channel (NULL if running) */ uint16_t alarm; /* abort ao_sleep time */ ao_arch_task_members /* any architecture-specific fields */ uint8_t task_id; /* unique id */ - __code char *name; /* task name */ + const char *name; /* task name */ #ifdef NEWLIB int __errno; /* storage for errno in newlib libc */ #endif @@ -66,10 +64,10 @@ struct ao_task { #define AO_NO_TASK 0 /* no task id */ -extern __xdata struct ao_task * __xdata ao_tasks[AO_NUM_TASKS]; -extern __data uint8_t ao_num_tasks; -extern __xdata struct ao_task *__data ao_cur_task; -extern __data uint8_t ao_task_minimize_latency; /* Reduce IRQ latency */ +extern struct ao_task * ao_tasks[AO_NUM_TASKS]; +extern uint8_t ao_num_tasks; +extern struct ao_task *ao_cur_task; +extern uint8_t ao_task_minimize_latency; /* Reduce IRQ latency */ #ifndef HAS_ARCH_VALIDATE_CUR_STACK #define ao_validate_cur_stack() @@ -85,7 +83,7 @@ extern __data uint8_t ao_task_minimize_latency; /* Reduce IRQ latency */ * 1 on alarm */ uint8_t -ao_sleep(__xdata void *wchan); +ao_sleep(void *wchan); /* Suspend the current task until wchan is awoken or the timeout * expires. returns: @@ -93,11 +91,11 @@ ao_sleep(__xdata void *wchan); * 1 on alarm */ uint8_t -ao_sleep_for(__xdata void *wchan, uint16_t timeout); +ao_sleep_for(void *wchan, uint16_t timeout); /* Wake all tasks sleeping on wchan */ void -ao_wakeup(__xdata void *wchan) __reentrant; +ao_wakeup(void *wchan); #if 0 /* set an alarm to go off in 'delay' ticks */ @@ -115,7 +113,7 @@ ao_yield(void) ao_arch_naked_declare; /* Add a task to the run queue */ void -ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name) __reentrant; +ao_add_task(struct ao_task * task, void (*start)(void), const char *name); #if HAS_TASK_QUEUE /* Called on timer interrupt to check alarms */ @@ -134,7 +132,7 @@ ao_task_info(void); /* Start the scheduler. This will not return */ void -ao_start_scheduler(void); +ao_start_scheduler(void) __attribute__((noreturn)); #if HAS_TASK_QUEUE void diff --git a/src/kernel/ao_telemetry.c b/src/kernel/ao_telemetry.c index 9ed612ce..9e1304f7 100644 --- a/src/kernel/ao_telemetry.c +++ b/src/kernel/ao_telemetry.c @@ -20,10 +20,10 @@ #include "ao_log.h" #include "ao_product.h" -static __pdata uint16_t ao_telemetry_interval; +static uint16_t ao_telemetry_interval; #if HAS_RADIO_RATE -static __xdata uint16_t ao_telemetry_desired_interval; +static uint16_t ao_telemetry_desired_interval; #endif /* TeleMetrum v1.0 just doesn't have enough space to @@ -37,10 +37,10 @@ static __xdata uint16_t ao_telemetry_desired_interval; #ifdef SIMPLIFY #define ao_telemetry_time time -#define RDF_SPACE __pdata +#define RDF_SPACE #else -#define RDF_SPACE __xdata -static __pdata uint16_t ao_telemetry_time; +#define RDF_SPACE +static uint16_t ao_telemetry_time; #endif #if HAS_RDF @@ -49,7 +49,7 @@ static RDF_SPACE uint16_t ao_rdf_time; #endif #if HAS_APRS -static __pdata uint16_t ao_aprs_time; +static uint16_t ao_aprs_time; #include <ao_aprs.h> #endif @@ -74,7 +74,7 @@ static __pdata uint16_t ao_aprs_time; #define AO_TELEMETRY_SENSOR AO_TELEMETRY_SENSOR_TELENANO #endif -static __xdata union ao_telemetry_all telemetry; +static union ao_telemetry_all telemetry; static void ao_telemetry_send(void) @@ -88,7 +88,7 @@ ao_telemetry_send(void) static void ao_send_sensor(void) { - __xdata struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; + struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; telemetry.generic.tick = packet->tick; telemetry.generic.type = AO_TELEMETRY_SENSOR; @@ -136,7 +136,7 @@ ao_send_sensor(void) static void ao_send_mega_sensor(void) { - __xdata struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; + struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; telemetry.generic.tick = packet->tick; telemetry.generic.type = AO_TELEMETRY_MEGA_SENSOR; @@ -181,15 +181,15 @@ ao_send_mega_sensor(void) ao_telemetry_send(); } -static __pdata int8_t ao_telemetry_mega_data_max; -static __pdata int8_t ao_telemetry_mega_data_cur; +static int8_t ao_telemetry_mega_data_max; +static int8_t ao_telemetry_mega_data_cur; /* Send mega data packet */ static void ao_send_mega_data(void) { if (--ao_telemetry_mega_data_cur <= 0) { - __xdata struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; + struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; uint8_t i; telemetry.generic.tick = packet->tick; @@ -223,7 +223,7 @@ ao_send_mega_data(void) static void ao_send_metrum_sensor(void) { - __xdata struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; + struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; telemetry.generic.tick = packet->tick; telemetry.generic.type = AO_TELEMETRY_METRUM_SENSOR; @@ -246,15 +246,15 @@ ao_send_metrum_sensor(void) ao_telemetry_send(); } -static __pdata int8_t ao_telemetry_metrum_data_max; -static __pdata int8_t ao_telemetry_metrum_data_cur; +static int8_t ao_telemetry_metrum_data_max; +static int8_t ao_telemetry_metrum_data_cur; /* Send telemetrum data packet */ static void ao_send_metrum_data(void) { if (--ao_telemetry_metrum_data_cur <= 0) { - __xdata struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; + struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; telemetry.generic.tick = packet->tick; telemetry.generic.type = AO_TELEMETRY_METRUM_DATA; @@ -281,7 +281,7 @@ ao_send_metrum_data(void) static void ao_send_mini(void) { - __xdata struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; + struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)]; telemetry.generic.tick = packet->tick; telemetry.generic.type = AO_SEND_MINI; @@ -306,9 +306,9 @@ ao_send_mini(void) #endif /* AO_SEND_MINI */ -static __pdata int8_t ao_telemetry_config_max; -static __pdata int8_t ao_telemetry_config_cur; -static __pdata uint16_t ao_telemetry_flight_number; +static int8_t ao_telemetry_config_max; +static int8_t ao_telemetry_config_cur; +static uint16_t ao_telemetry_flight_number; #ifndef ao_telemetry_battery_convert #define ao_telemetry_battery_convert(a) (a) @@ -337,7 +337,7 @@ ao_send_configuration(void) ao_config.callsign, AO_MAX_CALLSIGN); ao_xmemcpy (telemetry.configuration.version, - CODE_TO_XDATA(ao_version), + ao_version, AO_MAX_VERSION); ao_telemetry_config_cur = ao_telemetry_config_max; ao_telemetry_send(); @@ -346,9 +346,9 @@ ao_send_configuration(void) #if HAS_GPS -static __pdata int8_t ao_telemetry_gps_max; -static __pdata int8_t ao_telemetry_loc_cur; -static __pdata int8_t ao_telemetry_sat_cur; +static int8_t ao_telemetry_gps_max; +static int8_t ao_telemetry_loc_cur; +static int8_t ao_telemetry_sat_cur; static void ao_send_location(void) @@ -387,8 +387,8 @@ ao_send_satellite(void) #if HAS_COMPANION -static __pdata int8_t ao_telemetry_companion_max; -static __pdata int8_t ao_telemetry_companion_cur; +static int8_t ao_telemetry_companion_max; +static int8_t ao_telemetry_companion_cur; static void ao_send_companion(void) @@ -536,7 +536,7 @@ ao_telemetry_set_interval(uint16_t interval) #if HAS_RADIO_RATE /* Limit max telemetry rate based on available radio bandwidth. */ - static __xdata const uint16_t min_interval[] = { + static const uint16_t min_interval[] = { /* [AO_RADIO_RATE_38400] = */ AO_MS_TO_TICKS(100), /* [AO_RADIO_RATE_9600] = */ AO_MS_TO_TICKS(500), /* [AO_RADIO_RATE_2400] = */ AO_MS_TO_TICKS(1000) @@ -613,7 +613,7 @@ ao_rdf_set(uint8_t rdf) } #endif -__xdata struct ao_task ao_telemetry_task; +struct ao_task ao_telemetry_task; void ao_telemetry_init() diff --git a/src/kernel/ao_tracker.c b/src/kernel/ao_tracker.c index 46278530..1454c17c 100644 --- a/src/kernel/ao_tracker.c +++ b/src/kernel/ao_tracker.c @@ -30,7 +30,7 @@ static uint8_t ao_tracker_force_telem; static inline uint8_t ao_usb_connected(void) { - return ao_gpio_get(AO_USB_CONNECT_PORT, AO_USB_CONNECT_PIN, AO_USB_CONNECT) != 0; + return ao_gpio_get(AO_USB_CONNECT_PORT, AO_USB_CONNECT_PIN) != 0; } #else #define ao_usb_connected() 1 @@ -211,9 +211,9 @@ static struct ao_task ao_tracker_task; static void ao_tracker_set_telem(void) { - ao_cmd_hex(); + uint16_t r = ao_cmd_hex(); if (ao_cmd_status == ao_cmd_success) - ao_tracker_force_telem = ao_cmd_lex_i; + ao_tracker_force_telem = r; ao_cmd_status = ao_cmd_success; printf ("flight: %d\n", ao_flight_number); printf ("force_telem: %d\n", ao_tracker_force_telem); diff --git a/src/kernel/ao_usb.h b/src/kernel/ao_usb.h index 40516de1..6c74a042 100644 --- a/src/kernel/ao_usb.h +++ b/src/kernel/ao_usb.h @@ -69,7 +69,7 @@ ao_usb_disable(void); void ao_usb_init(void); -extern __code __at (0x00aa) uint8_t ao_usb_descriptors []; +extern const uint8_t ao_usb_descriptors []; #define AO_USB_SETUP_DIR_MASK (0x01 << 7) #define AO_USB_SETUP_TYPE_MASK (0x03 << 5) @@ -176,8 +176,8 @@ struct ao_usb_line_coding { uint8_t data_bits; } ; -extern __xdata struct ao_usb_line_coding ao_usb_line_coding; +extern struct ao_usb_line_coding ao_usb_line_coding; -extern __pdata uint8_t ao_usb_running; +extern uint8_t ao_usb_running; #endif /* _AO_USB_H_ */ |