X-Git-Url: http://git.droids-corp.org/?p=protos%2Fxbee-avr.git;a=blobdiff_plain;f=commands.c;h=dee0693e926c2200a71649ae23a0767c43a8c0a4;hp=6eb034c59b92ade35bdb1673f7b84b3e5f836a3b;hb=a4e51d8b2a5b13308d314aaf72e58672346dfb1f;hpb=f97044f0c5ecbbc665bd7ac1d454fd9479476a78 diff --git a/commands.c b/commands.c index 6eb034c..dee0693 100644 --- a/commands.c +++ b/commands.c @@ -53,13 +53,13 @@ #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; @@ -79,6 +79,9 @@ static int range_cur_count = 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); @@ -95,6 +98,9 @@ static void range_cb(struct callout_manager *cm, uint8_t i, mask; struct rc_proto_range rangepkt; + (void)clt; + (void)dummy; + range_cur_count--; /* get new xmit power */ @@ -125,7 +131,7 @@ static void range_cb(struct callout_manager *cm, /* 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 */ @@ -134,6 +140,9 @@ static void cmd_help_parsed(void *parsed_result, void *data) 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) { @@ -164,23 +173,23 @@ static void cmd_help_parsed(void *parsed_result, void *data) 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, }, }; @@ -197,30 +206,32 @@ static void cmd_neigh_del_parsed(void *parsed_result, 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, }, }; @@ -238,33 +249,35 @@ static void cmd_neigh_add_parsed(void *parsed_result, 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, }, }; @@ -281,6 +294,8 @@ static void cmd_neigh_list_parsed(void *parsed_result, { 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, @@ -289,23 +304,23 @@ static void cmd_neigh_list_parsed(void *parsed_result, } } -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, }, }; @@ -318,7 +333,7 @@ parse_pgm_inst_t cmd_neigh_list = { /* 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 */ @@ -329,30 +344,31 @@ static void cmd_read_parsed(void *parsed_result, 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, }, }; @@ -363,7 +379,7 @@ parse_pgm_inst_t cmd_read = { /* 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; @@ -380,6 +396,7 @@ static void cmd_write_parsed(void *parsed_result, void *data) int len; void *param; + (void)data; memcpy_P(©, res->cmd, sizeof(copy)); if (copy.flags & XBEE_ATCMD_F_PARAM_NONE) { @@ -409,96 +426,96 @@ static void cmd_write_parsed(void *parsed_result, void *data) 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, }, }; @@ -517,31 +534,33 @@ struct cmd_sendmsg_result { 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, }, }; @@ -559,30 +578,32 @@ struct cmd_sendmsg_name_result { 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, }, }; @@ -601,6 +622,7 @@ static void cmd_range_parsed(void *parsed_result, void *data) { 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); @@ -636,25 +658,25 @@ static void cmd_range_parsed(void *parsed_result, void *data) } } -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, }, }; @@ -673,6 +695,7 @@ static void cmd_range_period_parsed(void *parsed_result, void *data) { 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; @@ -681,27 +704,27 @@ static void cmd_range_period_parsed(void *parsed_result, void *data) 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, }, }; @@ -719,31 +742,33 @@ struct cmd_range_count_result { 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, }, }; @@ -761,32 +786,34 @@ struct cmd_range_powermask_result { 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, }, }; @@ -804,31 +831,33 @@ struct cmd_range_dstaddr_result { 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, }, }; @@ -848,6 +877,7 @@ static void cmd_monitor_parsed(void *parsed_result, void *data) 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); @@ -882,25 +912,25 @@ static void cmd_monitor_parsed(void *parsed_result, void *data) } } -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, }, }; @@ -911,7 +941,7 @@ parse_pgm_inst_t cmd_monitor = { 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 */ @@ -921,6 +951,7 @@ static void cmd_monitor_add_parsed(void *parsed_result, void *data) 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)) @@ -943,29 +974,29 @@ static void cmd_monitor_add_parsed(void *parsed_result, void *data) 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, }, }; @@ -984,6 +1015,7 @@ static void cmd_monitor_period_parsed(void *parsed_result, void *data) { 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; @@ -992,28 +1024,28 @@ static void cmd_monitor_period_parsed(void *parsed_result, void *data) 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, }, }; @@ -1032,6 +1064,7 @@ static void cmd_monitor_del_parsed(void *parsed_result, void *data) { 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); @@ -1044,28 +1077,28 @@ static void cmd_monitor_del_parsed(void *parsed_result, void *data) } } -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, }, }; @@ -1081,23 +1114,25 @@ struct cmd_ping_result { /* 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, }, }; @@ -1112,25 +1147,27 @@ struct cmd_raw_result { /* 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, }, }; @@ -1147,32 +1184,34 @@ struct cmd_dump_result { 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, }, }; @@ -1189,37 +1228,38 @@ struct cmd_debug_result { 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 */ @@ -1239,37 +1279,37 @@ static void cmd_baudrate_parsed(void * parsed_result, __attribute__((unused)) vo 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++) { @@ -1286,60 +1326,58 @@ static void cmd_test_spi_parsed(void * parsed_result, } } -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, };