X-Git-Url: http://git.droids-corp.org/?p=protos%2Fxbee-avr.git;a=blobdiff_plain;f=commands.c;h=eff413db23e75f155eafadd024de5730259626c2;hp=dee0693e926c2200a71649ae23a0767c43a8c0a4;hb=21d10011bc4b009d7a09131b955953fa7aba3815;hpb=701d7cbf7d30c49e1d21943ce47d00bf250c70e7 diff --git a/commands.c b/commands.c index dee0693..eff413d 100644 --- a/commands.c +++ b/commands.c @@ -51,6 +51,8 @@ #include "rc_proto.h" #include "main.h" #include "cmdline.h" +#include "beep.h" +#include "eeprom_config.h" /* commands_gen.c */ extern const parse_inst_t PROGMEM cmd_reset; @@ -1299,6 +1301,150 @@ const parse_inst_t PROGMEM cmd_baudrate = { }, }; + +/**********************************************************/ + +/* this structure is filled when cmd_beep is parsed successfully */ +struct cmd_beep_result { + fixed_string_t beep; +}; + +/* function called when cmd_beep is parsed successfully */ +static void cmd_beep_parsed(void *parsed_result, void *data) +{ + (void)parsed_result; + (void)data; + + beep(0, 3, 3); + beep(1, 3, 3); + beep(2, 3, 3); + beep(0, 1, 1); + beep(1, 1, 1); + beep(2, 1, 1); +} + +const char PROGMEM str_beep[] = "beep"; +const parse_token_string_t PROGMEM cmd_beep_beep = + TOKEN_STRING_INITIALIZER(struct cmd_beep_result, beep, + str_beep); + +const char PROGMEM help_beep[] = "Send a beep"; + +const parse_inst_t PROGMEM cmd_beep = { + .f = cmd_beep_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_beep, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_beep_beep, + NULL, + }, +}; + +/**********************************************************/ + +/* this structure is filled when cmd_servo is parsed successfully */ +struct cmd_servo_result { + fixed_string_t arg0; + fixed_string_t arg1; + uint16_t num; + uint16_t val; +}; + +/* function called when cmd_servo is parsed successfully */ +static void cmd_servo_parsed(void * parsed_result, void *data) +{ + struct cmd_servo_result *res = parsed_result; + + (void)data; + + if (!strcmp_P(res->arg1, PSTR("set"))) { + if (res->num >= N_SERVO) { + printf_P(PSTR("bad servo num\n")); + return; + } + if (res->val >= 1024) { + printf_P(PSTR("bad servo val\n")); + return; + } + spi_servo_set(res->num, res->val); + } + else if (!strcmp_P(res->arg1, PSTR("bypass"))) { + spi_servo_set_bypass(!!res->val); + } + else if (!strcmp_P(res->arg1, PSTR("ppm"))) { + spi_servo_set_ppm(!!res->val); + } + else if (!strcmp_P(res->arg1, PSTR("show"))) { + spi_servo_dump(); + } +} + +const char PROGMEM str_servo_arg0[] = "servo"; +const parse_token_string_t PROGMEM cmd_servo_arg0 = + TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg0, + str_servo_arg0); +const char PROGMEM str_servo_arg1_set[] = "set"; +const parse_token_string_t PROGMEM cmd_servo_arg1_set = + TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1, + str_servo_arg1_set); +const parse_token_num_t PROGMEM cmd_servo_num = + TOKEN_NUM_INITIALIZER(struct cmd_servo_result, num, + UINT16); +const parse_token_num_t PROGMEM cmd_servo_val = + TOKEN_NUM_INITIALIZER(struct cmd_servo_result, val, + UINT16); + +const char PROGMEM help_servo_set[] = "set servo value"; +const parse_inst_t PROGMEM cmd_servo_set = { + .f = cmd_servo_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_servo_set, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_servo_arg0, + (PGM_P)&cmd_servo_arg1_set, + (PGM_P)&cmd_servo_num, + (PGM_P)&cmd_servo_val, + NULL, + }, +}; + +const char PROGMEM str_servo_arg1_show[] = "show"; +const parse_token_string_t PROGMEM cmd_servo_arg1_show = + TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1, + str_servo_arg1_show); + +const char PROGMEM help_servo_show[] = "read servo and config"; +const parse_inst_t PROGMEM cmd_servo_show = { + .f = cmd_servo_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_servo_show, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_servo_arg0, + (PGM_P)&cmd_servo_arg1_show, + NULL, + }, +}; + +const char PROGMEM str_servo_arg1_bypassppm[] = "bypass#ppm"; +const parse_token_string_t PROGMEM cmd_servo_arg1_bypassppm = + TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1, + str_servo_arg1_bypassppm); + +const char PROGMEM help_servo_bypassppm[] = "change bypass/ppm"; +const parse_inst_t PROGMEM cmd_servo_bypassppm = { + .f = cmd_servo_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_servo_bypassppm, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_servo_arg0, + (PGM_P)&cmd_servo_arg1_bypassppm, + (PGM_P)&cmd_servo_val, + NULL, + }, +}; + +/**********************************************************/ + /* this structure is filled when cmd_test_spi is parsed successfully */ struct cmd_test_spi_result { fixed_string_t arg0; @@ -1306,23 +1452,86 @@ struct cmd_test_spi_result { static void cmd_test_spi_parsed(void * parsed_result, void *data) { - int i; + uint8_t i, flags, wait_time = 0; + uint16_t val = 0; (void)parsed_result; (void)data; - while (1) { - for (i = 0; i < 50; i++) { - spi_servo_set(0, 0); - wait_ms(100); - spi_servo_set(0, 500); - wait_ms(100); + spi_servo_set_bypass(0); + spi_servo_set_ppm(0); + + /* stress test: send many commands, no wait between each servo + * of a series, and a variable delay between series */ + printf_P(PSTR("stress test\r\n")); + while (!cmdline_keypressed()) { + + wait_time++; + if (wait_time > 20) + wait_time = 0; + + IRQ_LOCK(flags); + val = global_ms; + IRQ_UNLOCK(flags); + val >>= 3; + val &= 1023; + + for (i = 0; i < 6; i++) + spi_servo_set(i, val); + + wait_ms(wait_time); + printf_P(PSTR("%4.4d %4.4d %4.4d %4.4d %4.4d %4.4d\r\n"), + spi_servo_get(0), spi_servo_get(1), spi_servo_get(2), + spi_servo_get(3), spi_servo_get(4), spi_servo_get(5)); + } + + printf_P(PSTR("bypass mode, with spi commands in background\r\n")); + spi_servo_set_bypass(1); + + /* test bypass mode */ + while (!cmdline_keypressed()) { + + wait_time++; + if (wait_time > 20) + wait_time = 0; + + IRQ_LOCK(flags); + val = global_ms; + IRQ_UNLOCK(flags); + val >>= 3; + val &= 1023; + + for (i = 0; i < 6; i++) + spi_servo_set(i, val); + + wait_ms(wait_time); + printf_P(PSTR("%4.4d %4.4d %4.4d %4.4d %4.4d %4.4d\r\n"), + spi_servo_get(0), spi_servo_get(1), spi_servo_get(2), + spi_servo_get(3), spi_servo_get(4), spi_servo_get(5)); + } + + printf_P(PSTR("PPM to servo\r\n")); + spi_servo_set_bypass(0); + spi_servo_set_ppm(0); + + /* test PPM to servo (bypass) mode */ + while (!cmdline_keypressed()) { + for (i = 0; i < 6; i++) { + val = spi_servo_get(i); + spi_servo_set(i, val); } + } + + printf_P(PSTR("PPM to (servo + PPM)\r\n")); + spi_servo_set_bypass(0); + spi_servo_set_ppm(1); - spi_servo_bypass(1); - wait_ms(10000); - spi_servo_bypass(0); - wait_ms(1); + /* test PPM to servo (bypass) mode */ + while (!cmdline_keypressed()) { + for (i = 0; i < 6; i++) { + val = spi_servo_get(i); + spi_servo_set(i, val); + } } } @@ -1342,6 +1551,212 @@ const parse_inst_t PROGMEM cmd_test_spi = { }, }; +/**********************************************************/ + +/* this structure is filled when cmd_test_eeprom_config is parsed successfully */ +struct cmd_test_eeprom_config_result { + fixed_string_t arg0; +}; + +static void cmd_test_eeprom_config_parsed(void *parsed_result, void *data) +{ + (void)parsed_result; + (void)data; + + eeprom_dump_cmds(); + eeprom_append_cmd("salut1\n"); + eeprom_dump_cmds(); + eeprom_append_cmd("salut2\n"); + eeprom_append_cmd("salut3\n"); + eeprom_append_cmd("salut4\n"); + eeprom_dump_cmds(); + eeprom_insert_cmd_before("coin\n", 0); + eeprom_insert_cmd_before("coin2\n", 2); + eeprom_dump_cmds(); + eeprom_delete_cmd(2); + eeprom_delete_cmd(0); + eeprom_dump_cmds(); +} + +const char PROGMEM str_test_eeprom_config_arg0[] = "test_eeprom_config"; +const parse_token_string_t PROGMEM cmd_test_eeprom_config_arg0 = + TOKEN_STRING_INITIALIZER(struct cmd_test_eeprom_config_result, arg0, + str_test_eeprom_config_arg0); + +const char PROGMEM help_test_eeprom_config[] = "Test the eeprom configuration"; +const parse_inst_t PROGMEM cmd_test_eeprom_config = { + .f = cmd_test_eeprom_config_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_test_eeprom_config, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_test_eeprom_config_arg0, + NULL, + }, +}; + +/* ************* */ + +struct cmd_eeprom_del_result { + fixed_string_t cmd; + fixed_string_t action; + uint8_t n; +}; + +static void cmd_eeprom_del_parsed(void *parsed_result, + void *data) +{ + struct cmd_eeprom_del_result *res = parsed_result; + + (void)data; + if (eeprom_delete_cmd(res->n) < 0) + printf_P(PSTR("cannot delete command\n")); + eeprom_dump_cmds(); +} + +const char PROGMEM str_eeprom_del_eeprom[] = "eeprom"; +const parse_token_string_t PROGMEM cmd_eeprom_del_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_eeprom_del_result, cmd, + str_eeprom_del_eeprom); +const char PROGMEM str_eeprom_del_del[] = "del"; +const parse_token_string_t PROGMEM cmd_eeprom_del_action = + TOKEN_STRING_INITIALIZER(struct cmd_eeprom_del_result, action, + str_eeprom_del_del); +const parse_token_num_t PROGMEM cmd_eeprom_del_num = + TOKEN_NUM_INITIALIZER(struct cmd_eeprom_del_result, n, + UINT8); + +const char PROGMEM help_eeprom_del[] = "delete an eeprom init command"; +const parse_inst_t PROGMEM cmd_eeprom_del = { + .f = cmd_eeprom_del_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_eeprom_del, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_eeprom_del_cmd, + (PGM_P)&cmd_eeprom_del_action, + (PGM_P)&cmd_eeprom_del_num, + NULL, + }, +}; + +/* ************* */ + +struct cmd_eeprom_add_result { + fixed_string_t cmd; + fixed_string_t action; + uint8_t n; +}; + +static void cmd_eeprom_add_parsed(void *parsed_result, + void *data) +{ + struct cmd_eeprom_add_result *res = parsed_result; + struct rdline rdl; + const char *buffer; + int8_t ret; + int16_t c; + + rdline_init(&rdl, cmdline_write_char, NULL, NULL); + rdline_newline(&rdl, "> "); + + /* XXX bad: we should not block as we do not serve callout */ + while (1) { + c = cmdline_dev_recv(NULL); + if (c < 0) + continue; + + ret = rdline_char_in(&rdl, c); + if (ret == -2) { + printf_P(PSTR("abort\n")); + return; + } + if (ret == 1) + break; + } + + buffer = rdline_get_buffer(&rdl); + if (data == NULL) + eeprom_insert_cmd_before(buffer, res->n); + else + eeprom_append_cmd(buffer); + eeprom_dump_cmds(); +} + +const char PROGMEM str_eeprom_add_eeprom[] = "eeprom"; +const parse_token_string_t PROGMEM cmd_eeprom_add_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_eeprom_add_result, cmd, + str_eeprom_add_eeprom); +const char PROGMEM str_eeprom_add_add[] = "add"; +const parse_token_string_t PROGMEM cmd_eeprom_add_action = + TOKEN_STRING_INITIALIZER(struct cmd_eeprom_add_result, action, + str_eeprom_add_add); +const parse_token_num_t PROGMEM cmd_eeprom_add_num = + TOKEN_NUM_INITIALIZER(struct cmd_eeprom_add_result, n, + UINT8); + +const char PROGMEM help_eeprom_add[] = "insert an eeprom init command"; +const parse_inst_t PROGMEM cmd_eeprom_add = { + .f = cmd_eeprom_add_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_eeprom_add, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_eeprom_add_cmd, + (PGM_P)&cmd_eeprom_add_action, + (PGM_P)&cmd_eeprom_add_num, + NULL, + }, +}; + +const char PROGMEM help_eeprom_add2[] = "append an eeprom init command"; +const parse_inst_t PROGMEM cmd_eeprom_add2 = { + .f = cmd_eeprom_add_parsed, /* function to call */ + .data = (void *)1, /* 2nd arg of func */ + .help_str = help_eeprom_add2, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_eeprom_add_cmd, + (PGM_P)&cmd_eeprom_add_action, + NULL, + }, +}; + +/* ************* */ + +struct cmd_eeprom_list_result { + fixed_string_t cmd; + fixed_string_t action; +}; + +static void cmd_eeprom_list_parsed(void *parsed_result, + void *data) +{ + (void)parsed_result; + (void)data; + eeprom_dump_cmds(); +} + +const char PROGMEM str_eeprom_list_eeprom[] = "eeprom"; +const parse_token_string_t PROGMEM cmd_eeprom_list_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_eeprom_list_result, cmd, + str_eeprom_list_eeprom); +const char PROGMEM str_eeprom_list_list[] = "list"; +const parse_token_string_t PROGMEM cmd_eeprom_list_action = + TOKEN_STRING_INITIALIZER(struct cmd_eeprom_list_result, action, + str_eeprom_list_list); + +const char PROGMEM help_eeprom_list[] = "list all eeprom init commands"; +const parse_inst_t PROGMEM cmd_eeprom_list = { + .f = cmd_eeprom_list_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_eeprom_list, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_eeprom_list_cmd, + (PGM_P)&cmd_eeprom_list_action, + NULL, + }, +}; + + +/* ************* */ + /* in progmem */ const parse_ctx_t PROGMEM main_ctx[] = { @@ -1378,6 +1793,15 @@ const parse_ctx_t PROGMEM main_ctx[] = { &cmd_dump, &cmd_debug, &cmd_baudrate, + &cmd_beep, + &cmd_servo_set, + &cmd_servo_bypassppm, + &cmd_servo_show, &cmd_test_spi, + &cmd_test_eeprom_config, + &cmd_eeprom_del, + &cmd_eeprom_add, + &cmd_eeprom_add2, + &cmd_eeprom_list, NULL, };