#include <aversive/queue.h>
#include <uart.h>
-#include <clock_time.h>
-
-#include <scheduler.h>
-#include <scheduler_stats.h>
#include <rdline.h>
#include <parse.h>
/* function called when cmd_reset is parsed successfully */
static void cmd_reset_parsed(void * parsed_result, void * data)
{
+ (void)parsed_result;
+ (void)data;
#ifdef HOST_VERSION
hostsim_exit();
#endif
reset();
}
-prog_char str_reset_arg0[] = "reset";
-parse_pgm_token_string_t cmd_reset_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_reset_result, arg0, str_reset_arg0);
+const char PROGMEM str_reset_arg0[] = "reset";
+const parse_token_string_t PROGMEM cmd_reset_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_reset_result, arg0, str_reset_arg0);
-prog_char help_reset[] = "Reset the board";
-parse_pgm_inst_t cmd_reset = {
+const char PROGMEM help_reset[] = "Reset the board";
+const parse_inst_t PROGMEM cmd_reset = {
.f = cmd_reset_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_reset,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_reset_arg0,
+ (PGM_P)&cmd_reset_arg0,
NULL,
},
};
/* function called when cmd_bootloader is parsed successfully */
static void cmd_bootloader_parsed(void *parsed_result, void *data)
{
+ (void)parsed_result;
+ (void)data;
#ifndef HOST_VERSION
bootloader();
#else
#endif
}
-prog_char str_bootloader_arg0[] = "bootloader";
-parse_pgm_token_string_t cmd_bootloader_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_bootloader_result, arg0, str_bootloader_arg0);
+const char PROGMEM str_bootloader_arg0[] = "bootloader";
+const parse_token_string_t PROGMEM cmd_bootloader_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_bootloader_result, arg0, str_bootloader_arg0);
-prog_char help_bootloader[] = "Launch the bootloader";
-parse_pgm_inst_t cmd_bootloader = {
+const char PROGMEM help_bootloader[] = "Launch the bootloader";
+const parse_inst_t PROGMEM cmd_bootloader = {
.f = cmd_bootloader_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_bootloader,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_bootloader_arg0,
+ (PGM_P)&cmd_bootloader_arg0,
NULL,
},
};
/**********************************************************/
-/* Scheduler show */
+/* Callout show */
-/* this structure is filled when cmd_scheduler is parsed successfully */
-struct cmd_scheduler_result {
+/* this structure is filled when cmd_callout is parsed successfully */
+struct cmd_callout_result {
fixed_string_t arg0;
fixed_string_t arg1;
};
-/* function called when cmd_scheduler is parsed successfully */
-static void cmd_scheduler_parsed(void *parsed_result, void *data)
+/* function called when cmd_callout is parsed successfully */
+static void cmd_callout_parsed(void *parsed_result, void *data)
{
- scheduler_dump_events();
- scheduler_stats_dump();
+ (void)parsed_result;
+ (void)data;
+ callout_dump_stats(&xbeeboard.intr_cm);
}
-prog_char str_scheduler_arg0[] = "scheduler";
-parse_pgm_token_string_t cmd_scheduler_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_scheduler_result, arg0, str_scheduler_arg0);
-prog_char str_scheduler_arg1[] = "show";
-parse_pgm_token_string_t cmd_scheduler_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_scheduler_result, arg1, str_scheduler_arg1);
+const char PROGMEM str_callout_arg0[] = "callout";
+const parse_token_string_t PROGMEM cmd_callout_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_callout_result, arg0, str_callout_arg0);
+const char PROGMEM str_callout_arg1[] = "show";
+const parse_token_string_t PROGMEM cmd_callout_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_callout_result, arg1, str_callout_arg1);
-prog_char help_scheduler[] = "Show scheduler events";
-parse_pgm_inst_t cmd_scheduler = {
- .f = cmd_scheduler_parsed, /* function to call */
+const char PROGMEM help_callout[] = "Show callout events";
+const parse_inst_t PROGMEM cmd_callout = {
+ .f = cmd_callout_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
- .help_str = help_scheduler,
+ .help_str = help_callout,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_scheduler_arg0,
- (prog_void *)&cmd_scheduler_arg1,
+ (PGM_P)&cmd_callout_arg0,
+ (PGM_P)&cmd_callout_arg1,
NULL,
},
};
};
/* keep it sync with string choice */
-static const prog_char uart_log[] = "uart";
-static const prog_char i2c_log[] = "i2c";
-static const prog_char default_log[] = "default";
+static const char PROGMEM uart_log[] = "uart";
+static const char PROGMEM i2c_log[] = "i2c";
+static const char PROGMEM default_log[] = "default";
+static const char PROGMEM xbee_log[] = "xbee";
+static const char PROGMEM rc_proto_log[] = "rc_proto";
struct log_name_and_num {
- const prog_char * name;
+ const char *name;
uint8_t num;
};
{ uart_log, E_UART },
{ i2c_log, E_I2C },
{ default_log, E_USER_DEFAULT },
+ { xbee_log, E_USER_XBEE },
+ { rc_proto_log, E_USER_RC_PROTO },
};
static uint8_t
return 0;
}
-const prog_char *
+const char *
log_num2name(uint8_t num)
{
uint8_t i;
static void cmd_log_do_show(void)
{
uint8_t i, empty=1;
- const prog_char * name;
+ const char *name;
printf_P(PSTR("log level is %d\r\n"), xbeeboard.log_level);
for (i=0; i<NB_LOGS; i++) {
}
/* function called when cmd_log is parsed successfully */
-static void cmd_log_parsed(void * parsed_result, void * data)
+static void cmd_log_parsed(void * parsed_result, void *data)
{
struct cmd_log_result *res = (struct cmd_log_result *) parsed_result;
+ (void)data;
if (!strcmp_P(res->arg1, PSTR("level"))) {
xbeeboard.log_level = res->arg2;
}
cmd_log_do_show();
}
-prog_char str_log_arg0[] = "log";
-parse_pgm_token_string_t cmd_log_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg0, str_log_arg0);
-prog_char str_log_arg1[] = "level";
-parse_pgm_token_string_t cmd_log_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1);
-parse_pgm_token_num_t cmd_log_arg2 = TOKEN_NUM_INITIALIZER(struct cmd_log_result, arg2, INT8);
+const char PROGMEM str_log_arg0[] = "log";
+const parse_token_string_t PROGMEM cmd_log_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg0, str_log_arg0);
+const char PROGMEM str_log_arg1[] = "level";
+const parse_token_string_t PROGMEM cmd_log_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1);
+const parse_token_num_t PROGMEM cmd_log_arg2 = TOKEN_NUM_INITIALIZER(struct cmd_log_result, arg2, INT8);
-prog_char help_log[] = "Set log options: level (0 -> 5)";
-parse_pgm_inst_t cmd_log = {
+const char PROGMEM help_log[] = "Set log options: level (0 -> 5)";
+const parse_inst_t PROGMEM cmd_log = {
.f = cmd_log_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_log,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_log_arg0,
- (prog_void *)&cmd_log_arg1,
- (prog_void *)&cmd_log_arg2,
+ (PGM_P)&cmd_log_arg0,
+ (PGM_P)&cmd_log_arg1,
+ (PGM_P)&cmd_log_arg2,
NULL,
},
};
-prog_char str_log_arg1_show[] = "show";
-parse_pgm_token_string_t cmd_log_arg1_show = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1_show);
+const char PROGMEM str_log_arg1_show[] = "show";
+const parse_token_string_t PROGMEM cmd_log_arg1_show = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1_show);
-prog_char help_log_show[] = "Show configured logs";
-parse_pgm_inst_t cmd_log_show = {
+const char PROGMEM help_log_show[] = "Show configured logs";
+const parse_inst_t PROGMEM cmd_log_show = {
.f = cmd_log_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_log_show,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_log_arg0,
- (prog_void *)&cmd_log_arg1_show,
+ (PGM_P)&cmd_log_arg0,
+ (PGM_P)&cmd_log_arg1_show,
NULL,
},
};
};
/* function called when cmd_log is parsed successfully */
-static void cmd_log_type_parsed(void * parsed_result, void * data)
+static void cmd_log_type_parsed(void * parsed_result, void *data)
{
struct cmd_log_type_result *res = (struct cmd_log_type_result *) parsed_result;
uint8_t lognum;
uint8_t i;
-
+
+ (void)data;
+
lognum = log_name2num(res->arg2);
if (lognum == 0) {
printf_P(PSTR("Cannot find log num\r\n"));
cmd_log_do_show();
}
-prog_char str_log_arg1_type[] = "type";
-parse_pgm_token_string_t cmd_log_arg1_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg1, str_log_arg1_type);
+const char PROGMEM str_log_arg1_type[] = "type";
+const parse_token_string_t PROGMEM cmd_log_arg1_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg1, str_log_arg1_type);
/* keep it sync with log_name_and_num above */
-prog_char str_log_arg2_type[] = "uart#rs#servo#traj#i2c#oa#strat#i2cproto#ext#sensor#bd#cs";
-parse_pgm_token_string_t cmd_log_arg2_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg2, str_log_arg2_type);
-prog_char str_log_arg3[] = "on#off";
-parse_pgm_token_string_t cmd_log_arg3 = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg3, str_log_arg3);
-
-prog_char help_log_type[] = "Set log type";
-parse_pgm_inst_t cmd_log_type = {
+const char PROGMEM str_log_arg2_type[] =
+ "uart#i2c#i2cproto#default#xbee#rc_proto";
+const parse_token_string_t PROGMEM cmd_log_arg2_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg2, str_log_arg2_type);
+const char PROGMEM str_log_arg3[] = "on#off";
+const parse_token_string_t PROGMEM cmd_log_arg3 = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg3, str_log_arg3);
+
+const char PROGMEM help_log_type[] = "Set log type";
+const parse_inst_t PROGMEM cmd_log_type = {
.f = cmd_log_type_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_log_type,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_log_arg0,
- (prog_void *)&cmd_log_arg1_type,
- (prog_void *)&cmd_log_arg2_type,
- (prog_void *)&cmd_log_arg3,
+ (PGM_P)&cmd_log_arg0,
+ (PGM_P)&cmd_log_arg1_type,
+ (PGM_P)&cmd_log_arg2_type,
+ (PGM_P)&cmd_log_arg3,
NULL,
},
};
/* function called when cmd_stack_space is parsed successfully */
static void cmd_stack_space_parsed(void *parsed_result, void *data)
{
+ (void)parsed_result;
+ (void)data;
#ifdef HOST_VERSION
printf("not implemented\n");
#else
#endif
}
-prog_char str_stack_space_arg0[] = "stack_space";
-parse_pgm_token_string_t cmd_stack_space_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_stack_space_result, arg0, str_stack_space_arg0);
+const char PROGMEM str_stack_space_arg0[] = "stack_space";
+const parse_token_string_t PROGMEM cmd_stack_space_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_stack_space_result, arg0, str_stack_space_arg0);
-prog_char help_stack_space[] = "Display remaining stack space";
-parse_pgm_inst_t cmd_stack_space = {
+const char PROGMEM help_stack_space[] = "Display remaining stack space";
+const parse_inst_t PROGMEM cmd_stack_space = {
.f = cmd_stack_space_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = help_stack_space,
.tokens = { /* token list, NULL terminated */
- (prog_void *)&cmd_stack_space_arg0,
+ (PGM_P)&cmd_stack_space_arg0,
NULL,
},
};
git.droids-corp.org / protos / xbee-avr.git / blobdiff