X-Git-Url: http://git.droids-corp.org/?p=protos%2Fxbee-avr.git;a=blobdiff_plain;f=commands.c;h=ff8954ded9272c5cd00a552f933cbeb05446250e;hp=3448dedccb7c2b063fd01141c30c3c1a5ad6985a;hb=84aa7ae041e790da370b7bac9a3340b73d7dc4b3;hpb=852fd37145aaaee0ce2117f5c8173f5b86020fd0 diff --git a/commands.c b/commands.c index 3448ded..ff8954d 100644 --- a/commands.c +++ b/commands.c @@ -67,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; @@ -83,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); } @@ -91,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; @@ -111,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); - rangepkt.type = RC_PROTO_TYPE_RANGE; - rangepkt.power_level = range_power; + power_probe.type = RC_PROTO_POWER_PROBE; + power_probe.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 */ @@ -324,9 +378,6 @@ const parse_inst_t PROGMEM cmd_neigh_list = { }, }; - - - /* ************* */ /* this structure is filled when cmd_read is parsed successfully */ @@ -342,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"; @@ -394,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)); @@ -422,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"; @@ -534,6 +589,7 @@ 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; @@ -541,7 +597,8 @@ static void cmd_sendmsg_parsed(void *parsed_result, void *data) msg.iov[0].buf = res->data; msg.iov[0].len = strlen(res->data); - xbeeapp_send_msg(res->addr, &msg, 1); + xbeeapp_send_msg(res->addr, &msg, send_msg_cb, (void *)&done); + while (done == 0); } const char PROGMEM str_sendmsg[] = "sendmsg"; @@ -572,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; @@ -683,6 +641,7 @@ 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; @@ -690,7 +649,8 @@ static void cmd_sendmsg_name_parsed(void *parsed_result, void *data) msg.iov[0].buf = res->data; msg.iov[0].len = strlen(res->data); - xbeeapp_send_msg(res->neigh->addr, &msg, 1); + 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 = @@ -1225,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"; @@ -1610,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; @@ -1835,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, @@ -1856,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,