#include <parse_num.h>
#include <uart.h>
#include <xbee.h>
+#include <callout.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 "../fpv-common/i2c_commands.h"
+#include "i2c_protocol.h"
#include "eeprom_config.h"
/* commands_gen.c */
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;
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;
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);
}
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;
}
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 */
},
};
-
-
-
/* ************* */
/* this structure is filled when cmd_read is parsed successfully */
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";
char cmd[3];
int len;
void *param;
+ 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, 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";
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";
/* ************* */
-/* 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;
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 =
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);
}
}
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);
printf_P(PSTR("not running\r\n"));
return;
}
+ callout_stop(&xbeeboard.intr_cm, &monitor_event);
monitor_running = 0;
- callout_stop(&cm, &monitor_event);
}
}
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;
}
/* 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";
{
(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;
},
};
-/* ************* */
-
-/* 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 */
/**********************************************************/
+/* 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_timers is parsed successfully */
+struct cmd_rc_proto_timers_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+ uint16_t servo_min;
+ uint16_t servo_max;
+ uint16_t power_probe;
+ uint16_t autobypass;
+};
+
+static void cmd_rc_proto_timers_parsed(void *parsed_result, void *data)
+{
+ struct cmd_rc_proto_timers_result *res = parsed_result;
+ (void)data;
+
+ if (!strcmp_P(res->arg1, PSTR("set"))) {
+ rc_proto_timers.send_servo_min_ms = res->servo_min;
+ rc_proto_timers.send_servo_max_ms = res->servo_max;
+ rc_proto_timers.send_power_probe_ms = res->power_probe;
+ rc_proto_timers.autobypass_ms = res->autobypass;
+ }
+
+ printf_P(PSTR("rc_proto_timers: min=%d, max=%d, "
+ "power_probe=%d autobypass=%d\n"),
+ rc_proto_timers.send_servo_min_ms,
+ rc_proto_timers.send_servo_max_ms,
+ rc_proto_timers.send_power_probe_ms,
+ rc_proto_timers.autobypass_ms);
+}
+
+const char PROGMEM str_rc_proto_timers_arg0[] = "rc_proto_timers";
+const parse_token_string_t PROGMEM cmd_rc_proto_timers_arg0 =
+ TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_timers_result, arg0,
+ str_rc_proto_timers_arg0);
+const char PROGMEM str_rc_proto_timers_arg1[] = "set";
+const parse_token_string_t PROGMEM cmd_rc_proto_timers_arg1 =
+ TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_timers_result, arg1,
+ str_rc_proto_timers_arg1);
+const parse_token_num_t PROGMEM cmd_rc_proto_timers_servo_min =
+ TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_timers_result, servo_min,
+ UINT16);
+const parse_token_num_t PROGMEM cmd_rc_proto_timers_servo_max =
+ TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_timers_result, servo_max,
+ UINT16);
+const parse_token_num_t PROGMEM cmd_rc_proto_timers_power_probe =
+ TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_timers_result, power_probe,
+ UINT16);
+const parse_token_num_t PROGMEM cmd_rc_proto_timers_autobypass =
+ TOKEN_NUM_INITIALIZER(struct cmd_rc_proto_timers_result, autobypass,
+ UINT16);
+
+const char PROGMEM help_rc_proto_timers[] = "set rc_proto_timers (servo_min, "
+ "servo_max, pow_probe, autobypass)";
+const parse_inst_t PROGMEM cmd_rc_proto_timers = {
+ .f = cmd_rc_proto_timers_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_rc_proto_timers,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_rc_proto_timers_arg0,
+ (PGM_P)&cmd_rc_proto_timers_arg1,
+ (PGM_P)&cmd_rc_proto_timers_servo_min,
+ (PGM_P)&cmd_rc_proto_timers_servo_max,
+ (PGM_P)&cmd_rc_proto_timers_power_probe,
+ (PGM_P)&cmd_rc_proto_timers_autobypass,
+ NULL,
+ },
+};
+
+const char PROGMEM str_rc_proto_timers_show_arg1[] = "show";
+const parse_token_string_t PROGMEM cmd_rc_proto_timers_show_arg1 =
+ TOKEN_STRING_INITIALIZER(struct cmd_rc_proto_timers_result, arg1,
+ str_rc_proto_timers_show_arg1);
+
+const char PROGMEM help_rc_proto_timers_show[] = "show rc_proto timers value";
+const parse_inst_t PROGMEM cmd_rc_proto_timers_show = {
+ .f = cmd_rc_proto_timers_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_rc_proto_timers_show,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_rc_proto_timers_arg0,
+ (PGM_P)&cmd_rc_proto_timers_show_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("compute_best_pow"))) {
+ if (on == 1)
+ flags |= RC_PROTO_FLAGS_COMPUTE_BEST_POW;
+ else
+ flags &= ~RC_PROTO_FLAGS_COMPUTE_BEST_POW;
+ }
+ 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");
+ printf_P(PSTR("rc_proto_mode compute_best_pow %s\n"),
+ (flags & RC_PROTO_FLAGS_COMPUTE_BEST_POW) ? "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#compute_best_pow";
+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;
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)
};
+/* ************* */
+
+struct cmd_dump_i2c_result {
+ fixed_string_t cmd;
+};
+
+static void cmd_dump_i2c_parsed(void *parsed_result, void *data)
+{
+ struct i2c_ans_imuboard_status imu;
+ uint8_t irq_flags;
+
+ (void)parsed_result;
+ (void)data;
+
+ while (!cmdline_keypressed()) {
+ IRQ_LOCK(irq_flags);
+ memcpy(&imu, &imuboard_status, sizeof(imu));
+ IRQ_UNLOCK(irq_flags);
+
+ if (imu.flags & IMUBOARD_STATUS_GPS_OK) {
+ printf_P(PSTR("GPS lat=%"PRIi32" long=%"PRIi32
+ " alt=%"PRIi32"\n"),
+ imu.latitude, imu.longitude, imu.altitude);
+ }
+ else
+ printf_P(PSTR("GPS unavailable\n"));
+ i2c_protocol_debug();
+ wait_ms(100);
+ }
+}
+
+const char PROGMEM str_dump_i2c[] = "dump_i2c";
+const parse_token_string_t PROGMEM cmd_dump_i2c_cmd =
+ TOKEN_STRING_INITIALIZER(struct cmd_dump_i2c_result, cmd,
+ str_dump_i2c);
+
+const char PROGMEM help_dump_i2c[] = "dump_i2c";
+const parse_inst_t PROGMEM cmd_dump_i2c = {
+ .f = cmd_dump_i2c_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_dump_i2c,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_dump_i2c_cmd,
+ NULL,
+ },
+};
+
+
/* ************* */
/* in progmem */
&cmd_log_show,
&cmd_log_type,
&cmd_stack_space,
- &cmd_scheduler,
+ &cmd_callout,
&cmd_help,
&cmd_neigh_del,
&cmd_neigh_add,
&cmd_write_u16,
&cmd_write_u32,
&cmd_sendmsg,
- &cmd_send_hello,
- &cmd_send_hello_name,
&cmd_sendmsg_name,
&cmd_range,
&cmd_range_period,
&cmd_monitor_del,
&cmd_ping,
&cmd_raw,
- &cmd_dump,
- &cmd_debug,
&cmd_baudrate,
&cmd_beep,
&cmd_servo_set,
&cmd_servo_show,
&cmd_test_spi,
&cmd_dump_xbee_stats,
+ &cmd_rc_proto_stats,
+ &cmd_rc_proto_timers,
+ &cmd_rc_proto_timers_show,
+ &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,
&cmd_eeprom_add2,
&cmd_eeprom_list,
+ &cmd_dump_i2c,
NULL,
};
git.droids-corp.org / protos / xbee-avr.git / blobdiff