X-Git-Url: http://git.droids-corp.org/?p=protos%2Fxbee-avr.git;a=blobdiff_plain;f=commands.c;h=ff8954ded9272c5cd00a552f933cbeb05446250e;hp=df76f478b3807ff4dc8c55c87616cc54175c76e9;hb=84aa7ae041e790da370b7bac9a3340b73d7dc4b3;hpb=8a9ba904e4215b92930a6d71c06c97514bcc6688 diff --git a/commands.c b/commands.c index df76f47..ff8954d 100644 --- a/commands.c +++ b/commands.c @@ -36,14 +36,15 @@ #include #include #include +#include -#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" @@ -56,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; @@ -66,7 +67,7 @@ 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; @@ -82,7 +83,8 @@ static void monitor_cb(struct callout_mgr *cm, if (monitor_current == NULL) monitor_current = LIST_FIRST(&xbee_monitor_list); - xbeeapp_send_atcmd(monitor_current->atcmd, NULL, 0, 0, NULL, NULL); + /* no rx_cb given: the user must check the monitored values in logs */ + xbeeapp_send_atcmd(monitor_current->atcmd, NULL, 0, NULL, NULL); monitor_current = LIST_NEXT(monitor_current, next); callout_reschedule(cm, clt, monitor_period_ms / monitor_count); } @@ -90,12 +92,9 @@ static void monitor_cb(struct callout_mgr *cm, static void range_cb(struct callout_mgr *cm, struct callout *clt, void *dummy) { - (void)cm; - (void)clt; - (void)dummy; -#if 0 + struct rc_proto_power_probe power_probe; + struct xbee_msg msg; uint8_t i, mask; - struct rc_proto_range rangepkt; (void)clt; (void)dummy; @@ -110,20 +109,76 @@ static void range_cb(struct callout_mgr *cm, } range_power = ((range_power + i) & 0x7); - xbeeapp_send_atcmd("PL", &range_power, sizeof(range_power), 0, NULL, NULL); + xbeeapp_send_atcmd("PL", &range_power, sizeof(range_power), NULL, NULL); + + power_probe.type = RC_PROTO_POWER_PROBE; + power_probe.power_level = range_power; - rangepkt.type = RC_PROTO_TYPE_RANGE; - rangepkt.power_level = range_power; + msg.iovlen = 1; + msg.iov[0].buf = &power_probe; + msg.iov[0].len = sizeof(power_probe); - xbeeapp_send_msg(range_dstaddr, &rangepkt, sizeof(rangepkt), 0); + xbeeapp_send_msg(range_dstaddr, &msg, NULL, NULL); if (range_cur_count == 0) { range_running = 0; + callout_stop(cm, clt); return; } callout_reschedule(cm, clt, range_period_ms); -#endif +} + +/* callback invoked when a xbee_send is done */ +static int8_t send_msg_cb(int8_t retcode, void *frame, unsigned len, + void *arg) +{ + struct xbee_xmit_status_hdr *recvframe = frame; + uint8_t *done = arg; + + *done = 1; + if (retcode == XBEE_USER_RETCODE_TIMEOUT) { + printf_P(PSTR("timeout\r\n")); + return retcode; + } + if (retcode == XBEE_USER_RETCODE_BAD_FRAME || + len != sizeof(*recvframe)) { + printf_P(PSTR("invalid frame\r\n")); + return XBEE_USER_RETCODE_BAD_FRAME; + } + + printf_P(PSTR("ok\r\n")); + return XBEE_USER_RETCODE_OK; +} + +/* callback invoked to dump the response to AT command */ +static int8_t dump_xbee_atresp_cb(int8_t retcode, void *frame, unsigned len, + void *arg) +{ + struct xbee_atresp_hdr *recvframe = frame; + char atcmd_str[3]; + char buf[32]; + uint8_t *done = arg; + + *done = 1; + if (retcode == XBEE_USER_RETCODE_TIMEOUT) { + printf_P(PSTR("timeout\r\n")); + return retcode; + } + if (retcode == XBEE_USER_RETCODE_BAD_FRAME || + len < sizeof(*recvframe)) { + printf_P(PSTR("invalid frame\r\n")); + return XBEE_USER_RETCODE_BAD_FRAME; + } + + /* get AT command from frame */ + memcpy(atcmd_str, &recvframe->cmd, 2); + atcmd_str[2] = '\0'; + + atresp_to_str(buf, sizeof(buf), frame, len); + len -= sizeof(*recvframe); + printf_P(PSTR("status ok, len=%d, %s\n"), len, buf); + return XBEE_USER_RETCODE_OK; } /* this structure is filled when cmd_help is parsed successfully */ @@ -323,9 +378,6 @@ const parse_inst_t PROGMEM cmd_neigh_list = { }, }; - - - /* ************* */ /* this structure is filled when cmd_read is parsed successfully */ @@ -341,12 +393,14 @@ static void cmd_read_parsed(void *parsed_result, struct cmd_read_result *res = parsed_result; struct xbee_atcmd copy; char cmd[3]; + volatile uint8_t done = 0; (void)data; memcpy_P(©, res->cmd, sizeof(copy)); memcpy_P(&cmd, copy.name, 2); cmd[2] = '\0'; - xbeeapp_send_atcmd(cmd, NULL, 0, 1, NULL, NULL); + xbeeapp_send_atcmd(cmd, NULL, 0, dump_xbee_atresp_cb, (void *)&done); + while (done == 0); } const char PROGMEM str_read_read[] = "read"; @@ -393,6 +447,7 @@ static void cmd_write_parsed(void *parsed_result, void *data) char cmd[3]; int len; void *param; + volatile uint8_t done = 0; (void)data; memcpy_P(©, res->cmd, sizeof(copy)); @@ -421,7 +476,8 @@ static void cmd_write_parsed(void *parsed_result, void *data) } memcpy_P(&cmd, copy.name, 2); cmd[2] = '\0'; - xbeeapp_send_atcmd(cmd, param, len, 1, NULL, NULL); + xbeeapp_send_atcmd(cmd, param, len, dump_xbee_atresp_cb, (void *)&done); + while (done == 0); } const char PROGMEM str_write_none[] = "write"; @@ -532,9 +588,17 @@ 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; + volatile uint8_t done = 0; (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, send_msg_cb, (void *)&done); + while (done == 0); } const char PROGMEM str_sendmsg[] = "sendmsg"; @@ -565,105 +629,6 @@ 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; @@ -675,9 +640,17 @@ 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; + volatile uint8_t done = 0; (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, send_msg_cb, (void *)&done); + while (done == 0); } const parse_token_string_t PROGMEM cmd_sendmsg_name_sendmsg_name = @@ -740,17 +713,18 @@ static void cmd_range_parsed(void *parsed_result, void *data) return; } range_cur_count = range_count; - callout_init(&range_event, range_cb, NULL, 0); - callout_schedule(&cm, &range_event, 0); /* immediate */ + callout_init(&range_event, range_cb, NULL, LOW_PRIO); range_running = 1; + callout_schedule(&xbeeboard.intr_cm, + &range_event, 0); /* immediate */ } else if (!strcmp(res->action, "end")) { if (range_running == 0) { printf_P(PSTR("not running\r\n")); return; } + callout_stop(&xbeeboard.intr_cm, &range_event); range_running = 0; - callout_stop(&cm, &range_event); } } @@ -989,10 +963,11 @@ 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, monitor_cb, NULL, 0); - callout_schedule(&cm, &monitor_event, 0); /* immediate */ + callout_init(&monitor_event, monitor_cb, NULL, 1); monitor_running = 1; monitor_current = LIST_FIRST(&xbee_monitor_list); + callout_schedule(&xbeeboard.intr_cm, + &monitor_event, 0); /* immediate */ printf_P(PSTR("monitor cb: %S %s\r\n"), monitor_current->desc, monitor_current->atcmd); @@ -1003,8 +978,8 @@ static void cmd_monitor_parsed(void *parsed_result, void *data) printf_P(PSTR("not running\r\n")); return; } + callout_stop(&xbeeboard.intr_cm, &monitor_event); monitor_running = 0; - callout_stop(&cm, &monitor_event); } } @@ -1167,7 +1142,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.intr_cm, &monitor_event); monitor_running = 0; return; } @@ -1210,9 +1185,12 @@ struct cmd_ping_result { /* function called when cmd_ping is parsed successfully */ static void cmd_ping_parsed(void *parsed_result, void *data) { + volatile uint8_t done = 0; + (void)parsed_result; (void)data; - xbeeapp_send_atcmd("VL", NULL, 0, 1, NULL, NULL); + xbeeapp_send_atcmd("VL", NULL, 0, dump_xbee_atresp_cb, (void *)&done); + while (done == 0); } const char PROGMEM str_ping[] = "ping"; @@ -1245,6 +1223,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; @@ -1268,94 +1251,6 @@ const parse_inst_t PROGMEM cmd_raw = { }, }; -/* ************* */ - -/* this structure is filled when cmd_dump is parsed successfully */ -struct cmd_dump_result { - fixed_string_t dump; - fixed_string_t onoff; -}; - -/* function called when cmd_dump is parsed successfully */ -static void cmd_dump_parsed(void *parsed_result, void *data) -{ - struct cmd_dump_result *res = parsed_result; - - (void)data; - if (!strcmp(res->onoff, "on")) - xbee_hexdump = 1; - else - xbee_hexdump = 0; -} - -const char PROGMEM str_dump[] = "dump"; -const char PROGMEM str_dump_onoff[] = "on#off"; - -const parse_token_string_t PROGMEM cmd_dump_dump = - TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump, - str_dump); - -const parse_token_string_t PROGMEM cmd_dump_onoff = - TOKEN_STRING_INITIALIZER(struct cmd_dump_result, onoff, - str_dump_onoff); - -const char PROGMEM help_dump[] = "enable/disable hexdump of received packets"; - -const parse_inst_t PROGMEM cmd_dump = { - .f = cmd_dump_parsed, /* function to call */ - .data = NULL, /* 2nd arg of func */ - .help_str = help_dump, - .tokens = { /* token list, NULL terminated */ - (PGM_P)&cmd_dump_dump, - (PGM_P)&cmd_dump_onoff, - NULL, - }, -}; - -/* ************* */ - -/* this structure is filled when cmd_debug is parsed successfully */ -struct cmd_debug_result { - fixed_string_t debug; - fixed_string_t onoff; -}; - -/* function called when cmd_debug is parsed successfully */ -static void cmd_debug_parsed(void *parsed_result, void *data) -{ - struct cmd_debug_result *res = parsed_result; - - (void)data; - if (!strcmp(res->onoff, "on")) - xbee_debug = 1; - else - xbee_debug = 0; -} - -const char PROGMEM str_debug[] = "debug"; -const char PROGMEM str_debug_onoff[] = "on#off"; - -const parse_token_string_t PROGMEM cmd_debug_debug = - TOKEN_STRING_INITIALIZER(struct cmd_debug_result, debug, - str_debug); - -const parse_token_string_t PROGMEM cmd_debug_onoff = - TOKEN_STRING_INITIALIZER(struct cmd_debug_result, onoff, - str_debug_onoff); - -const char PROGMEM help_debug[] = "enable/disable additionnal debug"; - -const parse_inst_t PROGMEM cmd_debug = { - .f = cmd_debug_parsed, /* function to call */ - .data = NULL, /* 2nd arg of func */ - .help_str = help_debug, - .tokens = { /* token list, NULL terminated */ - (PGM_P)&cmd_debug_debug, - (PGM_P)&cmd_debug_onoff, - NULL, - }, -}; - /**********************************************************/ /* this structure is filled when cmd_baudrate is parsed successfully */ @@ -1678,6 +1573,381 @@ const parse_inst_t PROGMEM cmd_dump_xbee_stats = { /**********************************************************/ +/* this structure is filled when cmd_rc_proto_stats is parsed successfully */ +struct cmd_rc_proto_stats_result { + fixed_string_t arg0; + fixed_string_t arg1; +}; + +static void cmd_rc_proto_stats_parsed(void *parsed_result, void *data) +{ + struct cmd_rc_proto_stats_result *res = parsed_result; + (void)data; + + if (!strcmp(res->arg1, "show")) + rc_proto_dump_stats(); + else /* reset */ + rc_proto_reset_stats(); +} + +const char PROGMEM str_rc_proto_stats_arg0[] = "rc_proto_stats"; +const parse_token_string_t PROGMEM cmd_rc_proto_stats_arg0 = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_stats_result, arg0, + str_rc_proto_stats_arg0); +const char PROGMEM str_rc_proto_stats_arg1[] = "show#reset"; +const parse_token_string_t PROGMEM cmd_rc_proto_stats_arg1 = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_stats_result, arg1, + str_rc_proto_stats_arg1); + +const char PROGMEM help_rc_proto_stats[] = "dump rc_proto stats"; +const parse_inst_t PROGMEM cmd_rc_proto_stats = { + .f = cmd_rc_proto_stats_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_rc_proto_stats, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_stats_arg0, + (PGM_P)&cmd_rc_proto_stats_arg1, + NULL, + }, +}; + +/**********************************************************/ + +/* this structure is filled when cmd_rc_proto_mode is parsed successfully */ +struct cmd_rc_proto_mode_result { + fixed_string_t arg0; + fixed_string_t cmd; + fixed_string_t val; +}; + +static void cmd_rc_proto_mode_parsed(void *parsed_result, void *data) +{ + struct cmd_rc_proto_mode_result *res = parsed_result; + (void)data; + uint8_t flags; + uint8_t on = 0; + + flags = rc_proto_get_mode(); + if (!strcmp_P(res->val, PSTR("on"))) + on = 1; + + if (!strcmp_P(res->cmd, PSTR("rx_copy_spi"))) { + if (on == 1) + flags |= RC_PROTO_FLAGS_RX_COPY_SPI; + else + flags &= ~RC_PROTO_FLAGS_RX_COPY_SPI; + } + else if (!strcmp_P(res->cmd, PSTR("rx_autobypass"))) { + if (on == 1) + flags |= RC_PROTO_FLAGS_RX_AUTOBYPASS; + else + flags &= ~RC_PROTO_FLAGS_RX_AUTOBYPASS; + } + else if (!strcmp_P(res->cmd, PSTR("tx_stats"))) { + if (on == 1) + flags |= RC_PROTO_FLAGS_TX_STATS; + else + flags &= ~RC_PROTO_FLAGS_TX_STATS; + } + else if (!strcmp_P(res->cmd, PSTR("tx_power_probe"))) { + if (on == 1) + flags |= RC_PROTO_FLAGS_TX_POW_PROBE; + else + flags &= ~RC_PROTO_FLAGS_TX_POW_PROBE; + } + else if (!strcmp_P(res->cmd, PSTR("tx"))) { + flags &= ~RC_PROTO_FLAGS_TX_MASK; + if (!strcmp_P(res->val, PSTR("bypass"))) + flags |= RC_PROTO_FLAGS_TX_BYPASS; + else if (!strcmp_P(res->val, PSTR("copy_spi"))) + flags |= RC_PROTO_FLAGS_TX_COPY_SPI; + } + rc_proto_set_mode(flags); + + /* dump state */ + if ((flags & RC_PROTO_FLAGS_TX_MASK) == RC_PROTO_FLAGS_TX_OFF) + printf_P(PSTR("rc_proto_mode tx off\n")); + else if ((flags & RC_PROTO_FLAGS_TX_MASK) == RC_PROTO_FLAGS_TX_BYPASS) + printf_P(PSTR("rc_proto_mode tx bypass\n")); + else if ((flags & RC_PROTO_FLAGS_TX_MASK) == RC_PROTO_FLAGS_TX_COPY_SPI) + printf_P(PSTR("rc_proto_mode tx copy_spi\n")); + printf_P(PSTR("rc_proto_mode rx_copy_spi %s\n"), + (flags & RC_PROTO_FLAGS_RX_COPY_SPI) ? "on" : "off"); + printf_P(PSTR("rc_proto_mode rx_autobypass %s\n"), + (flags & RC_PROTO_FLAGS_RX_AUTOBYPASS) ? "on" : "off"); + printf_P(PSTR("rc_proto_mode tx_stats %s\n"), + (flags & RC_PROTO_FLAGS_TX_STATS) ? "on" : "off"); + printf_P(PSTR("rc_proto_mode tx_power_probe %s\n"), + (flags & RC_PROTO_FLAGS_TX_POW_PROBE) ? "on" : "off"); +} + +const char PROGMEM str_rc_proto_mode_arg0[] = "rc_proto_mode"; +const parse_token_string_t PROGMEM cmd_rc_proto_mode_arg0 = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_mode_result, arg0, + str_rc_proto_mode_arg0); + +const char PROGMEM str_rc_proto_mode_cmd[] = + "rx_copy_spi#rx_autobypass#tx_stats#tx_power_probe"; +const parse_token_string_t PROGMEM cmd_rc_proto_mode_cmd = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_mode_result, cmd, + str_rc_proto_mode_cmd); + +const char PROGMEM str_rc_proto_mode_onoff[] = "on#off"; +const parse_token_string_t PROGMEM cmd_rc_proto_mode_onoff = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_mode_result, val, + str_rc_proto_mode_onoff); + +const char PROGMEM help_rc_proto_mode[] = "Set rc proto behavior"; +const parse_inst_t PROGMEM cmd_rc_proto_mode = { + .f = cmd_rc_proto_mode_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_rc_proto_mode, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_mode_arg0, + (PGM_P)&cmd_rc_proto_mode_cmd, + (PGM_P)&cmd_rc_proto_mode_onoff, + NULL, + }, +}; + +const char PROGMEM str_rc_proto_mode_cmd2[] = "tx"; +const parse_token_string_t PROGMEM cmd_rc_proto_mode_cmd2 = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_mode_result, cmd, + str_rc_proto_mode_cmd2); + +const char PROGMEM str_rc_proto_mode_val[] = "off#bypass#copy_spi"; +const parse_token_string_t PROGMEM cmd_rc_proto_mode_val = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_mode_result, val, + str_rc_proto_mode_val); + +const parse_inst_t PROGMEM cmd_rc_proto_mode2 = { + .f = cmd_rc_proto_mode_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_rc_proto_mode, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_mode_arg0, + (PGM_P)&cmd_rc_proto_mode_cmd2, + (PGM_P)&cmd_rc_proto_mode_val, + NULL, + }, +}; + +const char PROGMEM str_rc_proto_mode_cmd3[] = "show"; +const parse_token_string_t PROGMEM cmd_rc_proto_mode_cmd3 = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_mode_result, cmd, + str_rc_proto_mode_cmd3); + +const parse_inst_t PROGMEM cmd_rc_proto_mode3 = { + .f = cmd_rc_proto_mode_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_rc_proto_mode, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_mode_arg0, + (PGM_P)&cmd_rc_proto_mode_cmd3, + NULL, + }, +}; + +/**********************************************************/ + +/* this structure is filled when cmd_rc_proto_hello is parsed successfully */ +struct cmd_rc_proto_hello_result { + fixed_string_t rc_proto_hello; + uint64_t addr; + struct xbee_neigh *neigh; + uint16_t period; + uint16_t count; + fixed_string_t data; +}; + +/* function called when cmd_rc_proto_hello is parsed successfully */ +static void cmd_rc_proto_hello_parsed(void *parsed_result, void *use_neigh) +{ + struct cmd_rc_proto_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), -1); + next += res->period; + res->count--; + } +} + +const char PROGMEM str_rc_proto_hello[] = "rc_proto_hello"; + +const parse_token_string_t PROGMEM cmd_rc_proto_hello_rc_proto_hello = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_hello_result, rc_proto_hello, + str_rc_proto_hello); + +const parse_token_num_t PROGMEM cmd_rc_proto_hello_addr = + TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_hello_result, addr, UINT64); + +const parse_token_num_t PROGMEM cmd_rc_proto_hello_period = + TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_hello_result, period, UINT16); + +const parse_token_num_t PROGMEM cmd_rc_proto_hello_count = + TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_hello_result, count, UINT16); + +const parse_token_string_t PROGMEM cmd_rc_proto_hello_data = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_hello_result, data, NULL); + +const char PROGMEM help_rc_proto_hello[] = + "Send hello msg to a node: addr, period_ms, count, str"; + +const parse_inst_t PROGMEM cmd_rc_proto_hello = { + .f = cmd_rc_proto_hello_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_rc_proto_hello, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_hello_rc_proto_hello, + (PGM_P)&cmd_rc_proto_hello_addr, + (PGM_P)&cmd_rc_proto_hello_period, + (PGM_P)&cmd_rc_proto_hello_count, + (PGM_P)&cmd_rc_proto_hello_data, + NULL, + }, +}; + +const parse_token_neighbor_t PROGMEM cmd_rc_proto_hello_neigh = + TOKEN_NEIGHBOR_INITIALIZER(struct cmd_rc_proto_hello_result, neigh, + &xbee_dev); + +const parse_inst_t PROGMEM cmd_rc_proto_hello_name = { + .f = cmd_rc_proto_hello_parsed, /* function to call */ + .data = (void *)1, /* 2nd arg of func */ + .help_str = help_rc_proto_hello, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_hello_rc_proto_hello, + (PGM_P)&cmd_rc_proto_hello_neigh, + (PGM_P)&cmd_rc_proto_hello_period, + (PGM_P)&cmd_rc_proto_hello_count, + (PGM_P)&cmd_rc_proto_hello_data, + NULL, + }, +}; + +/**********************************************************/ + +/* this structure is filled when cmd_rc_proto_echo is parsed successfully */ +struct cmd_rc_proto_echo_result { + fixed_string_t rc_proto_echo; + uint64_t addr; + struct xbee_neigh *neigh; + uint16_t period; + uint16_t count; + fixed_string_t data; +}; + +/* function called when cmd_rc_proto_echo is parsed successfully */ +static void cmd_rc_proto_echo_parsed(void *parsed_result, void *use_neigh) +{ + struct cmd_rc_proto_echo_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_echo_req(addr, res->data, strlen(res->data), -1); + next += res->period; + res->count--; + } +} + +const char PROGMEM str_rc_proto_echo[] = "rc_proto_echo"; + +const parse_token_string_t PROGMEM cmd_rc_proto_echo_rc_proto_echo = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_echo_result, rc_proto_echo, + str_rc_proto_echo); + +const parse_token_num_t PROGMEM cmd_rc_proto_echo_addr = + TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_echo_result, addr, UINT64); + +const parse_token_num_t PROGMEM cmd_rc_proto_echo_period = + TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_echo_result, period, UINT16); + +const parse_token_num_t PROGMEM cmd_rc_proto_echo_count = + TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_echo_result, count, UINT16); + +const parse_token_string_t PROGMEM cmd_rc_proto_echo_data = + TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_echo_result, data, NULL); + +const char PROGMEM help_rc_proto_echo[] = + "Send echo msg to a node: addr, period_ms, count, str"; + +const parse_inst_t PROGMEM cmd_rc_proto_echo = { + .f = cmd_rc_proto_echo_parsed, /* function to call */ + .data = NULL, /* 2nd arg of func */ + .help_str = help_rc_proto_echo, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_echo_rc_proto_echo, + (PGM_P)&cmd_rc_proto_echo_addr, + (PGM_P)&cmd_rc_proto_echo_period, + (PGM_P)&cmd_rc_proto_echo_count, + (PGM_P)&cmd_rc_proto_echo_data, + NULL, + }, +}; + +const parse_token_neighbor_t PROGMEM cmd_rc_proto_echo_neigh = + TOKEN_NEIGHBOR_INITIALIZER(struct cmd_rc_proto_echo_result, neigh, + &xbee_dev); + +const parse_inst_t PROGMEM cmd_rc_proto_echo_name = { + .f = cmd_rc_proto_echo_parsed, /* function to call */ + .data = (void *)1, /* 2nd arg of func */ + .help_str = help_rc_proto_echo, + .tokens = { /* token list, NULL terminated */ + (PGM_P)&cmd_rc_proto_echo_rc_proto_echo, + (PGM_P)&cmd_rc_proto_echo_neigh, + (PGM_P)&cmd_rc_proto_echo_period, + (PGM_P)&cmd_rc_proto_echo_count, + (PGM_P)&cmd_rc_proto_echo_data, + NULL, + }, +}; + +/**********************************************************/ + /* this structure is filled when cmd_test_eeprom_config is parsed successfully */ struct cmd_test_eeprom_config_result { fixed_string_t arg0; @@ -1892,7 +2162,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, @@ -1903,8 +2173,6 @@ 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, @@ -1917,8 +2185,6 @@ const parse_ctx_t PROGMEM main_ctx[] = { &cmd_monitor_del, &cmd_ping, &cmd_raw, - &cmd_dump, - &cmd_debug, &cmd_baudrate, &cmd_beep, &cmd_servo_set, @@ -1926,6 +2192,14 @@ const parse_ctx_t PROGMEM main_ctx[] = { &cmd_servo_show, &cmd_test_spi, &cmd_dump_xbee_stats, + &cmd_rc_proto_stats, + &cmd_rc_proto_mode, + &cmd_rc_proto_mode2, + &cmd_rc_proto_mode3, + &cmd_rc_proto_hello, + &cmd_rc_proto_hello_name, + &cmd_rc_proto_echo, + &cmd_rc_proto_echo_name, &cmd_test_eeprom_config, &cmd_eeprom_del, &cmd_eeprom_add,