#include <aversive/queue.h>
#include <aversive/endian.h>
#include <aversive/error.h>
+#include <aversive/wait.h>
#include <parse.h>
#include <rdline.h>
#include <parse_string.h>
#include <parse_num.h>
#include <uart.h>
-
-#include "xbee_atcmd.h"
-#include "xbee_neighbor.h"
-#include "xbee_stats.h"
-#include "xbee_proto.h"
-#include "xbee.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 "main.h"
#include "cmdline.h"
+#include "beep.h"
+#include "eeprom_config.h"
/* commands_gen.c */
-extern parse_pgm_inst_t cmd_reset;
-extern parse_pgm_inst_t cmd_bootloader;
-extern parse_pgm_inst_t cmd_log;
-extern parse_pgm_inst_t cmd_log_show;
-extern parse_pgm_inst_t cmd_log_type;
-extern parse_pgm_inst_t cmd_stack_space;
-extern parse_pgm_inst_t cmd_scheduler;
+extern const parse_inst_t PROGMEM cmd_reset;
+extern const parse_inst_t PROGMEM cmd_bootloader;
+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;
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;
static void monitor_cb(struct callout_manager *cm,
struct callout *clt, void *dummy)
{
+ (void)clt;
+ (void)dummy;
+
if (monitor_current == NULL)
monitor_current = LIST_FIRST(&xbee_monitor_list);
static void range_cb(struct callout_manager *cm,
struct callout *clt, void *dummy)
{
+ (void)cm;
+ (void)clt;
+ (void)dummy;
+#if 0
uint8_t i, mask;
struct rc_proto_range rangepkt;
+ (void)clt;
+ (void)dummy;
+
range_cur_count--;
/* get new xmit power */
callout_reset(cm, &range_event,
range_period_ms,
SINGLE, range_cb, NULL);
+#endif
}
/* this structure is filled when cmd_help is parsed successfully */
struct cmd_help_result {
fixed_string_t help;
- struct xbee_atcmd_pgm *cmd;
+ struct xbee_atcmd *cmd;
};
/* function called when cmd_help is parsed successfully */
struct cmd_help_result *res = parsed_result;
struct xbee_atcmd cmdcopy;
int type;
+
+ (void)data;
+
memcpy_P(&cmdcopy, res->cmd, sizeof(cmdcopy));
type = (cmdcopy.flags & (XBEE_ATCMD_F_READ | XBEE_ATCMD_F_WRITE));
switch (type) {
printf_P(PSTR("%S\r\n"), cmdcopy.help);
}
-prog_char str_help_help[] = "help";
+const char PROGMEM str_help_help[] = "help";
-parse_pgm_token_string_t cmd_help_help =
+const parse_token_string_t PROGMEM cmd_help_help =
TOKEN_STRING_INITIALIZER(struct cmd_help_result, help, str_help_help);
-parse_pgm_token_atcmd_t cmd_help_atcmd =
+const parse_token_atcmd_t PROGMEM cmd_help_atcmd =
TOKEN_ATCMD_INITIALIZER(struct cmd_help_result, cmd, &xbee_dev,
0, 0);
-prog_char help_help[] = "Help a register using an AT command";
-parse_pgm_inst_t cmd_help = {
+const char PROGMEM help_help[] = "Help a register using an AT command";
+const parse_inst_t PROGMEM cmd_help = {
.f = cmd_help_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_help,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_help_help,
- (prog_void *)&cmd_help_atcmd,
+ (PGM_P)&cmd_help_help,
+ (PGM_P)&cmd_help_atcmd,
NULL,
},
};
void *data)
{
struct cmd_neigh_del_result *res = parsed_result;
+
+ (void)data;
xbee_neigh_del(xbee_dev, res->neigh);
}
-prog_char str_neigh_del_neigh[] = "neigh";
-parse_pgm_token_string_t cmd_neigh_del_cmd =
+const char PROGMEM str_neigh_del_neigh[] = "neigh";
+const parse_token_string_t PROGMEM cmd_neigh_del_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_neigh_del_result, cmd,
str_neigh_del_neigh);
-prog_char str_neigh_del_del[] = "del";
-parse_pgm_token_string_t cmd_neigh_del_action =
+const char PROGMEM str_neigh_del_del[] = "del";
+const parse_token_string_t PROGMEM cmd_neigh_del_action =
TOKEN_STRING_INITIALIZER(struct cmd_neigh_del_result, action,
str_neigh_del_del);
-parse_pgm_token_neighbor_t cmd_neigh_del_neigh =
+const parse_token_neighbor_t PROGMEM cmd_neigh_del_neigh =
TOKEN_NEIGHBOR_INITIALIZER(struct cmd_neigh_del_result, neigh,
&xbee_dev);
-prog_char help_neigh_del[] = "delete a neighbor";
-parse_pgm_inst_t cmd_neigh_del = {
+const char PROGMEM help_neigh_del[] = "delete a neighbor";
+const parse_inst_t PROGMEM cmd_neigh_del = {
.f = cmd_neigh_del_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_neigh_del,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_neigh_del_cmd,
- (prog_void *)&cmd_neigh_del_action,
- (prog_void *)&cmd_neigh_del_neigh,
+ (PGM_P)&cmd_neigh_del_cmd,
+ (PGM_P)&cmd_neigh_del_action,
+ (PGM_P)&cmd_neigh_del_neigh,
NULL,
},
};
void *data)
{
struct cmd_neigh_add_result *res = parsed_result;
+
+ (void)data;
if (xbee_neigh_add(xbee_dev, res->name, res->addr) == NULL)
printf_P(PSTR("name or addr already exist\r\n"));
}
-prog_char str_neigh_add_neigh[] = "neigh";
-parse_pgm_token_string_t cmd_neigh_add_cmd =
+const char PROGMEM str_neigh_add_neigh[] = "neigh";
+const parse_token_string_t PROGMEM cmd_neigh_add_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_neigh_add_result, cmd,
str_neigh_add_neigh);
-prog_char str_neigh_add_add[] = "add";
-parse_pgm_token_string_t cmd_neigh_add_action =
+const char PROGMEM str_neigh_add_add[] = "add";
+const parse_token_string_t PROGMEM cmd_neigh_add_action =
TOKEN_STRING_INITIALIZER(struct cmd_neigh_add_result, action,
str_neigh_add_add);
-parse_pgm_token_string_t cmd_neigh_add_name =
+const parse_token_string_t PROGMEM cmd_neigh_add_name =
TOKEN_STRING_INITIALIZER(struct cmd_neigh_add_result, name, NULL);
-parse_pgm_token_num_t cmd_neigh_add_addr =
+const parse_token_num_t PROGMEM cmd_neigh_add_addr =
TOKEN_NUM_INITIALIZER(struct cmd_neigh_add_result, addr, UINT64);
-prog_char help_neigh_add[] = "add a neighbor";
-parse_pgm_inst_t cmd_neigh_add = {
+const char PROGMEM help_neigh_add[] = "add a neighbor";
+const parse_inst_t PROGMEM cmd_neigh_add = {
.f = cmd_neigh_add_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_neigh_add,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_neigh_add_cmd,
- (prog_void *)&cmd_neigh_add_action,
- (prog_void *)&cmd_neigh_add_name,
- (prog_void *)&cmd_neigh_add_addr,
+ (PGM_P)&cmd_neigh_add_cmd,
+ (PGM_P)&cmd_neigh_add_action,
+ (PGM_P)&cmd_neigh_add_name,
+ (PGM_P)&cmd_neigh_add_addr,
NULL,
},
};
{
struct xbee_neigh *neigh;
+ (void)parsed_result;
+ (void)data;
LIST_FOREACH(neigh, &xbee_dev->neigh_list, next) {
printf_P(PSTR(" %s: 0x%.8"PRIx32"%.8"PRIx32"\r\n"),
neigh->name,
}
}
-prog_char str_neigh_list_neigh[] = "neigh";
-parse_pgm_token_string_t cmd_neigh_list_cmd =
+const char PROGMEM str_neigh_list_neigh[] = "neigh";
+const parse_token_string_t PROGMEM cmd_neigh_list_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_neigh_list_result, cmd,
str_neigh_list_neigh);
-prog_char str_neigh_list_list[] = "list";
-parse_pgm_token_string_t cmd_neigh_list_action =
+const char PROGMEM str_neigh_list_list[] = "list";
+const parse_token_string_t PROGMEM cmd_neigh_list_action =
TOKEN_STRING_INITIALIZER(struct cmd_neigh_list_result, action,
str_neigh_list_list);
-prog_char help_neigh_list[] = "list all knwon neighbors";
-parse_pgm_inst_t cmd_neigh_list = {
+const char PROGMEM help_neigh_list[] = "list all knwon neighbors";
+const parse_inst_t PROGMEM cmd_neigh_list = {
.f = cmd_neigh_list_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_neigh_list,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_neigh_list_cmd,
- (prog_void *)&cmd_neigh_list_action,
+ (PGM_P)&cmd_neigh_list_cmd,
+ (PGM_P)&cmd_neigh_list_action,
NULL,
},
};
/* this structure is filled when cmd_read is parsed successfully */
struct cmd_read_result {
fixed_string_t read;
- struct xbee_atcmd_pgm *cmd;
+ struct xbee_atcmd *cmd;
};
/* function called when cmd_read is parsed successfully */
struct xbee_atcmd copy;
char cmd[3];
+ (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);
}
-prog_char str_read_read[] = "read";
+const char PROGMEM str_read_read[] = "read";
-parse_pgm_token_string_t cmd_read_read =
+const parse_token_string_t PROGMEM cmd_read_read =
TOKEN_STRING_INITIALIZER(struct cmd_read_result, read,
str_read_read);
-parse_pgm_token_atcmd_t cmd_read_atcmd =
+const parse_token_atcmd_t PROGMEM cmd_read_atcmd =
TOKEN_ATCMD_INITIALIZER(struct cmd_read_result, cmd, &xbee_dev,
XBEE_ATCMD_F_READ, XBEE_ATCMD_F_READ);
-prog_char help_read[] = "Read a register using an AT command";
-parse_pgm_inst_t cmd_read = {
+const char PROGMEM help_read[] = "Read a register using an AT command";
+const parse_inst_t PROGMEM cmd_read = {
.f = cmd_read_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_read,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_read_read,
- (prog_void *)&cmd_read_atcmd,
+ (PGM_P)&cmd_read_read,
+ (PGM_P)&cmd_read_atcmd,
NULL,
},
};
/* this structure is filled when cmd_write is parsed successfully */
struct cmd_write_result {
fixed_string_t write;
- struct xbee_atcmd_pgm *cmd;
+ struct xbee_atcmd *cmd;
union {
uint8_t u8;
uint16_t u16;
int len;
void *param;
+ (void)data;
memcpy_P(©, res->cmd, sizeof(copy));
if (copy.flags & XBEE_ATCMD_F_PARAM_NONE) {
xbeeapp_send_atcmd(cmd, param, len, 1, NULL, NULL);
}
-prog_char str_write_none[] = "write";
+const char PROGMEM str_write_none[] = "write";
-parse_pgm_token_string_t cmd_write_write =
+const parse_token_string_t PROGMEM cmd_write_write =
TOKEN_STRING_INITIALIZER(struct cmd_write_result, write,
str_write_none);
-parse_pgm_token_atcmd_t cmd_write_none_atcmd =
+const parse_token_atcmd_t PROGMEM cmd_write_none_atcmd =
TOKEN_ATCMD_INITIALIZER(struct cmd_write_result, cmd,
&xbee_dev,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_NONE,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_NONE);
-prog_char help_write_none[] = "Send an AT command (no argument)";
+const char PROGMEM help_write_none[] = "Send an AT command (no argument)";
-parse_pgm_inst_t cmd_write_none = {
+const parse_inst_t PROGMEM cmd_write_none = {
.f = cmd_write_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_write_none,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_write_write,
- (prog_void *)&cmd_write_none_atcmd,
+ (PGM_P)&cmd_write_write,
+ (PGM_P)&cmd_write_none_atcmd,
NULL,
},
};
-parse_pgm_token_atcmd_t cmd_write_u8_atcmd =
+const parse_token_atcmd_t PROGMEM cmd_write_u8_atcmd =
TOKEN_ATCMD_INITIALIZER(struct cmd_write_result, cmd,
&xbee_dev,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_U8,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_U8);
-parse_pgm_token_num_t cmd_write_u8_u8 =
+const parse_token_num_t PROGMEM cmd_write_u8_u8 =
TOKEN_NUM_INITIALIZER(struct cmd_write_result, u8, UINT8);
-prog_char help_write_u8[] = "Write a 8 bits register using an AT command";
+const char PROGMEM help_write_u8[] = "Write a 8 bits register using an AT command";
-parse_pgm_inst_t cmd_write_u8 = {
+const parse_inst_t PROGMEM cmd_write_u8 = {
.f = cmd_write_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_write_u8,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_write_write,
- (prog_void *)&cmd_write_u8_atcmd,
- (prog_void *)&cmd_write_u8_u8,
+ (PGM_P)&cmd_write_write,
+ (PGM_P)&cmd_write_u8_atcmd,
+ (PGM_P)&cmd_write_u8_u8,
NULL,
},
};
-parse_pgm_token_atcmd_t cmd_write_u16_atcmd =
+const parse_token_atcmd_t PROGMEM cmd_write_u16_atcmd =
TOKEN_ATCMD_INITIALIZER(struct cmd_write_result, cmd,
&xbee_dev,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_U16,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_U16);
-parse_pgm_token_num_t cmd_write_u16_u16 =
+const parse_token_num_t PROGMEM cmd_write_u16_u16 =
TOKEN_NUM_INITIALIZER(struct cmd_write_result, u16, UINT16);
-prog_char help_write_u16[] = "Write a 16 bits register using an AT command";
+const char PROGMEM help_write_u16[] = "Write a 16 bits register using an AT command";
-parse_pgm_inst_t cmd_write_u16 = {
+const parse_inst_t PROGMEM cmd_write_u16 = {
.f = cmd_write_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_write_u16,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_write_write,
- (prog_void *)&cmd_write_u16_atcmd,
- (prog_void *)&cmd_write_u16_u16,
+ (PGM_P)&cmd_write_write,
+ (PGM_P)&cmd_write_u16_atcmd,
+ (PGM_P)&cmd_write_u16_u16,
NULL,
},
};
-parse_pgm_token_atcmd_t cmd_write_u32_atcmd =
+const parse_token_atcmd_t PROGMEM cmd_write_u32_atcmd =
TOKEN_ATCMD_INITIALIZER(struct cmd_write_result, cmd,
&xbee_dev,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_U32,
XBEE_ATCMD_F_WRITE | XBEE_ATCMD_F_PARAM_U32);
-parse_pgm_token_num_t cmd_write_u32_u32 =
+const parse_token_num_t PROGMEM cmd_write_u32_u32 =
TOKEN_NUM_INITIALIZER(struct cmd_write_result, u32, UINT32);
-prog_char help_write_u32[] = "Write a 32 bits register using an AT command";
+const char PROGMEM help_write_u32[] = "Write a 32 bits register using an AT command";
-parse_pgm_inst_t cmd_write_u32 = {
+const parse_inst_t PROGMEM cmd_write_u32 = {
.f = cmd_write_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_write_u32,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_write_write,
- (prog_void *)&cmd_write_u32_atcmd,
- (prog_void *)&cmd_write_u32_u32,
+ (PGM_P)&cmd_write_write,
+ (PGM_P)&cmd_write_u32_atcmd,
+ (PGM_P)&cmd_write_u32_u32,
NULL,
},
};
static void cmd_sendmsg_parsed(void *parsed_result, void *data)
{
struct cmd_sendmsg_result *res = parsed_result;
+
+ (void)data;
xbeeapp_send_msg(res->addr, res->data, strlen(res->data), 1);
}
-prog_char str_sendmsg[] = "sendmsg";
+const char PROGMEM str_sendmsg[] = "sendmsg";
-parse_pgm_token_string_t cmd_sendmsg_sendmsg =
+const parse_token_string_t PROGMEM cmd_sendmsg_sendmsg =
TOKEN_STRING_INITIALIZER(struct cmd_sendmsg_result, sendmsg,
str_sendmsg);
-parse_pgm_token_num_t cmd_sendmsg_addr =
+const parse_token_num_t PROGMEM cmd_sendmsg_addr =
TOKEN_NUM_INITIALIZER(struct cmd_sendmsg_result, addr, UINT64);
-parse_pgm_token_string_t cmd_sendmsg_data =
+const parse_token_string_t PROGMEM cmd_sendmsg_data =
TOKEN_STRING_INITIALIZER(struct cmd_sendmsg_result, data, NULL);
-prog_char help_sendmsg[] = "Send data to a node using its address";
+const char PROGMEM help_sendmsg[] = "Send data to a node using its address";
-parse_pgm_inst_t cmd_sendmsg = {
+const parse_inst_t PROGMEM cmd_sendmsg = {
.f = cmd_sendmsg_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_sendmsg,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_sendmsg_sendmsg,
- (prog_void *)&cmd_sendmsg_addr,
- (prog_void *)&cmd_sendmsg_data,
+ (PGM_P)&cmd_sendmsg_sendmsg,
+ (PGM_P)&cmd_sendmsg_addr,
+ (PGM_P)&cmd_sendmsg_data,
+ NULL,
+ },
+};
+
+/* ************* */
+
+/* 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,
},
};
static void cmd_sendmsg_name_parsed(void *parsed_result, void *data)
{
struct cmd_sendmsg_name_result *res = parsed_result;
+
+ (void)data;
xbeeapp_send_msg(res->neigh->addr, res->data, strlen(res->data), 1);
}
-parse_pgm_token_string_t cmd_sendmsg_name_sendmsg_name =
+const parse_token_string_t PROGMEM cmd_sendmsg_name_sendmsg_name =
TOKEN_STRING_INITIALIZER(struct cmd_sendmsg_name_result, sendmsg_name,
str_sendmsg);
-parse_pgm_token_neighbor_t cmd_sendmsg_name_neigh =
+const parse_token_neighbor_t PROGMEM cmd_sendmsg_name_neigh =
TOKEN_NEIGHBOR_INITIALIZER(struct cmd_sendmsg_name_result, neigh,
&xbee_dev);
-parse_pgm_token_string_t cmd_sendmsg_name_data =
+const parse_token_string_t PROGMEM cmd_sendmsg_name_data =
TOKEN_STRING_INITIALIZER(struct cmd_sendmsg_name_result, data, NULL);
-prog_char help_sendmsg_name[] = "Send data to a node using its name";
+const char PROGMEM help_sendmsg_name[] = "Send data to a node using its name";
-parse_pgm_inst_t cmd_sendmsg_name = {
+const parse_inst_t PROGMEM cmd_sendmsg_name = {
.f = cmd_sendmsg_name_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_sendmsg_name,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_sendmsg_name_sendmsg_name,
- (prog_void *)&cmd_sendmsg_name_neigh,
- (prog_void *)&cmd_sendmsg_name_data,
+ (PGM_P)&cmd_sendmsg_name_sendmsg_name,
+ (PGM_P)&cmd_sendmsg_name_neigh,
+ (PGM_P)&cmd_sendmsg_name_data,
NULL,
},
};
{
struct cmd_range_result *res = parsed_result;
+ (void)data;
if (!strcmp_P(res->action, PSTR("show"))) {
printf_P(PSTR("range infos:\r\n"));
printf_P(PSTR(" range period %d\r\n"), range_period_ms);
}
}
-prog_char str_range[] = "range";
-prog_char str_range_tokens[] = "show#start#end";
+const char PROGMEM str_range[] = "range";
+const char PROGMEM str_range_tokens[] = "show#start#end";
-parse_pgm_token_string_t cmd_range_range =
+const parse_token_string_t PROGMEM cmd_range_range =
TOKEN_STRING_INITIALIZER(struct cmd_range_result, range,
str_range);
-parse_pgm_token_string_t cmd_range_action =
+const parse_token_string_t PROGMEM cmd_range_action =
TOKEN_STRING_INITIALIZER(struct cmd_range_result, action,
str_range_tokens);
-prog_char help_range[] = "start/stop/show current rangeing";
+const char PROGMEM help_range[] = "start/stop/show current rangeing";
-parse_pgm_inst_t cmd_range = {
+const parse_inst_t PROGMEM cmd_range = {
.f = cmd_range_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_range,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_range_range,
- (prog_void *)&cmd_range_action,
+ (PGM_P)&cmd_range_range,
+ (PGM_P)&cmd_range_action,
NULL,
},
};
{
struct cmd_range_period_result *res = parsed_result;
+ (void)data;
if (res->period < 10) {
printf_P(PSTR("error, minimum period is 10 ms\r\n"));
return;
range_period_ms = res->period;
}
-prog_char str_period[] = "period";
+const char PROGMEM str_period[] = "period";
-parse_pgm_token_string_t cmd_range_period_range_period =
+const parse_token_string_t PROGMEM cmd_range_period_range_period =
TOKEN_STRING_INITIALIZER(struct cmd_range_period_result, range,
str_range);
-parse_pgm_token_string_t cmd_range_period_action =
+const parse_token_string_t PROGMEM cmd_range_period_action =
TOKEN_STRING_INITIALIZER(struct cmd_range_period_result, action,
str_period);
-parse_pgm_token_num_t cmd_range_period_period =
+const parse_token_num_t PROGMEM cmd_range_period_period =
TOKEN_NUM_INITIALIZER(struct cmd_range_period_result, period, UINT32);
-prog_char help_range_period[] = "set range test period";
+const char PROGMEM help_range_period[] = "set range test period";
-parse_pgm_inst_t cmd_range_period = {
+const parse_inst_t PROGMEM cmd_range_period = {
.f = cmd_range_period_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_range_period,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_range_period_range_period,
- (prog_void *)&cmd_range_period_action,
- (prog_void *)&cmd_range_period_period,
+ (PGM_P)&cmd_range_period_range_period,
+ (PGM_P)&cmd_range_period_action,
+ (PGM_P)&cmd_range_period_period,
NULL,
},
};
static void cmd_range_count_parsed(void *parsed_result, void *data)
{
struct cmd_range_count_result *res = parsed_result;
+
+ (void)data;
range_count = res->count;
}
-prog_char str_count[] = "count";
+const char PROGMEM str_count[] = "count";
-parse_pgm_token_string_t cmd_range_count_range_count =
+const parse_token_string_t PROGMEM cmd_range_count_range_count =
TOKEN_STRING_INITIALIZER(struct cmd_range_count_result, range,
str_range);
-parse_pgm_token_string_t cmd_range_count_action =
+const parse_token_string_t PROGMEM cmd_range_count_action =
TOKEN_STRING_INITIALIZER(struct cmd_range_count_result, action,
str_count);
-parse_pgm_token_num_t cmd_range_count_count =
+const parse_token_num_t PROGMEM cmd_range_count_count =
TOKEN_NUM_INITIALIZER(struct cmd_range_count_result, count, UINT32);
-prog_char help_range_count[] = "set range test count";
+const char PROGMEM help_range_count[] = "set range test count";
-parse_pgm_inst_t cmd_range_count = {
+const parse_inst_t PROGMEM cmd_range_count = {
.f = cmd_range_count_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_range_count,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_range_count_range_count,
- (prog_void *)&cmd_range_count_action,
- (prog_void *)&cmd_range_count_count,
+ (PGM_P)&cmd_range_count_range_count,
+ (PGM_P)&cmd_range_count_action,
+ (PGM_P)&cmd_range_count_count,
NULL,
},
};
static void cmd_range_powermask_parsed(void *parsed_result, void *data)
{
struct cmd_range_powermask_result *res = parsed_result;
+
+ (void)data;
range_powermask = res->powermask;
}
-prog_char str_powermask[] = "powermask";
+const char PROGMEM str_powermask[] = "powermask";
-parse_pgm_token_string_t cmd_range_powermask_range_powermask =
+const parse_token_string_t PROGMEM cmd_range_powermask_range_powermask =
TOKEN_STRING_INITIALIZER(struct cmd_range_powermask_result, range,
str_range);
-parse_pgm_token_string_t cmd_range_powermask_action =
+const parse_token_string_t PROGMEM cmd_range_powermask_action =
TOKEN_STRING_INITIALIZER(struct cmd_range_powermask_result, action,
str_powermask);
-parse_pgm_token_num_t cmd_range_powermask_powermask =
+const parse_token_num_t PROGMEM cmd_range_powermask_powermask =
TOKEN_NUM_INITIALIZER(struct cmd_range_powermask_result, powermask,
UINT8);
-prog_char help_range_powermask[] = "set range test powermask";
+const char PROGMEM help_range_powermask[] = "set range test powermask";
-parse_pgm_inst_t cmd_range_powermask = {
+const parse_inst_t PROGMEM cmd_range_powermask = {
.f = cmd_range_powermask_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_range_powermask,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_range_powermask_range_powermask,
- (prog_void *)&cmd_range_powermask_action,
- (prog_void *)&cmd_range_powermask_powermask,
+ (PGM_P)&cmd_range_powermask_range_powermask,
+ (PGM_P)&cmd_range_powermask_action,
+ (PGM_P)&cmd_range_powermask_powermask,
NULL,
},
};
static void cmd_range_dstaddr_parsed(void *parsed_result, void *data)
{
struct cmd_range_dstaddr_result *res = parsed_result;
+
+ (void)data;
range_dstaddr = res->dstaddr;
}
-prog_char str_dstaddr[] = "dstaddr";
+const char PROGMEM str_dstaddr[] = "dstaddr";
-parse_pgm_token_string_t cmd_range_dstaddr_range_dstaddr =
+const parse_token_string_t PROGMEM cmd_range_dstaddr_range_dstaddr =
TOKEN_STRING_INITIALIZER(struct cmd_range_dstaddr_result, range,
str_range);
-parse_pgm_token_string_t cmd_range_dstaddr_action =
+const parse_token_string_t PROGMEM cmd_range_dstaddr_action =
TOKEN_STRING_INITIALIZER(struct cmd_range_dstaddr_result, action,
str_dstaddr);
-parse_pgm_token_num_t cmd_range_dstaddr_dstaddr =
+const parse_token_num_t PROGMEM cmd_range_dstaddr_dstaddr =
TOKEN_NUM_INITIALIZER(struct cmd_range_dstaddr_result, dstaddr, UINT64);
-prog_char help_range_dstaddr[] = "set register rangeing dstaddr";
+const char PROGMEM help_range_dstaddr[] = "set register rangeing dstaddr";
-parse_pgm_inst_t cmd_range_dstaddr = {
+const parse_inst_t PROGMEM cmd_range_dstaddr = {
.f = cmd_range_dstaddr_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_range_dstaddr,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_range_dstaddr_range_dstaddr,
- (prog_void *)&cmd_range_dstaddr_action,
- (prog_void *)&cmd_range_dstaddr_dstaddr,
+ (PGM_P)&cmd_range_dstaddr_range_dstaddr,
+ (PGM_P)&cmd_range_dstaddr_action,
+ (PGM_P)&cmd_range_dstaddr_dstaddr,
NULL,
},
};
struct cmd_monitor_result *res = parsed_result;
struct monitor_reg *m;
+ (void)data;
if (!strcmp_P(res->action, PSTR("show"))) {
printf_P(PSTR("monitor period is %d ms, %d regs in list\r\n"),
monitor_period_ms, monitor_count);
}
}
-prog_char str_monitor[] = "monitor";
-prog_char str_monitor_tokens[] = "show#start#end";
+const char PROGMEM str_monitor[] = "monitor";
+const char PROGMEM str_monitor_tokens[] = "show#start#end";
-parse_pgm_token_string_t cmd_monitor_monitor =
+const parse_token_string_t PROGMEM cmd_monitor_monitor =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_result, monitor,
str_monitor);
-parse_pgm_token_string_t cmd_monitor_action =
+const parse_token_string_t PROGMEM cmd_monitor_action =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_result, action,
str_monitor_tokens);
-prog_char help_monitor[] = "start/stop/show current monitoring";
+const char PROGMEM help_monitor[] = "start/stop/show current monitoring";
-parse_pgm_inst_t cmd_monitor = {
+const parse_inst_t PROGMEM cmd_monitor = {
.f = cmd_monitor_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_monitor,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_monitor_monitor,
- (prog_void *)&cmd_monitor_action,
+ (PGM_P)&cmd_monitor_monitor,
+ (PGM_P)&cmd_monitor_action,
NULL,
},
};
struct cmd_monitor_add_result {
fixed_string_t monitor;
fixed_string_t action;
- struct xbee_atcmd_pgm *cmd;
+ struct xbee_atcmd *cmd;
};
/* function called when cmd_monitor_add is parsed successfully */
struct monitor_reg *m;
struct xbee_atcmd copy;
+ (void)data;
memcpy_P(©, res->cmd, sizeof(copy));
LIST_FOREACH(m, &xbee_monitor_list, next) {
if (!strcmp_P(m->atcmd, copy.name))
monitor_count ++;
}
-prog_char str_monitor_add[] = "add";
+const char PROGMEM str_monitor_add[] = "add";
-parse_pgm_token_string_t cmd_monitor_add_monitor_add =
+const parse_token_string_t PROGMEM cmd_monitor_add_monitor_add =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_add_result, monitor,
str_monitor);
-parse_pgm_token_string_t cmd_monitor_add_action =
+const parse_token_string_t PROGMEM cmd_monitor_add_action =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_add_result, action,
str_monitor_add);
-parse_pgm_token_atcmd_t cmd_monitor_add_atcmd =
+const parse_token_atcmd_t PROGMEM cmd_monitor_add_atcmd =
TOKEN_ATCMD_INITIALIZER(struct cmd_monitor_add_result, cmd, &xbee_dev,
XBEE_ATCMD_F_READ, XBEE_ATCMD_F_READ);
-prog_char help_monitor_add[] = "add a register in monitor list";
+const char PROGMEM help_monitor_add[] = "add a register in monitor list";
-parse_pgm_inst_t cmd_monitor_add = {
+const parse_inst_t PROGMEM cmd_monitor_add = {
.f = cmd_monitor_add_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_monitor_add,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_monitor_add_monitor_add,
- (prog_void *)&cmd_monitor_add_action,
- (prog_void *)&cmd_monitor_add_atcmd,
+ (PGM_P)&cmd_monitor_add_monitor_add,
+ (PGM_P)&cmd_monitor_add_action,
+ (PGM_P)&cmd_monitor_add_atcmd,
NULL,
},
};
{
struct cmd_monitor_period_result *res = parsed_result;
+ (void)data;
if (res->period < 100) {
printf_P(PSTR("error, minimum period is 100 ms\r\n"));
return;
monitor_period_ms = res->period;
}
-prog_char str_monitor_period[] = "period";
+const char PROGMEM str_monitor_period[] = "period";
-parse_pgm_token_string_t cmd_monitor_period_monitor_period =
+const parse_token_string_t PROGMEM cmd_monitor_period_monitor_period =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_period_result, monitor,
str_monitor);
-parse_pgm_token_string_t cmd_monitor_period_action =
+const parse_token_string_t PROGMEM cmd_monitor_period_action =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_period_result, action,
str_monitor_period);
-parse_pgm_token_num_t cmd_monitor_period_period =
+const parse_token_num_t PROGMEM cmd_monitor_period_period =
TOKEN_NUM_INITIALIZER(struct cmd_monitor_period_result, period, UINT32);
-prog_char help_monitor_period[] = "set register monitoring period";
+const char PROGMEM help_monitor_period[] = "set register monitoring period";
-parse_pgm_inst_t cmd_monitor_period = {
+const parse_inst_t PROGMEM cmd_monitor_period = {
.f = cmd_monitor_period_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_monitor_period,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_monitor_period_monitor_period,
- (prog_void *)&cmd_monitor_period_action,
- (prog_void *)&cmd_monitor_period_period,
+ (PGM_P)&cmd_monitor_period_monitor_period,
+ (PGM_P)&cmd_monitor_period_action,
+ (PGM_P)&cmd_monitor_period_period,
NULL,
},
};
{
struct cmd_monitor_del_result *res = parsed_result;
+ (void)data;
monitor_current = LIST_NEXT(res->m, next);
LIST_REMOVE(res->m, next);
free(res->m);
}
}
-prog_char str_monitor_del[] = "del";
+const char PROGMEM str_monitor_del[] = "del";
-parse_pgm_token_string_t cmd_monitor_del_monitor_del =
+const parse_token_string_t PROGMEM cmd_monitor_del_monitor_del =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_del_result, monitor,
str_monitor);
-parse_pgm_token_string_t cmd_monitor_del_action =
+const parse_token_string_t PROGMEM cmd_monitor_del_action =
TOKEN_STRING_INITIALIZER(struct cmd_monitor_del_result, action,
str_monitor_del);
-parse_pgm_token_monitor_t cmd_monitor_del_atcmd =
+const parse_token_monitor_t PROGMEM cmd_monitor_del_atcmd =
TOKEN_MONITOR_INITIALIZER(struct cmd_monitor_del_result, m);
-prog_char help_monitor_del[] = "del a register in monitor list";
+const char PROGMEM help_monitor_del[] = "del a register in monitor list";
-parse_pgm_inst_t cmd_monitor_del = {
+const parse_inst_t PROGMEM cmd_monitor_del = {
.f = cmd_monitor_del_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_monitor_del,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_monitor_del_monitor_del,
- (prog_void *)&cmd_monitor_del_action,
- (prog_void *)&cmd_monitor_del_atcmd,
+ (PGM_P)&cmd_monitor_del_monitor_del,
+ (PGM_P)&cmd_monitor_del_action,
+ (PGM_P)&cmd_monitor_del_atcmd,
NULL,
},
};
/* function called when cmd_ping is parsed successfully */
static void cmd_ping_parsed(void *parsed_result, void *data)
{
+ (void)parsed_result;
+ (void)data;
xbeeapp_send_atcmd("VL", NULL, 0, 1, NULL, NULL);
}
-prog_char str_ping[] = "ping";
+const char PROGMEM str_ping[] = "ping";
-parse_pgm_token_string_t cmd_ping_ping =
+const parse_token_string_t PROGMEM cmd_ping_ping =
TOKEN_STRING_INITIALIZER(struct cmd_ping_result, ping,
str_ping);
-prog_char help_ping[] = "Send a ping to the xbee device";
+const char PROGMEM help_ping[] = "Send a ping to the xbee device";
-parse_pgm_inst_t cmd_ping = {
+const parse_inst_t PROGMEM cmd_ping = {
.f = cmd_ping_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_ping,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_ping_ping,
+ (PGM_P)&cmd_ping_ping,
NULL,
},
};
/* function called when cmd_raw is parsed successfully */
static void cmd_raw_parsed(void *parsed_result, void *data)
{
+ (void)parsed_result;
+ (void)data;
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;
}
-prog_char str_raw[] = "raw";
+const char PROGMEM str_raw[] = "raw";
-parse_pgm_token_string_t cmd_raw_raw =
+const parse_token_string_t PROGMEM cmd_raw_raw =
TOKEN_STRING_INITIALIZER(struct cmd_raw_result, raw,
str_raw);
-prog_char help_raw[] = "Switch to raw mode";
+const char PROGMEM help_raw[] = "Switch to raw mode";
-parse_pgm_inst_t cmd_raw = {
+const parse_inst_t PROGMEM cmd_raw = {
.f = cmd_raw_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_raw,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_raw_raw,
+ (PGM_P)&cmd_raw_raw,
NULL,
},
};
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;
}
-prog_char str_dump[] = "dump";
-prog_char str_dump_onoff[] = "on#off";
+const char PROGMEM str_dump[] = "dump";
+const char PROGMEM str_dump_onoff[] = "on#off";
-parse_pgm_token_string_t cmd_dump_dump =
+const parse_token_string_t PROGMEM cmd_dump_dump =
TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump,
str_dump);
-parse_pgm_token_string_t cmd_dump_onoff =
+const parse_token_string_t PROGMEM cmd_dump_onoff =
TOKEN_STRING_INITIALIZER(struct cmd_dump_result, onoff,
str_dump_onoff);
-prog_char help_dump[] = "enable/disable hexdump of received packets";
+const char PROGMEM help_dump[] = "enable/disable hexdump of received packets";
-parse_pgm_inst_t cmd_dump = {
+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 */
- (prog_void *)&cmd_dump_dump,
- (prog_void *)&cmd_dump_onoff,
+ (PGM_P)&cmd_dump_dump,
+ (PGM_P)&cmd_dump_onoff,
NULL,
},
};
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;
}
-prog_char str_debug[] = "debug";
-prog_char str_debug_onoff[] = "on#off";
+const char PROGMEM str_debug[] = "debug";
+const char PROGMEM str_debug_onoff[] = "on#off";
-parse_pgm_token_string_t cmd_debug_debug =
+const parse_token_string_t PROGMEM cmd_debug_debug =
TOKEN_STRING_INITIALIZER(struct cmd_debug_result, debug,
str_debug);
-parse_pgm_token_string_t cmd_debug_onoff =
+const parse_token_string_t PROGMEM cmd_debug_onoff =
TOKEN_STRING_INITIALIZER(struct cmd_debug_result, onoff,
str_debug_onoff);
-prog_char help_debug[] = "enable/disable additionnal debug";
+const char PROGMEM help_debug[] = "enable/disable additionnal debug";
-parse_pgm_inst_t cmd_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 */
- (prog_void *)&cmd_debug_debug,
- (prog_void *)&cmd_debug_onoff,
+ (PGM_P)&cmd_debug_debug,
+ (PGM_P)&cmd_debug_onoff,
NULL,
},
};
-#ifndef USE_USB
/**********************************************************/
/* this structure is filled when cmd_baudrate is parsed successfully */
uart_setconf(XBEE_UART, &c);
}
-prog_char str_baudrate_arg0[] = "baudrate";
-parse_pgm_token_string_t cmd_baudrate_arg0 =
+const char PROGMEM str_baudrate_arg0[] = "baudrate";
+const parse_token_string_t PROGMEM cmd_baudrate_arg0 =
TOKEN_STRING_INITIALIZER(struct cmd_baudrate_result, arg0,
str_baudrate_arg0);
-parse_pgm_token_num_t cmd_baudrate_arg1 =
+const parse_token_num_t PROGMEM cmd_baudrate_arg1 =
TOKEN_NUM_INITIALIZER(struct cmd_baudrate_result, arg1,
UINT32);
-prog_char help_baudrate[] = "Change xbee baudrate";
-parse_pgm_inst_t cmd_baudrate = {
+const char PROGMEM help_baudrate[] = "Change xbee baudrate";
+const parse_inst_t PROGMEM cmd_baudrate = {
.f = cmd_baudrate_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_baudrate,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_baudrate_arg0,
- (prog_void *)&cmd_baudrate_arg1,
+ (PGM_P)&cmd_baudrate_arg0,
+ (PGM_P)&cmd_baudrate_arg1,
NULL,
},
};
-#endif
+/**********************************************************/
+
+/* this structure is filled when cmd_beep is parsed successfully */
+struct cmd_beep_result {
+ fixed_string_t beep;
+};
+
+/* function called when cmd_beep is parsed successfully */
+static void cmd_beep_parsed(void *parsed_result, void *data)
+{
+ (void)parsed_result;
+ (void)data;
+
+ beep(0, 3, 3);
+ beep(1, 3, 3);
+ beep(2, 3, 3);
+ beep(0, 1, 1);
+ beep(1, 1, 1);
+ beep(2, 1, 1);
+}
+
+const char PROGMEM str_beep[] = "beep";
+const parse_token_string_t PROGMEM cmd_beep_beep =
+ TOKEN_STRING_INITIALIZER(struct cmd_beep_result, beep,
+ str_beep);
+
+const char PROGMEM help_beep[] = "Send a beep";
+
+const parse_inst_t PROGMEM cmd_beep = {
+ .f = cmd_beep_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_beep,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_beep_beep,
+ NULL,
+ },
+};
+
+/**********************************************************/
+
+/* this structure is filled when cmd_servo is parsed successfully */
+struct cmd_servo_result {
+ fixed_string_t arg0;
+ fixed_string_t arg1;
+ uint16_t num;
+ uint16_t val;
+};
+
+/* function called when cmd_servo is parsed successfully */
+static void cmd_servo_parsed(void * parsed_result, void *data)
+{
+ struct cmd_servo_result *res = parsed_result;
+
+ (void)data;
+
+ if (!strcmp_P(res->arg1, PSTR("set"))) {
+ if (res->num >= N_SERVO) {
+ printf_P(PSTR("bad servo num\n"));
+ return;
+ }
+ if (res->val >= 1024) {
+ printf_P(PSTR("bad servo val\n"));
+ return;
+ }
+ spi_servo_set(res->num, res->val);
+ }
+ else if (!strcmp_P(res->arg1, PSTR("bypass"))) {
+ spi_servo_set_bypass(!!res->val);
+ }
+ else if (!strcmp_P(res->arg1, PSTR("ppm"))) {
+ spi_servo_set_ppm(!!res->val);
+ }
+ else if (!strcmp_P(res->arg1, PSTR("show"))) {
+ spi_servo_dump();
+ }
+}
+
+const char PROGMEM str_servo_arg0[] = "servo";
+const parse_token_string_t PROGMEM cmd_servo_arg0 =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg0,
+ str_servo_arg0);
+const char PROGMEM str_servo_arg1_set[] = "set";
+const parse_token_string_t PROGMEM cmd_servo_arg1_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1,
+ str_servo_arg1_set);
+const parse_token_num_t PROGMEM cmd_servo_num =
+ TOKEN_NUM_INITIALIZER(struct cmd_servo_result, num,
+ UINT16);
+const parse_token_num_t PROGMEM cmd_servo_val =
+ TOKEN_NUM_INITIALIZER(struct cmd_servo_result, val,
+ UINT16);
+
+const char PROGMEM help_servo_set[] = "set servo value";
+const parse_inst_t PROGMEM cmd_servo_set = {
+ .f = cmd_servo_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_servo_set,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_servo_arg0,
+ (PGM_P)&cmd_servo_arg1_set,
+ (PGM_P)&cmd_servo_num,
+ (PGM_P)&cmd_servo_val,
+ NULL,
+ },
+};
+
+const char PROGMEM str_servo_arg1_show[] = "show";
+const parse_token_string_t PROGMEM cmd_servo_arg1_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1,
+ str_servo_arg1_show);
+
+const char PROGMEM help_servo_show[] = "read servo and config";
+const parse_inst_t PROGMEM cmd_servo_show = {
+ .f = cmd_servo_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_servo_show,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_servo_arg0,
+ (PGM_P)&cmd_servo_arg1_show,
+ NULL,
+ },
+};
+
+const char PROGMEM str_servo_arg1_bypassppm[] = "bypass#ppm";
+const parse_token_string_t PROGMEM cmd_servo_arg1_bypassppm =
+ TOKEN_STRING_INITIALIZER(struct cmd_servo_result, arg1,
+ str_servo_arg1_bypassppm);
+
+const char PROGMEM help_servo_bypassppm[] = "change bypass/ppm";
+const parse_inst_t PROGMEM cmd_servo_bypassppm = {
+ .f = cmd_servo_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_servo_bypassppm,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_servo_arg0,
+ (PGM_P)&cmd_servo_arg1_bypassppm,
+ (PGM_P)&cmd_servo_val,
+ NULL,
+ },
+};
+
+/**********************************************************/
+
+/* this structure is filled when cmd_test_spi is parsed successfully */
+struct cmd_test_spi_result {
+ fixed_string_t arg0;
+};
+
+static void cmd_test_spi_parsed(void * parsed_result, void *data)
+{
+ uint8_t i, flags, wait_time = 0;
+ uint16_t val = 0;
+
+ (void)parsed_result;
+ (void)data;
+
+ spi_servo_set_bypass(0);
+ spi_servo_set_ppm(0);
+
+ /* stress test: send many commands, no wait between each servo
+ * of a series, and a variable delay between series */
+ printf_P(PSTR("stress test\r\n"));
+ while (!cmdline_keypressed()) {
+
+ wait_time++;
+ if (wait_time > 20)
+ wait_time = 0;
+
+ IRQ_LOCK(flags);
+ val = global_ms;
+ IRQ_UNLOCK(flags);
+ val >>= 3;
+ val &= 1023;
+
+ for (i = 0; i < 6; i++)
+ spi_servo_set(i, val);
+
+ wait_ms(wait_time);
+ printf_P(PSTR("%4.4d %4.4d %4.4d %4.4d %4.4d %4.4d\r\n"),
+ spi_servo_get(0), spi_servo_get(1), spi_servo_get(2),
+ spi_servo_get(3), spi_servo_get(4), spi_servo_get(5));
+ }
+
+ printf_P(PSTR("bypass mode, with spi commands in background\r\n"));
+ spi_servo_set_bypass(1);
+
+ /* test bypass mode */
+ while (!cmdline_keypressed()) {
+
+ wait_time++;
+ if (wait_time > 20)
+ wait_time = 0;
+
+ IRQ_LOCK(flags);
+ val = global_ms;
+ IRQ_UNLOCK(flags);
+ val >>= 3;
+ val &= 1023;
+
+ for (i = 0; i < 6; i++)
+ spi_servo_set(i, val);
+
+ wait_ms(wait_time);
+ printf_P(PSTR("%4.4d %4.4d %4.4d %4.4d %4.4d %4.4d\r\n"),
+ spi_servo_get(0), spi_servo_get(1), spi_servo_get(2),
+ spi_servo_get(3), spi_servo_get(4), spi_servo_get(5));
+ }
+
+ printf_P(PSTR("PPM to servo\r\n"));
+ spi_servo_set_bypass(0);
+ spi_servo_set_ppm(0);
+
+ /* test PPM to servo (bypass) mode */
+ while (!cmdline_keypressed()) {
+ for (i = 0; i < 6; i++) {
+ val = spi_servo_get(i);
+ spi_servo_set(i, val);
+ }
+ }
+
+ printf_P(PSTR("PPM to (servo + PPM)\r\n"));
+ spi_servo_set_bypass(0);
+ spi_servo_set_ppm(1);
+
+ /* test PPM to servo (bypass) mode */
+ while (!cmdline_keypressed()) {
+ for (i = 0; i < 6; i++) {
+ val = spi_servo_get(i);
+ spi_servo_set(i, val);
+ }
+ }
+}
+
+const char PROGMEM str_test_spi_arg0[] = "test_spi";
+const parse_token_string_t PROGMEM cmd_test_spi_arg0 =
+ TOKEN_STRING_INITIALIZER(struct cmd_test_spi_result, arg0,
+ str_test_spi_arg0);
+
+const char PROGMEM help_test_spi[] = "Test the spi";
+const parse_inst_t PROGMEM cmd_test_spi = {
+ .f = cmd_test_spi_parsed, /* function to call */
+ .data = NULL, /* 2nd arg of func */
+ .help_str = help_test_spi,
+ .tokens = { /* token list, NULL terminated */
+ (PGM_P)&cmd_test_spi_arg0,
+ NULL,
+ },
+};
+
+/**********************************************************/
+
+/* 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 */
-parse_pgm_ctx_t main_ctx[] = {
+const parse_ctx_t PROGMEM main_ctx[] = {
/* commands_gen.c */
- (parse_pgm_inst_t *)&cmd_reset,
- (parse_pgm_inst_t *)&cmd_bootloader,
- (parse_pgm_inst_t *)&cmd_log,
- (parse_pgm_inst_t *)&cmd_log_show,
- (parse_pgm_inst_t *)&cmd_log_type,
- (parse_pgm_inst_t *)&cmd_stack_space,
- (parse_pgm_inst_t *)&cmd_scheduler,
- (parse_pgm_inst_t *)&cmd_help,
- (parse_pgm_inst_t *)&cmd_neigh_del,
- (parse_pgm_inst_t *)&cmd_neigh_add,
- (parse_pgm_inst_t *)&cmd_neigh_list,
- (parse_pgm_inst_t *)&cmd_read,
- (parse_pgm_inst_t *)&cmd_write_none,
- (parse_pgm_inst_t *)&cmd_write_u8,
- (parse_pgm_inst_t *)&cmd_write_u16,
- (parse_pgm_inst_t *)&cmd_write_u32,
- (parse_pgm_inst_t *)&cmd_sendmsg,
- (parse_pgm_inst_t *)&cmd_sendmsg_name,
- (parse_pgm_inst_t *)&cmd_range,
- (parse_pgm_inst_t *)&cmd_range_period,
- (parse_pgm_inst_t *)&cmd_range_count,
- (parse_pgm_inst_t *)&cmd_range_powermask,
- (parse_pgm_inst_t *)&cmd_range_dstaddr,
- (parse_pgm_inst_t *)&cmd_monitor,
- (parse_pgm_inst_t *)&cmd_monitor_period,
- (parse_pgm_inst_t *)&cmd_monitor_add,
- (parse_pgm_inst_t *)&cmd_monitor_del,
- (parse_pgm_inst_t *)&cmd_ping,
- (parse_pgm_inst_t *)&cmd_raw,
- (parse_pgm_inst_t *)&cmd_dump,
- (parse_pgm_inst_t *)&cmd_debug,
-#ifndef USE_USB
- (parse_pgm_inst_t *)&cmd_baudrate,
-#endif
+ &cmd_reset,
+ &cmd_bootloader,
+ &cmd_log,
+ &cmd_log_show,
+ &cmd_log_type,
+ &cmd_stack_space,
+ &cmd_scheduler,
+ &cmd_help,
+ &cmd_neigh_del,
+ &cmd_neigh_add,
+ &cmd_neigh_list,
+ &cmd_read,
+ &cmd_write_none,
+ &cmd_write_u8,
+ &cmd_write_u16,
+ &cmd_write_u32,
+ &cmd_sendmsg,
+ &cmd_send_hello,
+ &cmd_send_hello_name,
+ &cmd_sendmsg_name,
+ &cmd_range,
+ &cmd_range_period,
+ &cmd_range_count,
+ &cmd_range_powermask,
+ &cmd_range_dstaddr,
+ &cmd_monitor,
+ &cmd_monitor_period,
+ &cmd_monitor_add,
+ &cmd_monitor_del,
+ &cmd_ping,
+ &cmd_raw,
+ &cmd_dump,
+ &cmd_debug,
+ &cmd_baudrate,
+ &cmd_beep,
+ &cmd_servo_set,
+ &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,
};