#include "cmdline.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 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);
uint8_t i, mask;
struct rc_proto_range rangepkt;
+ (void)clt;
+ (void)dummy;
+
range_cur_count--;
/* get new xmit power */
/* 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,
},
};
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_test_spi is parsed successfully */
struct cmd_test_spi_result {
fixed_string_t arg0;
};
-static void cmd_test_spi_parsed(void * parsed_result,
- __attribute__((unused)) void *data)
+static void cmd_test_spi_parsed(void * parsed_result, void *data)
{
int i;
+ (void)parsed_result;
+ (void)data;
while (1) {
for (i = 0; i < 50; i++) {
}
}
-prog_char str_test_spi_arg0[] = "test_spi";
-parse_pgm_token_string_t cmd_test_spi_arg0 =
+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);
-prog_char help_test_spi[] = "Test the spi";
-parse_pgm_inst_t cmd_test_spi = {
+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 */
- (prog_void *)&cmd_test_spi_arg0,
+ (PGM_P)&cmd_test_spi_arg0,
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
- (parse_pgm_inst_t *)&cmd_test_spi,
+ &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_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_test_spi,
NULL,
};