X-Git-Url: http://git.droids-corp.org/?p=protos%2Fxbee-avr.git;a=blobdiff_plain;f=commands.c;h=ffcd918e1024a74750816eef4c02ea6b7fad0d50;hp=b58594ad58aae930a449ba07768159207f4afaeb;hb=a992a62a843658a6f6a38158c3e13ce3dae45568;hpb=9a43add2f0ed382ce1f180bba65fdc077d03b6fb diff --git a/commands.c b/commands.c index b58594a..ffcd918 100644 --- a/commands.c +++ b/commands.c @@ -35,23 +35,20 @@ #include #include #include +#include +#include -#include "xbee_atcmd.h" -#include "xbee_neighbor.h" -#include "xbee_stats.h" -#include "xbee_proto.h" -#include "xbee.h" - -#include "callout.h" #include "parse_atcmd.h" #include "parse_neighbor.h" #include "parse_monitor.h" #include "spi_servo.h" #include "rc_proto.h" +#include "xbee_user.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; @@ -60,7 +57,7 @@ extern const parse_inst_t PROGMEM cmd_log; extern const parse_inst_t PROGMEM cmd_log_show; extern const parse_inst_t PROGMEM cmd_log_type; extern const parse_inst_t PROGMEM cmd_stack_space; -extern const parse_inst_t PROGMEM cmd_scheduler; +extern const parse_inst_t PROGMEM cmd_callout; static int monitor_period_ms = 1000; static int monitor_running = 0; @@ -70,14 +67,14 @@ struct monitor_reg *monitor_current; static int range_period_ms = 1000; static int range_powermask = 0x1F; -static uint8_t range_power = 0; +//static uint8_t range_power = 0; static int range_running = 0; static uint64_t range_dstaddr = 0xFFFF; /* broadcast by default */ static struct callout range_event; static int range_count = 100; static int range_cur_count = 0; -static void monitor_cb(struct callout_manager *cm, +static void monitor_cb(struct callout_mgr *cm, struct callout *clt, void *dummy) { (void)clt; @@ -88,14 +85,16 @@ static void monitor_cb(struct callout_manager *cm, xbeeapp_send_atcmd(monitor_current->atcmd, NULL, 0, 0, NULL, NULL); monitor_current = LIST_NEXT(monitor_current, next); - callout_reset(cm, &monitor_event, - monitor_period_ms / monitor_count, - SINGLE, monitor_cb, NULL); + callout_reschedule(cm, clt, monitor_period_ms / monitor_count); } -static void range_cb(struct callout_manager *cm, +static void range_cb(struct callout_mgr *cm, struct callout *clt, void *dummy) { + (void)cm; + (void)clt; + (void)dummy; +#if 0 uint8_t i, mask; struct rc_proto_range rangepkt; @@ -121,12 +120,11 @@ static void range_cb(struct callout_manager *cm, if (range_cur_count == 0) { range_running = 0; - return; + callout_stop(cm, clt); } - callout_reset(cm, &range_event, - range_period_ms, - SINGLE, range_cb, NULL); + callout_reschedule(cm, clt, range_period_ms); +#endif } /* this structure is filled when cmd_help is parsed successfully */ @@ -535,9 +533,15 @@ struct cmd_sendmsg_result { static void cmd_sendmsg_parsed(void *parsed_result, void *data) { struct cmd_sendmsg_result *res = parsed_result; + struct xbee_msg msg; (void)data; - xbeeapp_send_msg(res->addr, res->data, strlen(res->data), 1); + + msg.iovlen = 1; + msg.iov[0].buf = res->data; + msg.iov[0].len = strlen(res->data); + + xbeeapp_send_msg(res->addr, &msg, 1); } const char PROGMEM str_sendmsg[] = "sendmsg"; @@ -568,6 +572,105 @@ const parse_inst_t PROGMEM cmd_sendmsg = { /* ************* */ +/* this structure is filled when cmd_send_hello is parsed successfully */ +struct cmd_send_hello_result { + fixed_string_t send_hello; + uint64_t addr; + struct xbee_neigh *neigh; + uint16_t period; + uint16_t count; + fixed_string_t data; +}; + +/* function called when cmd_send_hello is parsed successfully */ +static void cmd_send_hello_parsed(void *parsed_result, void *use_neigh) +{ + struct cmd_send_hello_result *res = parsed_result; + uint16_t now, next, diff; + uint8_t flags; + uint64_t addr; + + if (use_neigh) + addr = res->neigh->addr; + else + addr = res->addr; + + IRQ_LOCK(flags); + now = global_ms; + IRQ_UNLOCK(flags); + + next = now; + + while (!cmdline_keypressed() && res->count != 0) { + IRQ_LOCK(flags); + now = global_ms; + IRQ_UNLOCK(flags); + + diff = now - next; + if (diff < res->period) + continue; + + rc_proto_send_hello(addr, res->data, strlen(res->data)); + next += res->period; + res->count--; + } +} + +const char PROGMEM str_send_hello[] = "send_hello"; + +const parse_token_string_t PROGMEM cmd_send_hello_send_hello = + TOKEN_STRING_INITIALIZER(struct cmd_send_hello_result, send_hello, + str_send_hello); + +const parse_token_num_t PROGMEM cmd_send_hello_addr = + TOKEN_NUM_INITIALIZER(struct cmd_send_hello_result, addr, UINT64); + +const parse_token_num_t PROGMEM cmd_send_hello_period = + TOKEN_NUM_INITIALIZER(struct cmd_send_hello_result, period, UINT16); + +const parse_token_num_t PROGMEM cmd_send_hello_count = + TOKEN_NUM_INITIALIZER(struct cmd_send_hello_result, count, UINT16); + +const parse_token_string_t PROGMEM cmd_send_hello_data = + TOKEN_STRING_INITIALIZER(struct cmd_send_hello_result, data, NULL); + +const char PROGMEM help_send_hello[] = + "Send hello msg to a node: addr, period_ms, count, str"; + +const parse_inst_t PROGMEM cmd_send_hello = { + .f = cmd_send_hello_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_send_hello, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_send_hello_send_hello, + (PGM_P)&cmd_send_hello_addr, + (PGM_P)&cmd_send_hello_period, + (PGM_P)&cmd_send_hello_count, + (PGM_P)&cmd_send_hello_data, + NULL, + }, +}; + +const parse_token_neighbor_t PROGMEM cmd_send_hello_neigh = + TOKEN_NEIGHBOR_INITIALIZER(struct cmd_send_hello_result, neigh, + &xbee_dev); + +const parse_inst_t PROGMEM cmd_send_hello_name = { + .f = cmd_send_hello_parsed, /* function to call */ + .data = (void *)1, /* 2nd arg of func */ + .help_str = help_send_hello, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_send_hello_send_hello, + (PGM_P)&cmd_send_hello_neigh, + (PGM_P)&cmd_send_hello_period, + (PGM_P)&cmd_send_hello_count, + (PGM_P)&cmd_send_hello_data, + NULL, + }, +}; + +/* ************* */ + /* this structure is filled when cmd_sendmsg_name is parsed successfully */ struct cmd_sendmsg_name_result { fixed_string_t sendmsg_name; @@ -579,9 +682,15 @@ struct cmd_sendmsg_name_result { static void cmd_sendmsg_name_parsed(void *parsed_result, void *data) { struct cmd_sendmsg_name_result *res = parsed_result; + struct xbee_msg msg; (void)data; - xbeeapp_send_msg(res->neigh->addr, res->data, strlen(res->data), 1); + + msg.iovlen = 1; + msg.iov[0].buf = res->data; + msg.iov[0].len = strlen(res->data); + + xbeeapp_send_msg(res->neigh->addr, &msg, 1); } const parse_token_string_t PROGMEM cmd_sendmsg_name_sendmsg_name = @@ -644,9 +753,9 @@ static void cmd_range_parsed(void *parsed_result, void *data) return; } range_cur_count = range_count; - callout_init(&range_event); - callout_reset(&cm, &range_event, 0, - SINGLE, range_cb, NULL); + callout_init(&range_event, range_cb, NULL, 0); + callout_schedule(&xbeeboard.mainloop_cm, + &range_event, 0); /* immediate */ range_running = 1; } else if (!strcmp(res->action, "end")) { @@ -655,7 +764,7 @@ static void cmd_range_parsed(void *parsed_result, void *data) return; } range_running = 0; - callout_stop(&cm, &range_event); + callout_stop(&xbeeboard.mainloop_cm, &range_event); } } @@ -894,8 +1003,9 @@ static void cmd_monitor_parsed(void *parsed_result, void *data) printf_P(PSTR("no regs to be monitored\r\n")); return; } - callout_init(&monitor_event); - callout_reset(&cm, &monitor_event, 0, SINGLE, monitor_cb, NULL); + callout_init(&monitor_event, monitor_cb, NULL, 0); + callout_schedule(&xbeeboard.mainloop_cm, + &monitor_event, 0); /* immediate */ monitor_running = 1; monitor_current = LIST_FIRST(&xbee_monitor_list); printf_P(PSTR("monitor cb: %S %s\r\n"), @@ -909,7 +1019,7 @@ static void cmd_monitor_parsed(void *parsed_result, void *data) return; } monitor_running = 0; - callout_stop(&cm, &monitor_event); + callout_stop(&xbeeboard.mainloop_cm, &monitor_event); } } @@ -1072,7 +1182,7 @@ static void cmd_monitor_del_parsed(void *parsed_result, void *data) monitor_count --; if (monitor_count == 0) { printf_P(PSTR("Disable monitoring, no more event\r\n")); - callout_stop(&cm, &monitor_event); + callout_stop(&xbeeboard.mainloop_cm, &monitor_event); monitor_running = 0; return; } @@ -1150,6 +1260,11 @@ static void cmd_raw_parsed(void *parsed_result, void *data) { (void)parsed_result; (void)data; + + if (range_running || monitor_running) { + printf_P(PSTR("stop running range or monitor first\r\n")); + return; + } printf_P(PSTR("switched to raw mode, CTRL-D to exit\r\n")); rdline_stop(&xbeeboard.rdl); /* don't display prompt when return */ xbee_raw = 1; @@ -1463,7 +1578,7 @@ static void cmd_test_spi_parsed(void * parsed_result, void *data) /* 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()) { + while (!cmdline_keypressed()) { wait_time++; if (wait_time > 20) @@ -1550,6 +1665,243 @@ const parse_inst_t PROGMEM cmd_test_spi = { }, }; +/**********************************************************/ + +/* this structure is filled when cmd_dump_xbee_stats is parsed successfully */ +struct cmd_dump_xbee_stats_result { + fixed_string_t arg0; +}; + +static void cmd_dump_xbee_stats_parsed(void *parsed_result, void *data) +{ + (void)parsed_result; + (void)data; + + xbee_dump_stats(xbee_dev); +} + +const char PROGMEM str_dump_xbee_stats_arg0[] = "dump_xbee_stats"; +const parse_token_string_t PROGMEM cmd_dump_xbee_stats_arg0 = + TOKEN_STRING_INITIALIZER(struct cmd_dump_xbee_stats_result, arg0, + str_dump_xbee_stats_arg0); + +const char PROGMEM help_dump_xbee_stats[] = "Test the spi"; +const parse_inst_t PROGMEM cmd_dump_xbee_stats = { + .f = cmd_dump_xbee_stats_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_dump_xbee_stats, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_dump_xbee_stats_arg0, + NULL, + }, +}; + +/**********************************************************/ + +/* 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[] = { @@ -1560,7 +1912,7 @@ const parse_ctx_t PROGMEM main_ctx[] = { &cmd_log_show, &cmd_log_type, &cmd_stack_space, - &cmd_scheduler, + &cmd_callout, &cmd_help, &cmd_neigh_del, &cmd_neigh_add, @@ -1571,6 +1923,8 @@ const parse_ctx_t PROGMEM main_ctx[] = { &cmd_write_u16, &cmd_write_u32, &cmd_sendmsg, + &cmd_send_hello, + &cmd_send_hello_name, &cmd_sendmsg_name, &cmd_range, &cmd_range_period, @@ -1591,5 +1945,11 @@ const parse_ctx_t PROGMEM main_ctx[] = { &cmd_servo_bypassppm, &cmd_servo_show, &cmd_test_spi, + &cmd_dump_xbee_stats, + &cmd_test_eeprom_config, + &cmd_eeprom_del, + &cmd_eeprom_add, + &cmd_eeprom_add2, + &cmd_eeprom_list, NULL, };