commands_gen.c

   1 /*
   2  *  Copyright Droids Corporation (2011)
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  *  Revision : $Id: commands_gen.c,v 1.8 2009-11-08 17:24:33 zer0 Exp $
  19  *
  20  *  Olivier MATZ <zer0@droids-corp.org>
  21  */
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25
  26 #include <aversive/pgmspace.h>
  27 #include <aversive/wait.h>
  28 #include <aversive/error.h>
  29 #include <aversive/queue.h>
  30
  31 #include <uart.h>
  32 #include <clock_time.h>
  33
  34 #include <scheduler.h>
  35 #include <scheduler_stats.h>
  36
  37 #include <rdline.h>
  38 #include <parse.h>
  39 #include <parse_string.h>
  40 #include <parse_num.h>
  41
  42 #include <diagnostic.h>
  43
  44 #include "callout.h"
  45 #include "main.h"
  46 #include "cmdline.h"
  47
  48 /**********************************************************/
  49 /* Reset */
  50
  51 /* this structure is filled when cmd_reset is parsed successfully */
  52 struct cmd_reset_result {
  53         fixed_string_t arg0;
  54 };
  55
  56 /* function called when cmd_reset is parsed successfully */
  57 static void cmd_reset_parsed(void * parsed_result, void * data)
  58 {
  59 #ifdef HOST_VERSION
  60         hostsim_exit();
  61 #endif
  62         reset();
  63 }
  64
  65 prog_char str_reset_arg0[] = "reset";
  66 parse_pgm_token_string_t cmd_reset_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_reset_result, arg0, str_reset_arg0);
  67
  68 prog_char help_reset[] = "Reset the board";
  69 parse_pgm_inst_t cmd_reset = {
  70         .f = cmd_reset_parsed,  /* function to call */
  71         .data = NULL,      /* 2nd arg of func */
  72         .help_str = help_reset,
  73         .tokens = {        /* token list, NULL terminated */
  74                 (prog_void *)&cmd_reset_arg0,
  75                 NULL,
  76         },
  77 };
  78
  79 /**********************************************************/
  80 /* Bootloader */
  81
  82 /* this structure is filled when cmd_bootloader is parsed successfully */
  83 struct cmd_bootloader_result {
  84         fixed_string_t arg0;
  85 };
  86
  87 /* function called when cmd_bootloader is parsed successfully */
  88 static void cmd_bootloader_parsed(void *parsed_result, void *data)
  89 {
  90 #ifndef HOST_VERSION
  91         bootloader();
  92 #else
  93         printf("not implemented\n");
  94 #endif
  95 }
  96
  97 prog_char str_bootloader_arg0[] = "bootloader";
  98 parse_pgm_token_string_t cmd_bootloader_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_bootloader_result, arg0, str_bootloader_arg0);
  99
 100 prog_char help_bootloader[] = "Launch the bootloader";
 101 parse_pgm_inst_t cmd_bootloader = {
 102         .f = cmd_bootloader_parsed,  /* function to call */
 103         .data = NULL,      /* 2nd arg of func */
 104         .help_str = help_bootloader,
 105         .tokens = {        /* token list, NULL terminated */
 106                 (prog_void *)&cmd_bootloader_arg0,
 107                 NULL,
 108         },
 109 };
 110
 111 /**********************************************************/
 112 /* Scheduler show */
 113
 114 /* this structure is filled when cmd_scheduler is parsed successfully */
 115 struct cmd_scheduler_result {
 116         fixed_string_t arg0;
 117         fixed_string_t arg1;
 118 };
 119
 120 /* function called when cmd_scheduler is parsed successfully */
 121 static void cmd_scheduler_parsed(void *parsed_result, void *data)
 122 {
 123         scheduler_dump_events();
 124         scheduler_stats_dump();
 125 }
 126
 127 prog_char str_scheduler_arg0[] = "scheduler";
 128 parse_pgm_token_string_t cmd_scheduler_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_scheduler_result, arg0, str_scheduler_arg0);
 129 prog_char str_scheduler_arg1[] = "show";
 130 parse_pgm_token_string_t cmd_scheduler_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_scheduler_result, arg1, str_scheduler_arg1);
 131
 132 prog_char help_scheduler[] = "Show scheduler events";
 133 parse_pgm_inst_t cmd_scheduler = {
 134         .f = cmd_scheduler_parsed,  /* function to call */
 135         .data = NULL,      /* 2nd arg of func */
 136         .help_str = help_scheduler,
 137         .tokens = {        /* token list, NULL terminated */
 138                 (prog_void *)&cmd_scheduler_arg0,
 139                 (prog_void *)&cmd_scheduler_arg1,
 140                 NULL,
 141         },
 142 };
 143
 144 /**********************************************************/
 145 /* Log */
 146
 147 /* this structure is filled when cmd_log is parsed successfully */
 148 struct cmd_log_result {
 149         fixed_string_t arg0;
 150         fixed_string_t arg1;
 151         uint8_t arg2;
 152         fixed_string_t arg3;
 153 };
 154
 155 /* keep it sync with string choice */
 156 static const prog_char uart_log[] = "uart";
 157 static const prog_char i2c_log[] = "i2c";
 158 static const prog_char default_log[] = "default";
 159
 160 struct log_name_and_num {
 161         const prog_char * name;
 162         uint8_t num;
 163 };
 164
 165 static const struct log_name_and_num log_name_and_num[] = {
 166         { uart_log, E_UART },
 167         { i2c_log, E_I2C },
 168         { default_log, E_USER_DEFAULT },
 169 };
 170
 171 static uint8_t
 172 log_name2num(const char * s)
 173 {
 174         uint8_t i;
 175
 176         for (i=0; i<sizeof(log_name_and_num)/sizeof(struct log_name_and_num); i++) {
 177                 if (!strcmp_P(s, log_name_and_num[i].name)) {
 178                         return log_name_and_num[i].num;
 179                 }
 180         }
 181         return 0;
 182 }
 183
 184 const prog_char *
 185 log_num2name(uint8_t num)
 186 {
 187         uint8_t i;
 188
 189         for (i=0; i<sizeof(log_name_and_num)/sizeof(struct log_name_and_num); i++) {
 190                 if (num ==  log_name_and_num[i].num) {
 191                         return log_name_and_num[i].name;
 192                 }
 193         }
 194         return NULL;
 195 }
 196
 197 /* function called when cmd_log is parsed successfully */
 198 static void cmd_log_do_show(void)
 199 {
 200         uint8_t i, empty=1;
 201         const prog_char * name;
 202
 203         printf_P(PSTR("log level is %d\r\n"), xbeeboard.log_level);
 204         for (i=0; i<NB_LOGS; i++) {
 205                 name = log_num2name(xbeeboard.logs[i]);
 206                 if (name) {
 207 #ifdef HOST_VERSION
 208                         printf_P(PSTR("log type %s is on\r\n"), name);
 209 #else
 210                         printf_P(PSTR("log type %S is on\r\n"), name);
 211 #endif
 212                         empty = 0;
 213                 }
 214         }
 215         if (empty)
 216                 printf_P(PSTR("no log configured\r\n"));
 217 }
 218
 219 /* function called when cmd_log is parsed successfully */
 220 static void cmd_log_parsed(void * parsed_result, void * data)
 221 {
 222         struct cmd_log_result *res = (struct cmd_log_result *) parsed_result;
 223
 224         if (!strcmp_P(res->arg1, PSTR("level"))) {
 225                 xbeeboard.log_level = res->arg2;
 226         }
 227
 228         /* else it is a show */
 229         cmd_log_do_show();
 230 }
 231
 232 prog_char str_log_arg0[] = "log";
 233 parse_pgm_token_string_t cmd_log_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg0, str_log_arg0);
 234 prog_char str_log_arg1[] = "level";
 235 parse_pgm_token_string_t cmd_log_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1);
 236 parse_pgm_token_num_t cmd_log_arg2 = TOKEN_NUM_INITIALIZER(struct cmd_log_result, arg2, INT8);
 237
 238 prog_char help_log[] = "Set log options: level (0 -> 5)";
 239 parse_pgm_inst_t cmd_log = {
 240         .f = cmd_log_parsed,  /* function to call */
 241         .data = NULL,      /* 2nd arg of func */
 242         .help_str = help_log,
 243         .tokens = {        /* token list, NULL terminated */
 244                 (prog_void *)&cmd_log_arg0,
 245                 (prog_void *)&cmd_log_arg1,
 246                 (prog_void *)&cmd_log_arg2,
 247                 NULL,
 248         },
 249 };
 250
 251 prog_char str_log_arg1_show[] = "show";
 252 parse_pgm_token_string_t cmd_log_arg1_show = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1_show);
 253
 254 prog_char help_log_show[] = "Show configured logs";
 255 parse_pgm_inst_t cmd_log_show = {
 256         .f = cmd_log_parsed,  /* function to call */
 257         .data = NULL,      /* 2nd arg of func */
 258         .help_str = help_log_show,
 259         .tokens = {        /* token list, NULL terminated */
 260                 (prog_void *)&cmd_log_arg0,
 261                 (prog_void *)&cmd_log_arg1_show,
 262                 NULL,
 263         },
 264 };
 265
 266 /* this structure is filled when cmd_log is parsed successfully */
 267 struct cmd_log_type_result {
 268         fixed_string_t arg0;
 269         fixed_string_t arg1;
 270         fixed_string_t arg2;
 271         fixed_string_t arg3;
 272 };
 273
 274 /* function called when cmd_log is parsed successfully */
 275 static void cmd_log_type_parsed(void * parsed_result, void * data)
 276 {
 277         struct cmd_log_type_result *res = (struct cmd_log_type_result *) parsed_result;
 278         uint8_t lognum;
 279         uint8_t i;
 280
 281         lognum = log_name2num(res->arg2);
 282         if (lognum == 0) {
 283                 printf_P(PSTR("Cannot find log num\r\n"));
 284                 return;
 285         }
 286
 287         if (!strcmp_P(res->arg3, PSTR("on"))) {
 288                 for (i=0; i<NB_LOGS; i++) {
 289                         if (xbeeboard.logs[i] == lognum) {
 290                                 printf_P(PSTR("Already on\r\n"));
 291                                 return;
 292                         }
 293                 }
 294                 for (i=0; i<NB_LOGS; i++) {
 295                         if (xbeeboard.logs[i] == 0) {
 296                                 xbeeboard.logs[i] = lognum;
 297                                 break;
 298                         }
 299                 }
 300                 if (i==NB_LOGS) {
 301                         printf_P(PSTR("no more room\r\n"));
 302                 }
 303         }
 304         else if (!strcmp_P(res->arg3, PSTR("off"))) {
 305                 for (i=0; i<NB_LOGS; i++) {
 306                         if (xbeeboard.logs[i] == lognum) {
 307                                 xbeeboard.logs[i] = 0;
 308                                 break;
 309                         }
 310                 }
 311                 if (i==NB_LOGS) {
 312                         printf_P(PSTR("already off\r\n"));
 313                 }
 314         }
 315         cmd_log_do_show();
 316 }
 317
 318 prog_char str_log_arg1_type[] = "type";
 319 parse_pgm_token_string_t cmd_log_arg1_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg1, str_log_arg1_type);
 320 /* keep it sync with log_name_and_num above */
 321 prog_char str_log_arg2_type[] = "uart#rs#servo#traj#i2c#oa#strat#i2cproto#ext#sensor#bd#cs";
 322 parse_pgm_token_string_t cmd_log_arg2_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg2, str_log_arg2_type);
 323 prog_char str_log_arg3[] = "on#off";
 324 parse_pgm_token_string_t cmd_log_arg3 = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg3, str_log_arg3);
 325
 326 prog_char help_log_type[] = "Set log type";
 327 parse_pgm_inst_t cmd_log_type = {
 328         .f = cmd_log_type_parsed,  /* function to call */
 329         .data = NULL,      /* 2nd arg of func */
 330         .help_str = help_log_type,
 331         .tokens = {        /* token list, NULL terminated */
 332                 (prog_void *)&cmd_log_arg0,
 333                 (prog_void *)&cmd_log_arg1_type,
 334                 (prog_void *)&cmd_log_arg2_type,
 335                 (prog_void *)&cmd_log_arg3,
 336                 NULL,
 337         },
 338 };
 339
 340
 341 /**********************************************************/
 342 /* Stack_Space */
 343
 344 /* this structure is filled when cmd_stack_space is parsed successfully */
 345 struct cmd_stack_space_result {
 346         fixed_string_t arg0;
 347 };
 348
 349 /* function called when cmd_stack_space is parsed successfully */
 350 static void cmd_stack_space_parsed(void *parsed_result, void *data)
 351 {
 352 #ifdef HOST_VERSION
 353         printf("not implemented\n");
 354 #else
 355         printf("res stack: %d\r\n", min_stack_space_available());
 356 #endif
 357 }
 358
 359 prog_char str_stack_space_arg0[] = "stack_space";
 360 parse_pgm_token_string_t cmd_stack_space_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_stack_space_result, arg0, str_stack_space_arg0);
 361
 362 prog_char help_stack_space[] = "Display remaining stack space";
 363 parse_pgm_inst_t cmd_stack_space = {
 364         .f = cmd_stack_space_parsed,  /* function to call */
 365         .data = NULL,      /* 2nd arg of func */
 366         .help_str = help_stack_space,
 367         .tokens = {        /* token list, NULL terminated */
 368                 (prog_void *)&cmd_stack_space_arg0,
 369                 NULL,
 370         },
 371 };