Don't use a global variable to hold the result.
Signed-off-by: Keith Packard <keithp@keithp.com>
35 files changed:
static void
ao_video_toggle(void)
{
static void
ao_video_toggle(void)
{
- ao_cmd_decimal();
- if (ao_cmd_lex_i)
+ uint16_t r = ao_cmd_decimal();
+ if (r)
- ao_vga_enable(ao_cmd_lex_i);
}
static void
ao_ball_toggle(void)
{
}
static void
ao_ball_toggle(void)
{
- ao_cmd_decimal();
- ball_enable = ao_cmd_lex_i;
+ ball_enable = ao_cmd_decimal();
ao_wakeup(&ball_enable);
}
ao_wakeup(&ball_enable);
}
{
uint8_t start;
uint8_t value;
{
uint8_t start;
uint8_t value;
- start = ao_cmd_lex_i;
- ao_cmd_hex();
- value = ao_cmd_lex_i;
+ start = ao_cmd_decimal();
+ value = ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success)
return;
ao_as1107_write_8(start, value);
if (ao_cmd_status != ao_cmd_success)
return;
ao_as1107_write_8(start, value);
int8_t ao_btm_stdio;
uint8_t ao_btm_connected;
int8_t ao_btm_stdio;
uint8_t ao_btm_connected;
#if BT_DEBUG
char ao_btm_buffer[256];
#if BT_DEBUG
char ao_btm_buffer[256];
for (i = 0; i < ao_btm_ptr; i++) {
c = ao_btm_buffer[i];
for (i = 0; i < ao_btm_ptr; i++) {
c = ao_btm_buffer[i];
putchar(ao_btm_buffer[i]);
}
putchar('\n');
putchar(ao_btm_buffer[i]);
}
putchar('\n');
- ao_cmd_decimal();
- if (ao_cmd_status == ao_cmd_success && ao_cmd_lex_i)
+ r = ao_cmd_decimal();
+ if (ao_cmd_status == ao_cmd_success && r)
ao_btm_ptr = 0;
ao_cmd_status = ao_cmd_success;
}
ao_btm_ptr = 0;
ao_cmd_status = ao_cmd_success;
}
static void
ao_btm_speed(void)
{
static void
ao_btm_speed(void)
{
- ao_cmd_decimal();
- if (ao_cmd_lex_u32 == 57600)
+ switch (ao_cmd_decimal()) {
+ case 57600:
ao_serial_btm_set_speed(AO_SERIAL_SPEED_57600);
ao_serial_btm_set_speed(AO_SERIAL_SPEED_57600);
- else if (ao_cmd_lex_u32 == 19200)
ao_serial_btm_set_speed(AO_SERIAL_SPEED_19200);
ao_serial_btm_set_speed(AO_SERIAL_SPEED_19200);
ao_cmd_status = ao_cmd_syntax_error;
ao_cmd_status = ao_cmd_syntax_error;
}
static uint8_t ao_btm_enable;
}
static uint8_t ao_btm_enable;
static uint8_t radio_on;
ao_cmd_white();
if (ao_cmd_lex_c != '\n') {
static uint8_t radio_on;
ao_cmd_white();
if (ao_cmd_lex_c != '\n') {
- ao_cmd_decimal();
- mode = (uint8_t) ao_cmd_lex_u32;
+ mode = ao_cmd_decimal();
}
mode++;
if ((mode & 2) && !radio_on) {
}
mode++;
if ((mode & 2) && !radio_on) {
uint8_t mode = 2;
static uint8_t radio_on;
ao_cmd_white();
uint8_t mode = 2;
static uint8_t radio_on;
ao_cmd_white();
- if (ao_cmd_lex_c != '\n') {
- ao_cmd_decimal();
- mode = (uint8_t) ao_cmd_lex_u32;
- }
+ if (ao_cmd_lex_c != '\n')
+ mode = ao_cmd_decimal();
mode++;
if ((mode & 2) && !radio_on) {
#if HAS_MONITOR
mode++;
if ((mode & 2) && !radio_on) {
#if HAS_MONITOR
{
uint8_t mode = 2;
ao_cmd_white();
{
uint8_t mode = 2;
ao_cmd_white();
- if (ao_cmd_lex_c != '\n') {
- ao_cmd_decimal();
- mode = (uint8_t) ao_cmd_lex_u32;
- }
+ if (ao_cmd_lex_c != '\n')
+ mode = ao_cmd_decimal();
mode++;
if ((mode & 2))
ao_radio_test_on();
mode++;
if ((mode & 2))
ao_radio_test_on();
static void
ao_radio_strobe_test(void)
{
static void
ao_radio_strobe_test(void)
{
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- r = ao_radio_strobe(ao_cmd_lex_i);
+ r = ao_radio_strobe(addr);
printf ("Strobe %02x -> %02x (rdy %d state %d)\n",
printf ("Strobe %02x -> %02x (rdy %d state %d)\n",
r,
r >> 7,
(r >> 4) & 0x7);
r,
r >> 7,
(r >> 4) & 0x7);
uint16_t addr;
uint8_t data;
uint16_t addr;
uint8_t data;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- addr = ao_cmd_lex_i;
- ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
printf ("Write %04x = %02x\n", addr, data);
ao_radio_reg_write(addr, data);
}
printf ("Write %04x = %02x\n", addr, data);
ao_radio_reg_write(addr, data);
}
uint16_t addr;
uint8_t data;
uint16_t addr;
uint8_t data;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
data = ao_radio_reg_read(addr);
printf ("Read %04x = %02x\n", addr, data);
}
data = ao_radio_reg_read(addr);
printf ("Read %04x = %02x\n", addr, data);
}
#if AO_UBLOX_DEBUG
static void ao_gps_option(void)
{
#if AO_UBLOX_DEBUG
static void ao_gps_option(void)
{
+ uint16_t r = ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success) {
ao_cmd_status = ao_cmd_success;
ao_gps_show();
} else {
if (ao_cmd_status != ao_cmd_success) {
ao_cmd_status = ao_cmd_success;
ao_gps_show();
} else {
- ao_gps_dbg_enable = ao_cmd_lex_i;
printf ("gps debug set to %d\n", ao_gps_dbg_enable);
}
}
printf ("gps debug set to %d\n", ao_gps_dbg_enable);
}
}
void
ao_lco_set_debug(void)
{
void
ao_lco_set_debug(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status == ao_cmd_success)
if (ao_cmd_status == ao_cmd_success)
- ao_lco_debug = ao_cmd_lex_i != 0;
}
const struct ao_cmds ao_lco_cmds[] = {
}
const struct ao_cmds ao_lco_cmds[] = {
static void
lco_args(void)
{
static void
lco_args(void)
{
- ao_cmd_decimal();
- lco_box = ao_cmd_lex_i;
- ao_cmd_hex();
- lco_channels = ao_cmd_lex_i;
+ lco_box = ao_cmd_decimal();
+ lco_channels = ao_cmd_hex();
}
static struct ao_pad_query ao_pad_query;
}
static struct ao_pad_query ao_pad_query;
- ao_cmd_decimal();
- secs = ao_cmd_lex_i;
+ secs = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
r = lco_query();
if (ao_cmd_status != ao_cmd_success)
return;
r = lco_query();
- ao_cmd_decimal();
- secs = ao_cmd_lex_i;
+ secs = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
r = lco_query();
if (ao_cmd_status != ao_cmd_success)
return;
r = lco_query();
void
ao_lco_set_debug(void)
{
void
ao_lco_set_debug(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status == ao_cmd_success)
if (ao_cmd_status == ao_cmd_success)
- ao_lco_debug = ao_cmd_lex_i;
}
const struct ao_cmds ao_lco_cmds[] = {
}
const struct ao_cmds ao_lco_cmds[] = {
uint8_t addr;
uint8_t val;
uint8_t addr;
uint8_t val;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
ao_mpu9250_spi_get();
val = _ao_mpu9250_reg_read(addr);
ao_mpu9250_spi_put();
ao_mpu9250_spi_get();
val = _ao_mpu9250_reg_read(addr);
ao_mpu9250_spi_put();
uint8_t addr;
uint8_t val;
uint8_t addr;
uint8_t val;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- addr = ao_cmd_lex_i;
- ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
printf("Addr %02x val %02x\n", addr, val);
ao_mpu9250_spi_get();
_ao_mpu9250_reg_write(addr, val);
printf("Addr %02x val %02x\n", addr, val);
ao_mpu9250_spi_get();
_ao_mpu9250_reg_write(addr, val);
uint8_t addr;
uint8_t val;
uint8_t addr;
uint8_t val;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
ao_mpu9250_spi_get();
val = _ao_mpu9250_mag_reg_read(addr);
ao_mpu9250_spi_put();
ao_mpu9250_spi_get();
val = _ao_mpu9250_mag_reg_read(addr);
ao_mpu9250_spi_put();
uint8_t addr;
uint8_t val;
uint8_t addr;
uint8_t val;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- addr = ao_cmd_lex_i;
- ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
printf("Addr %02x val %02x\n", addr, val);
ao_mpu9250_spi_get();
_ao_mpu9250_mag_reg_write(addr, val);
printf("Addr %02x val %02x\n", addr, val);
ao_mpu9250_spi_get();
_ao_mpu9250_mag_reg_write(addr, val);
ao_cmd_white();
if (!ao_match_word("DoIt"))
return;
ao_cmd_white();
if (!ao_match_word("DoIt"))
return;
+ ignite = 1 << ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- ignite = 1 << ao_cmd_lex_i;
- ao_cmd_decimal();
+ repeat = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success) {
repeat = 1;
ao_cmd_status = ao_cmd_success;
if (ao_cmd_status != ao_cmd_success) {
repeat = 1;
ao_cmd_status = ao_cmd_success;
- } else
- repeat = ao_cmd_lex_i;
while (repeat-- > 0) {
ao_pad_ignite = ignite;
ao_wakeup(&ao_pad_ignite);
while (repeat-- > 0) {
ao_pad_ignite = ignite;
ao_wakeup(&ao_pad_ignite);
void
ao_pad_set_debug(void)
{
void
ao_pad_set_debug(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status == ao_cmd_success)
if (ao_cmd_status == ao_cmd_success)
- ao_pad_debug = ao_cmd_lex_i != 0;
ao_pad_alarm_debug(void)
{
uint8_t which, value;
ao_pad_alarm_debug(void)
{
uint8_t which, value;
+ which = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- which = ao_cmd_lex_i;
- ao_cmd_decimal();
+ value = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
printf ("Set %s to %d\n", which ? "siren" : "strobe", value);
if (which)
ao_siren(value);
printf ("Set %s to %d\n", which ? "siren" : "strobe", value);
if (which)
ao_siren(value);
static void
ao_led_test(void)
{
static void
ao_led_test(void)
{
+ AO_LED_TYPE r = ao_cmd_hexbyte();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- ao_led_set(ao_cmd_lex_i);
- printf("LEDs set to %02x\n", ao_cmd_lex_i);
+ ao_led_set(r);
+ printf("LEDs set to %x\n", r);
}
static const struct ao_cmds ao_led_cmds[] = {
}
static const struct ao_cmds ao_led_cmds[] = {
- ao_cmd_decimal();
- q = ao_cmd_lex_i;
if (q >= AO_QUADRATURE_COUNT)
ao_cmd_status = ao_cmd_syntax_error;
if (ao_cmd_status != ao_cmd_success)
if (q >= AO_QUADRATURE_COUNT)
ao_cmd_status = ao_cmd_syntax_error;
if (ao_cmd_status != ao_cmd_success)
ao_seven_segment_show(void)
{
uint8_t digit, value;
ao_seven_segment_show(void)
{
uint8_t digit, value;
- ao_cmd_decimal();
- digit = ao_cmd_lex_i;
- ao_cmd_decimal();
- value = ao_cmd_lex_i;
+ digit = ao_cmd_decimal();
+ value = ao_cmd_decimal();
ao_seven_segment_set(digit, value);
}
ao_seven_segment_set(digit, value);
}
static void
ao_watchdog_set(void)
{
static void
ao_watchdog_set(void)
{
+ uint32_t r = ao_cmd_hex();
if (ao_cmd_status == ao_cmd_success) {
if (ao_cmd_status == ao_cmd_success) {
- ao_watchdog_enabled = ao_cmd_lex_i != 0;
+ ao_watchdog_enabled = r != 0;
ao_wakeup(&ao_watchdog_enabled);
}
}
ao_wakeup(&ao_watchdog_enabled);
}
}
ao_cmd_syntax_error = 2,
};
ao_cmd_syntax_error = 2,
};
-extern uint16_t ao_cmd_lex_i;
-extern uint32_t ao_cmd_lex_u32;
extern char ao_cmd_lex_c;
extern enum ao_cmd_status ao_cmd_status;
extern char ao_cmd_lex_c;
extern enum ao_cmd_status ao_cmd_status;
int8_t
ao_cmd_hexchar(char c);
int8_t
ao_cmd_hexchar(char c);
ao_cmd_decimal(void);
/* Read a single hex nibble off stdin. */
ao_cmd_decimal(void);
/* Read a single hex nibble off stdin. */
#include "ao.h"
#include "ao_task.h"
#include "ao.h"
#include "ao_task.h"
-uint16_t ao_cmd_lex_i;
-uint32_t ao_cmd_lex_u32;
char ao_cmd_lex_c;
enum ao_cmd_status ao_cmd_status;
char ao_cmd_lex_c;
enum ao_cmd_status ao_cmd_status;
-void
-ao_cmd_hexbyte(void)
+static
+uint32_t
+_ao_cmd_hex(uint8_t lim)
- 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);
- ao_cmd_status = ao_cmd_syntax_error;
+ if (i == 0 || lim != 0xff)
+ ao_cmd_status = ao_cmd_lex_error;
- ao_cmd_lex_i = (ao_cmd_lex_i << 4) | n;
+ result = (result << 4) | n;
+uint8_t
+ao_cmd_hexbyte(void)
- uint8_t r = ao_cmd_lex_error;
- int8_t n;
+ return _ao_cmd_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 _ao_cmd_hex(0xff);
uint8_t r = ao_cmd_lex_error;
uint8_t r = ao_cmd_lex_error;
ao_cmd_white();
for(;;) {
if ('0' <= ao_cmd_lex_c && ao_cmd_lex_c <= '9')
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;
else
break;
r = ao_cmd_success;
}
if (r != ao_cmd_success)
ao_cmd_status = r;
}
if (r != ao_cmd_success)
ao_cmd_status = r;
- ao_cmd_lex_i = (uint16_t) ao_cmd_lex_u32;
+ uint32_t v = ao_cmd_hex();
if (ao_cmd_status == ao_cmd_success)
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;
void
ao_config_frequency_set(void)
{
void
ao_config_frequency_set(void)
{
+ uint32_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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
ao_config_set_radio();
_ao_config_edit_finish();
#if HAS_RADIO_RECV
void
ao_config_main_deploy_set(void)
{
void
ao_config_main_deploy_set(void)
{
+ uint32_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
_ao_config_edit_finish();
}
ao_config_accel_calibrate_set(void)
{
int16_t up, down;
ao_config_accel_calibrate_set(void)
{
int16_t up, down;
#if HAS_GYRO
int16_t accel_along_up = 0, accel_along_down = 0;
int16_t accel_across_up = 0, accel_across_down = 0;
int16_t accel_through_up = 0, accel_through_down = 0;
#endif
#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
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- if (ao_cmd_lex_i == 0) {
up = ao_config_accel_calibrate_auto("up");
#if HAS_GYRO
accel_along_up = accel_cal_along;
up = ao_config_accel_calibrate_auto("up");
#if HAS_GYRO
accel_along_up = accel_cal_along;
accel_through_down = accel_cal_through;
#endif
} else {
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;
if (ao_cmd_status != ao_cmd_success)
return;
}
if (up >= down) {
printf("Invalid accel: up (%d) down (%d)\n",
}
if (up >= down) {
printf("Invalid accel: up (%d) down (%d)\n",
ao_config.accel_plus_g = up;
ao_config.accel_minus_g = down;
#if HAS_GYRO
ao_config.accel_plus_g = up;
ao_config.accel_minus_g = down;
#if HAS_GYRO
- if (ao_cmd_lex_i == 0) {
ao_config.accel_zero_along = (accel_along_up + accel_along_down) / 2;
ao_config.accel_zero_across = (accel_across_up + accel_across_down) / 2;
ao_config.accel_zero_through = (accel_through_up + accel_through_down) / 2;
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;
void
ao_config_apogee_delay_set(void)
{
void
ao_config_apogee_delay_set(void)
{
+ uint32_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
_ao_config_edit_finish();
}
void
ao_config_apogee_lockout_set(void)
{
void
ao_config_apogee_lockout_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
_ao_config_edit_finish();
}
void
ao_config_radio_cal_set(void)
{
void
ao_config_radio_cal_set(void)
{
+ uint32_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
ao_config_set_radio();
_ao_config_edit_finish();
}
void
ao_config_radio_rate_set(void)
{
void
ao_config_radio_rate_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
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_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();
_ao_config_edit_finish();
#if HAS_TELEMETRY
ao_telemetry_reset_interval();
#else
uint16_t block = (uint16_t) (ao_storage_block >> 10);
uint16_t log_max = (uint16_t) (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);
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_log_present())
printf("Storage must be empty before changing log size\n");
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);
printf("Flight log size must be multiple of %d kB\n", block);
- else if (ao_cmd_lex_i > log_max)
printf("Flight log max %d kB\n", log_max);
else {
_ao_config_edit_start();
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
_ao_config_edit_finish();
}
#endif
void
ao_config_ignite_mode_set(void)
{
void
ao_config_ignite_mode_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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
_ao_config_edit_finish();
}
#endif
void
ao_config_pad_orientation_set(void)
{
void
ao_config_pad_orientation_set(void)
{
+ uint16_t r = ao_cmd_decimal() & 1;
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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;
}
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
_ao_config_edit_finish();
}
#endif
void
ao_config_radio_enable_set(void)
{
void
ao_config_radio_enable_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
_ao_config_edit_finish();
#if HAS_TELEMETRY && HAS_RADIO_RATE
ao_telemetry_reset_interval();
_ao_config_edit_start();
for (i = 0; i < AO_AES_LEN; i++) {
_ao_config_edit_start();
for (i = 0; i < AO_AES_LEN; i++) {
+ uint8_t b = ao_cmd_hexbyte();
if (ao_cmd_status != ao_cmd_success)
break;
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();
}
++ao_config_aes_seq;
_ao_config_edit_finish();
void
ao_config_aprs_set(void)
{
void
ao_config_aprs_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
_ao_config_edit_finish();
ao_telemetry_reset_interval();
}
void
ao_config_radio_amp_set(void)
{
void
ao_config_radio_amp_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
_ao_config_edit_finish();
}
void
ao_config_radio_power_set(void)
{
void
ao_config_radio_power_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
_ao_config_edit_finish();
}
void
ao_config_beep_set(void)
{
void
ao_config_beep_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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
_ao_config_edit_finish();
}
#endif
ao_config_tracker_set(void)
{
uint16_t m, i;
ao_config_tracker_set(void)
{
uint16_t m, i;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- m = ao_cmd_lex_i;
- ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
ao_config.tracker_motion = m;
ao_config.tracker_interval = i;
_ao_config_edit_start();
ao_config.tracker_motion = m;
ao_config.tracker_interval = i;
void
ao_config_pyro_time_set(void)
{
void
ao_config_pyro_time_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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
_ao_config_edit_finish();
}
#endif
void
ao_config_aprs_ssid_set(void)
{
void
ao_config_aprs_ssid_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- if (15 < ao_cmd_lex_i) {
ao_cmd_status = ao_cmd_lex_error;
return;
}
_ao_config_edit_start();
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_config_edit_finish();
}
void
ao_config_aprs_format_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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();
}
_ao_config_edit_finish();
}
void
ao_config_pad_box_set(void)
{
void
ao_config_pad_box_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
- ao_config.pad_box = ao_cmd_lex_i;
_ao_config_edit_finish();
}
_ao_config_edit_finish();
}
void
ao_config_pad_idle_set(void)
{
void
ao_config_pad_idle_set(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
_ao_config_edit_start();
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
_ao_config_edit_finish();
}
#endif
enum ao_flight_state my_state = ao_flight_invalid;
int i;
enum ao_flight_state my_state = ao_flight_invalid;
int i;
+ calib_size = ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success)
return;
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;
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));
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));
cmd_flight = -1;
ao_cmd_lex();
}
cmd_flight = -1;
ao_cmd_lex();
}
+ cmd_flight *= ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
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 */
slots = ao_log_slots();
/* Look for the flight log matching the requested flight */
void
ao_log_single_set(void)
{
void
ao_log_single_set(void)
{
printf("Logging currently %s\n", ao_log_running ? "on" : "off");
printf("Logging currently %s\n", ao_log_running ? "on" : "off");
if (ao_cmd_status == ao_cmd_success) {
if (ao_cmd_status == ao_cmd_success) {
printf("Logging from %ld to %ld\n", ao_log_current_pos, ao_log_end_pos);
ao_log_single_start();
} else {
printf("Logging from %ld to %ld\n", ao_log_current_pos, ao_log_end_pos);
ao_log_single_start();
} else {
ao_log_single_delete(void)
{
uint32_t pos;
ao_log_single_delete(void)
{
uint32_t pos;
+ uint16_t r = ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
- if (ao_cmd_lex_i != 1) {
ao_cmd_status = ao_cmd_syntax_error;
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();
return;
}
ao_log_single_stop();
}
ao_log_current_pos = ao_log_start_pos = 0;
if (pos == 0)
}
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");
}
else
printf ("Erased\n");
}
static void
set_monitor(void)
{
static void
set_monitor(void)
{
- ao_cmd_hex();
- ao_external_monitoring = ao_cmd_lex_i;
+ ao_external_monitoring = ao_cmd_hex();
ao_wakeup(&ao_external_monitoring);
ao_wakeup(&ao_monitor_head);
_ao_monitor_adjust();
ao_wakeup(&ao_external_monitoring);
ao_wakeup(&ao_monitor_head);
_ao_monitor_adjust();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
if (AO_PYRO_NUM <= p) {
printf ("invalid pyro channel %d\n", p);
return;
if (AO_PYRO_NUM <= p) {
printf ("invalid pyro channel %d\n", p);
return;
}
pyro_tmp.flags |= ao_pyro_values[v].flag;
if (ao_pyro_values[v].offset != NO_VALUE) {
}
pyro_tmp.flags |= ao_pyro_values[v].flag;
if (ao_pyro_values[v].offset != NO_VALUE) {
ao_cmd_white();
if (ao_cmd_lex_c == '-') {
ao_cmd_white();
if (ao_cmd_lex_c == '-') {
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_pyro_values[v].flag & AO_PYRO_8_BIT_VALUE) {
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_pyro_values[v].flag & AO_PYRO_8_BIT_VALUE) {
ao_cmd_status = ao_cmd_syntax_error;
return;
}
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;
- 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;
+ len = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
if (len > AO_CMAC_MAX_LEN) {
ao_cmd_status = ao_cmd_syntax_error;
return;
}
flush();
if (len > AO_CMAC_MAX_LEN) {
ao_cmd_status = ao_cmd_syntax_error;
return;
}
flush();
for (i = 0; i < len; i++) {
cmac_data[i] = getbyte();
if (ao_cmd_status != ao_cmd_success)
for (i = 0; i < len; i++) {
cmac_data[i] = getbyte();
if (ao_cmd_status != ao_cmd_success)
uint8_t len, i;
uint16_t timeout;
uint8_t len, i;
uint16_t timeout;
+ len = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
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;
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 ");
i = ao_radio_cmac_recv(cmac_data, len, timeout);
if (i == AO_RADIO_CMAC_OK) {
printf ("PACKET ");
- ao_cmd_hex();
- count = ao_cmd_lex_i;
if (ao_cmd_status != ao_cmd_success)
return;
if (count > AO_MAX_SEND - 2) {
if (ao_cmd_status != ao_cmd_success)
return;
if (count > AO_MAX_SEND - 2) {
static void
ao_storage_dump(void)
{
static void
ao_storage_dump(void)
{
if (ao_cmd_status != ao_cmd_success)
return;
for (i = 0; ; i += 8) {
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(' ');
ao_cmd_put16((uint16_t) i);
for (j = 0; j < 8; j++) {
putchar(' ');
uint16_t block;
uint8_t i;
uint16_t len;
uint16_t block;
uint8_t i;
uint16_t len;
- 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;
addr = ((uint32_t) block << 8) | i;
- ao_cmd_hex();
- len = ao_cmd_lex_i;
if (ao_cmd_status != ao_cmd_success)
return;
while (len--) {
if (ao_cmd_status != ao_cmd_success)
return;
while (len--) {
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
ao_storage_write(addr, &b, 1);
addr++;
}
ao_storage_write(addr, &b, 1);
addr++;
}
void
ao_storage_zap(void)
{
void
ao_storage_zap(void)
{
+ uint32_t v = ao_cmd_hex();
if (ao_cmd_status != ao_cmd_success)
return;
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);
static void
ao_tracker_set_telem(void)
{
static void
ao_tracker_set_telem(void)
{
+ uint16_t r = ao_cmd_hex();
if (ao_cmd_status == ao_cmd_success)
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);
ao_cmd_status = ao_cmd_success;
printf ("flight: %d\n", ao_flight_number);
printf ("force_telem: %d\n", ao_tracker_force_telem);
static void
ao_video_toggle(void)
{
static void
ao_video_toggle(void)
{
- ao_cmd_decimal();
- if (ao_cmd_lex_i)
+ uint16_t r = ao_cmd_decimal();
+ if (r)
- ao_vga_enable(ao_cmd_lex_i);
}
static void
ao_ball_toggle(void)
{
}
static void
ao_ball_toggle(void)
{
- ao_cmd_decimal();
- ball_enable = ao_cmd_lex_i;
+ ball_enable = ao_cmd_decimal();
ao_wakeup(&ball_enable);
}
ao_wakeup(&ball_enable);
}
{
int com, seg, val;
int n, bit;
{
int com, seg, val;
int n, bit;
- ao_cmd_decimal();
- com = ao_cmd_lex_i;
- ao_cmd_decimal();
- seg = ao_cmd_lex_u32;
- ao_cmd_decimal();
- val = ao_cmd_lex_i;
+ com = ao_cmd_decimal();
+ seg = ao_cmd_decimal();
+ val = ao_cmd_decimal();
printf ("com: %d seg: %d val: %d\n", com, seg, val);
ao_lcd_set(com, seg, val);
ao_lcd_flush();
printf ("com: %d seg: %d val: %d\n", com, seg, val);
ao_lcd_set(com, seg, val);
ao_lcd_flush();
uint8_t ch;
uint16_t val;
uint8_t ch;
uint16_t val;
- ao_cmd_decimal();
- ch = ao_cmd_lex_u32;
- ao_cmd_decimal();
- val = ao_cmd_lex_u32;
+ ch = ao_cmd_decimal();
+ val = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
if (ch < 0 || AO_NUM_ADC <= ch) {
ao_cmd_status = ao_cmd_syntax_error;
return;
if (ch < 0 || AO_NUM_ADC <= ch) {
ao_cmd_status = ao_cmd_syntax_error;
return;
static void
set_logging(void)
{
static void
set_logging(void)
{
- ao_cmd_hex();
- ao_log_running = ao_cmd_lex_i;
+ ao_log_running = ao_cmd_hex();
ao_wakeup(&ao_log_running);
}
ao_wakeup(&ao_log_running);
}
void
ao_lco_set_debug(void)
{
void
ao_lco_set_debug(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status == ao_cmd_success)
if (ao_cmd_status == ao_cmd_success)
- ao_lco_debug = ao_cmd_lex_i != 0;
}
const struct ao_cmds ao_lco_cmds[] = {
}
const struct ao_cmds ao_lco_cmds[] = {
+ output = ao_cmd_decimal();
if (ao_cmd_status != ao_cmd_success)
return;
if (ao_cmd_status != ao_cmd_success)
return;
if (output > 1)
printf ("Invalid relay position %u\n", output);
else
if (output > 1)
printf ("Invalid relay position %u\n", output);
else
static void
ao_set_vidtime(void)
{
static void
ao_set_vidtime(void)
{
+ uint16_t r = ao_cmd_decimal();
if (ao_cmd_status == ao_cmd_success) {
if (ao_cmd_status == ao_cmd_success) {
- vidtime_monitor = ao_cmd_lex_i != 0;
+ vidtime_monitor = r != 0;
ao_wakeup(&vidtime_monitor);
}
}
ao_wakeup(&vidtime_monitor);
}
}