remove mainloop callout manager (all is handled under intr)
[protos/xbee-avr.git] / 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
33 #include <rdline.h>
34 #include <parse.h>
35 #include <parse_string.h>
36 #include <parse_num.h>
37
38 #include <diagnostic.h>
39
40 #include "callout.h"
41 #include "main.h"
42 #include "cmdline.h"
43
44 /**********************************************************/
45 /* Reset */
46
47 /* this structure is filled when cmd_reset is parsed successfully */
48 struct cmd_reset_result {
49         fixed_string_t arg0;
50 };
51
52 /* function called when cmd_reset is parsed successfully */
53 static void cmd_reset_parsed(void * parsed_result, void * data)
54 {
55         (void)parsed_result;
56         (void)data;
57 #ifdef HOST_VERSION
58         hostsim_exit();
59 #endif
60         reset();
61 }
62
63 const char PROGMEM str_reset_arg0[] = "reset";
64 const parse_token_string_t PROGMEM cmd_reset_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_reset_result, arg0, str_reset_arg0);
65
66 const char PROGMEM help_reset[] = "Reset the board";
67 const parse_inst_t PROGMEM cmd_reset = {
68         .f = cmd_reset_parsed,  /* function to call */
69         .data = NULL,      /* 2nd arg of func */
70         .help_str = help_reset,
71         .tokens = {        /* token list, NULL terminated */
72                 (PGM_P)&cmd_reset_arg0,
73                 NULL,
74         },
75 };
76
77 /**********************************************************/
78 /* Bootloader */
79
80 /* this structure is filled when cmd_bootloader is parsed successfully */
81 struct cmd_bootloader_result {
82         fixed_string_t arg0;
83 };
84
85 /* function called when cmd_bootloader is parsed successfully */
86 static void cmd_bootloader_parsed(void *parsed_result, void *data)
87 {
88         (void)parsed_result;
89         (void)data;
90 #ifndef HOST_VERSION
91         bootloader();
92 #else
93         printf("not implemented\n");
94 #endif
95 }
96
97 const char PROGMEM str_bootloader_arg0[] = "bootloader";
98 const parse_token_string_t PROGMEM cmd_bootloader_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_bootloader_result, arg0, str_bootloader_arg0);
99
100 const char PROGMEM help_bootloader[] = "Launch the bootloader";
101 const parse_inst_t PROGMEM 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                 (PGM_P)&cmd_bootloader_arg0,
107                 NULL,
108         },
109 };
110
111 /**********************************************************/
112 /* Callout show */
113
114 /* this structure is filled when cmd_callout is parsed successfully */
115 struct cmd_callout_result {
116         fixed_string_t arg0;
117         fixed_string_t arg1;
118 };
119
120 /* function called when cmd_callout is parsed successfully */
121 static void cmd_callout_parsed(void *parsed_result, void *data)
122 {
123         (void)parsed_result;
124         (void)data;
125         callout_dump_stats(&xbeeboard.intr_cm);
126 }
127
128 const char PROGMEM str_callout_arg0[] = "callout";
129 const parse_token_string_t PROGMEM cmd_callout_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_callout_result, arg0, str_callout_arg0);
130 const char PROGMEM str_callout_arg1[] = "show";
131 const parse_token_string_t PROGMEM cmd_callout_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_callout_result, arg1, str_callout_arg1);
132
133 const char PROGMEM help_callout[] = "Show callout events";
134 const parse_inst_t PROGMEM cmd_callout = {
135         .f = cmd_callout_parsed,  /* function to call */
136         .data = NULL,      /* 2nd arg of func */
137         .help_str = help_callout,
138         .tokens = {        /* token list, NULL terminated */
139                 (PGM_P)&cmd_callout_arg0,
140                 (PGM_P)&cmd_callout_arg1,
141                 NULL,
142         },
143 };
144
145 /**********************************************************/
146 /* Log */
147
148 /* this structure is filled when cmd_log is parsed successfully */
149 struct cmd_log_result {
150         fixed_string_t arg0;
151         fixed_string_t arg1;
152         uint8_t arg2;
153         fixed_string_t arg3;
154 };
155
156 /* keep it sync with string choice */
157 static const char PROGMEM uart_log[] = "uart";
158 static const char PROGMEM i2c_log[] = "i2c";
159 static const char PROGMEM default_log[] = "default";
160
161 struct log_name_and_num {
162         const char *name;
163         uint8_t num;
164 };
165
166 static const struct log_name_and_num log_name_and_num[] = {
167         { uart_log, E_UART },
168         { i2c_log, E_I2C },
169         { default_log, E_USER_DEFAULT },
170 };
171
172 static uint8_t
173 log_name2num(const char * s)
174 {
175         uint8_t i;
176
177         for (i=0; i<sizeof(log_name_and_num)/sizeof(struct log_name_and_num); i++) {
178                 if (!strcmp_P(s, log_name_and_num[i].name)) {
179                         return log_name_and_num[i].num;
180                 }
181         }
182         return 0;
183 }
184
185 const char *
186 log_num2name(uint8_t num)
187 {
188         uint8_t i;
189
190         for (i=0; i<sizeof(log_name_and_num)/sizeof(struct log_name_and_num); i++) {
191                 if (num ==  log_name_and_num[i].num) {
192                         return log_name_and_num[i].name;
193                 }
194         }
195         return NULL;
196 }
197
198 /* function called when cmd_log is parsed successfully */
199 static void cmd_log_do_show(void)
200 {
201         uint8_t i, empty=1;
202         const char *name;
203
204         printf_P(PSTR("log level is %d\r\n"), xbeeboard.log_level);
205         for (i=0; i<NB_LOGS; i++) {
206                 name = log_num2name(xbeeboard.logs[i]);
207                 if (name) {
208 #ifdef HOST_VERSION
209                         printf_P(PSTR("log type %s is on\r\n"), name);
210 #else
211                         printf_P(PSTR("log type %S is on\r\n"), name);
212 #endif
213                         empty = 0;
214                 }
215         }
216         if (empty)
217                 printf_P(PSTR("no log configured\r\n"));
218 }
219
220 /* function called when cmd_log is parsed successfully */
221 static void cmd_log_parsed(void * parsed_result, void *data)
222 {
223         struct cmd_log_result *res = (struct cmd_log_result *) parsed_result;
224
225         (void)data;
226         if (!strcmp_P(res->arg1, PSTR("level"))) {
227                 xbeeboard.log_level = res->arg2;
228         }
229
230         /* else it is a show */
231         cmd_log_do_show();
232 }
233
234 const char PROGMEM str_log_arg0[] = "log";
235 const parse_token_string_t PROGMEM cmd_log_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg0, str_log_arg0);
236 const char PROGMEM str_log_arg1[] = "level";
237 const parse_token_string_t PROGMEM cmd_log_arg1 = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1);
238 const parse_token_num_t PROGMEM cmd_log_arg2 = TOKEN_NUM_INITIALIZER(struct cmd_log_result, arg2, INT8);
239
240 const char PROGMEM help_log[] = "Set log options: level (0 -> 5)";
241 const parse_inst_t PROGMEM cmd_log = {
242         .f = cmd_log_parsed,  /* function to call */
243         .data = NULL,      /* 2nd arg of func */
244         .help_str = help_log,
245         .tokens = {        /* token list, NULL terminated */
246                 (PGM_P)&cmd_log_arg0,
247                 (PGM_P)&cmd_log_arg1,
248                 (PGM_P)&cmd_log_arg2,
249                 NULL,
250         },
251 };
252
253 const char PROGMEM str_log_arg1_show[] = "show";
254 const parse_token_string_t PROGMEM cmd_log_arg1_show = TOKEN_STRING_INITIALIZER(struct cmd_log_result, arg1, str_log_arg1_show);
255
256 const char PROGMEM help_log_show[] = "Show configured logs";
257 const parse_inst_t PROGMEM cmd_log_show = {
258         .f = cmd_log_parsed,  /* function to call */
259         .data = NULL,      /* 2nd arg of func */
260         .help_str = help_log_show,
261         .tokens = {        /* token list, NULL terminated */
262                 (PGM_P)&cmd_log_arg0,
263                 (PGM_P)&cmd_log_arg1_show,
264                 NULL,
265         },
266 };
267
268 /* this structure is filled when cmd_log is parsed successfully */
269 struct cmd_log_type_result {
270         fixed_string_t arg0;
271         fixed_string_t arg1;
272         fixed_string_t arg2;
273         fixed_string_t arg3;
274 };
275
276 /* function called when cmd_log is parsed successfully */
277 static void cmd_log_type_parsed(void * parsed_result, void *data)
278 {
279         struct cmd_log_type_result *res = (struct cmd_log_type_result *) parsed_result;
280         uint8_t lognum;
281         uint8_t i;
282
283         (void)data;
284
285         lognum = log_name2num(res->arg2);
286         if (lognum == 0) {
287                 printf_P(PSTR("Cannot find log num\r\n"));
288                 return;
289         }
290
291         if (!strcmp_P(res->arg3, PSTR("on"))) {
292                 for (i=0; i<NB_LOGS; i++) {
293                         if (xbeeboard.logs[i] == lognum) {
294                                 printf_P(PSTR("Already on\r\n"));
295                                 return;
296                         }
297                 }
298                 for (i=0; i<NB_LOGS; i++) {
299                         if (xbeeboard.logs[i] == 0) {
300                                 xbeeboard.logs[i] = lognum;
301                                 break;
302                         }
303                 }
304                 if (i==NB_LOGS) {
305                         printf_P(PSTR("no more room\r\n"));
306                 }
307         }
308         else if (!strcmp_P(res->arg3, PSTR("off"))) {
309                 for (i=0; i<NB_LOGS; i++) {
310                         if (xbeeboard.logs[i] == lognum) {
311                                 xbeeboard.logs[i] = 0;
312                                 break;
313                         }
314                 }
315                 if (i==NB_LOGS) {
316                         printf_P(PSTR("already off\r\n"));
317                 }
318         }
319         cmd_log_do_show();
320 }
321
322 const char PROGMEM str_log_arg1_type[] = "type";
323 const parse_token_string_t PROGMEM cmd_log_arg1_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg1, str_log_arg1_type);
324 /* keep it sync with log_name_and_num above */
325 const char PROGMEM str_log_arg2_type[] = "uart#rs#servo#traj#i2c#oa#strat#i2cproto#ext#sensor#bd#cs";
326 const parse_token_string_t PROGMEM cmd_log_arg2_type = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg2, str_log_arg2_type);
327 const char PROGMEM str_log_arg3[] = "on#off";
328 const parse_token_string_t PROGMEM cmd_log_arg3 = TOKEN_STRING_INITIALIZER(struct cmd_log_type_result, arg3, str_log_arg3);
329
330 const char PROGMEM help_log_type[] = "Set log type";
331 const parse_inst_t PROGMEM cmd_log_type = {
332         .f = cmd_log_type_parsed,  /* function to call */
333         .data = NULL,      /* 2nd arg of func */
334         .help_str = help_log_type,
335         .tokens = {        /* token list, NULL terminated */
336                 (PGM_P)&cmd_log_arg0,
337                 (PGM_P)&cmd_log_arg1_type,
338                 (PGM_P)&cmd_log_arg2_type,
339                 (PGM_P)&cmd_log_arg3,
340                 NULL,
341         },
342 };
343
344
345 /**********************************************************/
346 /* Stack_Space */
347
348 /* this structure is filled when cmd_stack_space is parsed successfully */
349 struct cmd_stack_space_result {
350         fixed_string_t arg0;
351 };
352
353 /* function called when cmd_stack_space is parsed successfully */
354 static void cmd_stack_space_parsed(void *parsed_result, void *data)
355 {
356         (void)parsed_result;
357         (void)data;
358 #ifdef HOST_VERSION
359         printf("not implemented\n");
360 #else
361         printf("res stack: %d\r\n", min_stack_space_available());
362 #endif
363 }
364
365 const char PROGMEM str_stack_space_arg0[] = "stack_space";
366 const parse_token_string_t PROGMEM cmd_stack_space_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_stack_space_result, arg0, str_stack_space_arg0);
367
368 const char PROGMEM help_stack_space[] = "Display remaining stack space";
369 const parse_inst_t PROGMEM cmd_stack_space = {
370         .f = cmd_stack_space_parsed,  /* function to call */
371         .data = NULL,      /* 2nd arg of func */
372         .help_str = help_stack_space,
373         .tokens = {        /* token list, NULL terminated */
374                 (PGM_P)&cmd_stack_space_arg0,
375                 NULL,
376         },
377 };