add cksum
[aversive.git] / projects / microb2010 / mechboard / commands_cs.c
1 /*
2  *  Copyright Droids Corporation (2008)
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_cs.c,v 1.2 2009-04-07 20:03:48 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
30 #include <ax12.h>
31 #include <uart.h>
32 #include <pwm_ng.h>
33 #include <time.h>
34
35 #include <pid.h>
36 #include <quadramp.h>
37 #include <control_system_manager.h>
38 #include <blocking_detection_manager.h>
39
40 #include <rdline.h>
41 #include <parse.h>
42 #include <parse_string.h>
43 #include <parse_num.h>
44
45 #include "main.h"
46 #include "cs.h"
47 #include "cmdline.h"
48
49 struct csb_list {
50         const prog_char *name;
51         struct cs_block *csb;
52 };
53
54 prog_char csb_left_arm_str[] = "left_arm";
55 prog_char csb_right_arm_str[] = "right_arm";
56 struct csb_list csb_list[] = {
57         { .name = csb_left_arm_str, .csb = &mechboard.left_arm },
58         { .name = csb_right_arm_str, .csb = &mechboard.right_arm },
59 };
60
61 struct cmd_cs_result {
62         fixed_string_t cmdname;
63         fixed_string_t csname;
64 };
65
66 /* token to be used for all cs-related commands */
67 prog_char str_csb_name[] = "left_arm#right_arm";
68 parse_pgm_token_string_t cmd_csb_name_tok = TOKEN_STRING_INITIALIZER(struct cmd_cs_result, csname, str_csb_name);
69
70 struct cs_block *cs_from_name(const char *name)
71 {
72         unsigned int i;
73
74         for (i=0; i<(sizeof(csb_list)/sizeof(*csb_list)); i++) {
75                 if (!strcmp_P(name, csb_list[i].name))
76                         return csb_list[i].csb;
77         }
78         return NULL;
79 }
80                 
81 /**********************************************************/
82 /* Gains for control system */
83
84 /* this structure is filled when cmd_gain is parsed successfully */
85 struct cmd_gain_result {
86         struct cmd_cs_result cs;
87         int16_t p;
88         int16_t i;
89         int16_t d;
90 };
91
92 /* function called when cmd_gain is parsed successfully */
93 static void cmd_gain_parsed(void * parsed_result, void *show)
94 {
95         struct cmd_gain_result *res = parsed_result;
96         struct cs_block *csb;
97
98         csb = cs_from_name(res->cs.csname);
99         if (csb == NULL) {
100                 printf_P(PSTR("null csb\r\n"));
101                 return;
102         }
103
104         if (!show) 
105                 pid_set_gains(&csb->pid, res->p, res->i, res->d);
106
107         printf_P(PSTR("%s %s %d %d %d\r\n"),
108                  res->cs.cmdname,
109                  res->cs.csname,
110                  pid_get_gain_P(&csb->pid),
111                  pid_get_gain_I(&csb->pid),
112                  pid_get_gain_D(&csb->pid));
113 }
114
115 prog_char str_gain_arg0[] = "gain";
116 parse_pgm_token_string_t cmd_gain_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_gain_result, cs.cmdname, str_gain_arg0);
117 parse_pgm_token_num_t cmd_gain_p = TOKEN_NUM_INITIALIZER(struct cmd_gain_result, p, INT16);
118 parse_pgm_token_num_t cmd_gain_i = TOKEN_NUM_INITIALIZER(struct cmd_gain_result, i, INT16);
119 parse_pgm_token_num_t cmd_gain_d = TOKEN_NUM_INITIALIZER(struct cmd_gain_result, d, INT16);
120
121 prog_char help_gain[] = "Set gain values for PID";
122 parse_pgm_inst_t cmd_gain = {
123         .f = cmd_gain_parsed,  /* function to call */
124         .data = NULL,      /* 2nd arg of func */
125         .help_str = help_gain,
126         .tokens = {        /* token list, NULL terminated */
127                 (prog_void *)&cmd_gain_arg0, 
128                 (prog_void *)&cmd_csb_name_tok, 
129                 (prog_void *)&cmd_gain_p, 
130                 (prog_void *)&cmd_gain_i, 
131                 (prog_void *)&cmd_gain_d, 
132                 NULL,
133         },
134 };
135
136 /* show */
137 /* this structure is filled when cmd_gain is parsed successfully */
138 struct cmd_gain_show_result {
139         struct cmd_cs_result cs;
140         fixed_string_t show;
141 };
142
143 prog_char str_gain_show_arg[] = "show";
144 parse_pgm_token_string_t cmd_gain_show_arg = TOKEN_STRING_INITIALIZER(struct cmd_gain_show_result, show, str_gain_show_arg);
145
146 prog_char help_gain_show[] = "Show gain values for PID";
147 parse_pgm_inst_t cmd_gain_show = {
148         .f = cmd_gain_parsed,  /* function to call */
149         .data = (void *)1,      /* 2nd arg of func */
150         .help_str = help_gain_show,
151         .tokens = {        /* token list, NULL terminated */
152                 (prog_void *)&cmd_gain_arg0, 
153                 (prog_void *)&cmd_csb_name_tok, 
154                 (prog_void *)&cmd_gain_show_arg,
155                 NULL,
156         },
157 };
158
159 /**********************************************************/
160 /* Speeds for control system */
161
162 /* this structure is filled when cmd_speed is parsed successfully */
163 struct cmd_speed_result {
164         struct cmd_cs_result cs;
165         uint16_t s;
166 };
167
168 /* function called when cmd_speed is parsed successfully */
169 static void cmd_speed_parsed(void *parsed_result, __attribute__((unused)) void *show)
170 {
171         struct cmd_speed_result * res = parsed_result;
172         
173         struct cs_block *csb;
174
175         csb = cs_from_name(res->cs.csname);
176         if (csb == NULL) {
177                 printf_P(PSTR("null csb\r\n"));
178                 return;
179         }
180
181 #if notyet
182         if (!show) 
183                 ramp_set_vars(&csb->ramp, res->s, res->s); /* set speed */
184
185         printf_P(PSTR("%s %lu\r\n"), 
186                  res->cs.csname,
187                  ext.r_b.var_pos);
188 #else
189         printf_P(PSTR("TODO\r\n"));
190 #endif
191 }
192
193 prog_char str_speed_arg0[] = "speed";
194 parse_pgm_token_string_t cmd_speed_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_speed_result, cs.cmdname, str_speed_arg0);
195 parse_pgm_token_num_t cmd_speed_s = TOKEN_NUM_INITIALIZER(struct cmd_speed_result, s, UINT16);
196
197 prog_char help_speed[] = "Set speed values for ramp filter";
198 parse_pgm_inst_t cmd_speed = {
199         .f = cmd_speed_parsed,  /* function to call */
200         .data = NULL,      /* 2nd arg of func */
201         .help_str = help_speed,
202         .tokens = {        /* token list, NULL terminated */
203                 (prog_void *)&cmd_speed_arg0, 
204                 (prog_void *)&cmd_csb_name_tok, 
205                 (prog_void *)&cmd_speed_s, 
206                 NULL,
207         },
208 };
209
210 /* show */
211 struct cmd_speed_show_result {
212         struct cmd_cs_result cs;
213         fixed_string_t show;
214 };
215
216 prog_char str_speed_show_arg[] = "show";
217 parse_pgm_token_string_t cmd_speed_show_arg = TOKEN_STRING_INITIALIZER(struct cmd_speed_show_result, show, str_speed_show_arg);
218
219 prog_char help_speed_show[] = "Show speed values for ramp filter";
220 parse_pgm_inst_t cmd_speed_show = {
221         .f = cmd_speed_parsed,  /* function to call */
222         .data = (void *)1,      /* 2nd arg of func */
223         .help_str = help_speed_show,
224         .tokens = {        /* token list, NULL terminated */
225                 (prog_void *)&cmd_speed_arg0, 
226                 (prog_void *)&cmd_csb_name_tok, 
227                 (prog_void *)&cmd_speed_show_arg,
228                 NULL,
229         },
230 };
231
232 /**********************************************************/
233 /* Derivate_Filters for control system */
234
235 /* this structure is filled when cmd_derivate_filter is parsed successfully */
236 struct cmd_derivate_filter_result {
237         struct cmd_cs_result cs;
238         uint8_t size;
239 };
240
241 /* function called when cmd_derivate_filter is parsed successfully */
242 static void cmd_derivate_filter_parsed(void *parsed_result, void *show)
243 {
244         struct cmd_derivate_filter_result * res = parsed_result;
245         struct cs_block *csb;
246
247         csb = cs_from_name(res->cs.csname);
248         if (csb == NULL) {
249                 printf_P(PSTR("null csb\r\n"));
250                 return;
251         }
252
253         if (!show) 
254                 pid_set_derivate_filter(&csb->pid, res->size);
255
256         printf_P(PSTR("%s %s %u\r\n"), 
257                  res->cs.cmdname,
258                  res->cs.csname,
259                  pid_get_derivate_filter(&csb->pid));
260 }
261
262 prog_char str_derivate_filter_arg0[] = "derivate_filter";
263 parse_pgm_token_string_t cmd_derivate_filter_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_derivate_filter_result, cs.cmdname, str_derivate_filter_arg0);
264 parse_pgm_token_num_t cmd_derivate_filter_size = TOKEN_NUM_INITIALIZER(struct cmd_derivate_filter_result, size, UINT32);
265
266 prog_char help_derivate_filter[] = "Set derivate_filter values for PID (in, I, out)";
267 parse_pgm_inst_t cmd_derivate_filter = {
268         .f = cmd_derivate_filter_parsed,  /* function to call */
269         .data = (void *)1,      /* 2nd arg of func */
270         .help_str = help_derivate_filter,
271         .tokens = {        /* token list, NULL terminated */
272                 (prog_void *)&cmd_derivate_filter_arg0, 
273                 (prog_void *)&cmd_csb_name_tok, 
274                 (prog_void *)&cmd_derivate_filter_size, 
275                 NULL,
276         },
277 };
278
279 /* show */
280
281 struct cmd_derivate_filter_show_result {
282         struct cmd_cs_result cs;
283         fixed_string_t show;
284 };
285
286 prog_char str_derivate_filter_show_arg[] = "show";
287 parse_pgm_token_string_t cmd_derivate_filter_show_arg = TOKEN_STRING_INITIALIZER(struct cmd_derivate_filter_show_result, show, str_derivate_filter_show_arg);
288
289 prog_char help_derivate_filter_show[] = "Show derivate_filter values for PID";
290 parse_pgm_inst_t cmd_derivate_filter_show = {
291         .f = cmd_derivate_filter_parsed,  /* function to call */
292         .data = NULL,      /* 2nd arg of func */
293         .help_str = help_derivate_filter_show,
294         .tokens = {        /* token list, NULL terminated */
295                 (prog_void *)&cmd_derivate_filter_arg0, 
296                 (prog_void *)&cmd_csb_name_tok, 
297                 (prog_void *)&cmd_derivate_filter_show_arg,
298                 NULL,
299         },
300 };
301
302
303 /**********************************************************/
304 /* Consign for control system */
305
306 /* this structure is filled when cmd_consign is parsed successfully */
307 struct cmd_consign_result {
308         struct cmd_cs_result cs;
309         int32_t p;
310 };
311
312 /* function called when cmd_consign is parsed successfully */
313 static void cmd_consign_parsed(void * parsed_result, __attribute__((unused)) void *data)
314 {
315         struct cmd_consign_result * res = parsed_result;
316         struct cs_block *csb;
317
318         csb = cs_from_name(res->cs.csname);
319         if (csb == NULL) {
320                 printf_P(PSTR("null csb\r\n"));
321                 return;
322         }
323
324         cs_set_consign(&csb->cs, res->p);
325 }
326
327 prog_char str_consign_arg0[] = "consign";
328 parse_pgm_token_string_t cmd_consign_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_consign_result, cs.cmdname, str_consign_arg0);
329 parse_pgm_token_num_t cmd_consign_p = TOKEN_NUM_INITIALIZER(struct cmd_consign_result, p, INT32);
330
331 prog_char help_consign[] = "Set consign value";
332 parse_pgm_inst_t cmd_consign = {
333         .f = cmd_consign_parsed,  /* function to call */
334         .data = NULL,      /* 2nd arg of func */
335         .help_str = help_consign,
336         .tokens = {        /* token list, NULL terminated */
337                 (prog_void *)&cmd_consign_arg0, 
338                 (prog_void *)&cmd_csb_name_tok, 
339                 (prog_void *)&cmd_consign_p, 
340                 NULL,
341         },
342 };
343
344
345 /**********************************************************/
346 /* Maximums for control system */
347
348 /* this structure is filled when cmd_maximum is parsed successfully */
349 struct cmd_maximum_result {
350         struct cmd_cs_result cs;
351         uint32_t in;
352         uint32_t i;
353         uint32_t out;
354 };
355
356 /* function called when cmd_maximum is parsed successfully */
357 static void cmd_maximum_parsed(void *parsed_result, void *show)
358 {
359         struct cmd_maximum_result * res = parsed_result;
360         
361         struct cs_block *csb;
362
363         csb = cs_from_name(res->cs.csname);
364         if (csb == NULL) {
365                 printf_P(PSTR("null csb\r\n"));
366                 return;
367         }
368
369         if (!show)
370                 pid_set_maximums(&csb->pid, res->in, res->i, res->out);
371
372         printf_P(PSTR("maximum %s %lu %lu %lu\r\n"), 
373                  res->cs.csname,
374                  pid_get_max_in(&csb->pid),
375                  pid_get_max_I(&csb->pid),
376                  pid_get_max_out(&csb->pid));
377 }
378
379 prog_char str_maximum_arg0[] = "maximum";
380 parse_pgm_token_string_t cmd_maximum_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_maximum_result, cs.cmdname, str_maximum_arg0);
381 parse_pgm_token_num_t cmd_maximum_in = TOKEN_NUM_INITIALIZER(struct cmd_maximum_result, in, UINT32);
382 parse_pgm_token_num_t cmd_maximum_i = TOKEN_NUM_INITIALIZER(struct cmd_maximum_result, i, UINT32);
383 parse_pgm_token_num_t cmd_maximum_out = TOKEN_NUM_INITIALIZER(struct cmd_maximum_result, out, UINT32);
384
385 prog_char help_maximum[] = "Set maximum values for PID (in, I, out)";
386 parse_pgm_inst_t cmd_maximum = {
387         .f = cmd_maximum_parsed,  /* function to call */
388         .data = NULL,      /* 2nd arg of func */
389         .help_str = help_maximum,
390         .tokens = {        /* token list, NULL terminated */
391                 (prog_void *)&cmd_maximum_arg0, 
392                 (prog_void *)&cmd_csb_name_tok, 
393                 (prog_void *)&cmd_maximum_in, 
394                 (prog_void *)&cmd_maximum_i, 
395                 (prog_void *)&cmd_maximum_out, 
396                 NULL,
397         },
398 };
399
400 /* show */
401
402 /* this structure is filled when cmd_maximum is parsed successfully */
403 struct cmd_maximum_show_result {
404         struct cmd_cs_result cs;
405         fixed_string_t show;
406 };
407 prog_char str_maximum_show_arg[] = "show";
408 parse_pgm_token_string_t cmd_maximum_show_arg = TOKEN_STRING_INITIALIZER(struct cmd_maximum_show_result, show, str_maximum_show_arg);
409
410 prog_char help_maximum_show[] = "Show maximum values for PID";
411 parse_pgm_inst_t cmd_maximum_show = {
412         .f = cmd_maximum_parsed,  /* function to call */
413         .data = (void *)1,      /* 2nd arg of func */
414         .help_str = help_maximum_show,
415         .tokens = {        /* token list, NULL terminated */
416                 (prog_void *)&cmd_maximum_arg0, 
417                 (prog_void *)&cmd_csb_name_tok, 
418                 (prog_void *)&cmd_maximum_show_arg,
419                 NULL,
420         },
421 };
422
423 /**********************************************************/
424 /* Quadramp for control system */
425
426 /* this structure is filled when cmd_quadramp is parsed successfully */
427 struct cmd_quadramp_result {
428         struct cmd_cs_result cs;
429         uint32_t ap;
430         uint32_t an;
431         uint32_t sp;
432         uint32_t sn;
433 };
434
435 /* function called when cmd_quadramp is parsed successfully */
436 static void cmd_quadramp_parsed(void *parsed_result, void *show)
437 {
438         struct cmd_quadramp_result * res = parsed_result;
439         
440         struct cs_block *csb;
441
442         csb = cs_from_name(res->cs.csname);
443         if (csb == NULL) {
444                 printf_P(PSTR("null csb\r\n"));
445                 return;
446         }
447
448         if (!show)  {
449                 quadramp_set_1st_order_vars(&csb->qr, res->sp, res->sn);
450                 quadramp_set_2nd_order_vars(&csb->qr, res->ap, res->an);
451         }
452
453         printf_P(PSTR("quadramp %s %ld %ld %ld %ld\r\n"), 
454                  res->cs.csname,
455                  csb->qr.var_2nd_ord_pos,
456                  csb->qr.var_2nd_ord_neg,
457                  csb->qr.var_1st_ord_pos,
458                  csb->qr.var_1st_ord_neg);
459 }
460
461 prog_char str_quadramp_arg0[] = "quadramp";
462 parse_pgm_token_string_t cmd_quadramp_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_quadramp_result, cs.cmdname, str_quadramp_arg0);
463 parse_pgm_token_num_t cmd_quadramp_ap = TOKEN_NUM_INITIALIZER(struct cmd_quadramp_result, ap, UINT32);
464 parse_pgm_token_num_t cmd_quadramp_an = TOKEN_NUM_INITIALIZER(struct cmd_quadramp_result, an, UINT32);
465 parse_pgm_token_num_t cmd_quadramp_sp = TOKEN_NUM_INITIALIZER(struct cmd_quadramp_result, sp, UINT32);
466 parse_pgm_token_num_t cmd_quadramp_sn = TOKEN_NUM_INITIALIZER(struct cmd_quadramp_result, sn, UINT32);
467
468 prog_char help_quadramp[] = "Set quadramp values (acc+, acc-, speed+, speed-)";
469 parse_pgm_inst_t cmd_quadramp = {
470         .f = cmd_quadramp_parsed,  /* function to call */
471         .data = NULL,      /* 2nd arg of func */
472         .help_str = help_quadramp,
473         .tokens = {        /* token list, NULL terminated */
474                 (prog_void *)&cmd_quadramp_arg0, 
475                 (prog_void *)&cmd_csb_name_tok, 
476                 (prog_void *)&cmd_quadramp_ap, 
477                 (prog_void *)&cmd_quadramp_an, 
478                 (prog_void *)&cmd_quadramp_sp, 
479                 (prog_void *)&cmd_quadramp_sn, 
480                 
481                 NULL,
482         },
483 };
484
485 /* show */
486
487 struct cmd_quadramp_show_result {
488         struct cmd_cs_result cs;
489         fixed_string_t show;
490 };
491
492 prog_char str_quadramp_show_arg[] = "show";
493 parse_pgm_token_string_t cmd_quadramp_show_arg = TOKEN_STRING_INITIALIZER(struct cmd_quadramp_show_result, show, str_quadramp_show_arg);
494
495 prog_char help_quadramp_show[] = "Get quadramp values for control system";
496 parse_pgm_inst_t cmd_quadramp_show = {
497         .f = cmd_quadramp_parsed,  /* function to call */
498         .data = (void *)1,      /* 2nd arg of func */
499         .help_str = help_quadramp_show,
500         .tokens = {        /* token list, NULL terminated */
501                 (prog_void *)&cmd_quadramp_arg0, 
502                 (prog_void *)&cmd_csb_name_tok, 
503                 (prog_void *)&cmd_quadramp_show_arg, 
504                 NULL,
505         },
506 };
507
508
509
510 /**********************************************************/
511 /* cs_status show for control system */
512
513 /* this structure is filled when cmd_cs_status is parsed successfully */
514 struct cmd_cs_status_result {
515         struct cmd_cs_result cs;
516         fixed_string_t arg;
517 };
518
519 /* function called when cmd_cs_status is parsed successfully */
520 static void cmd_cs_status_parsed(void *parsed_result, __attribute__((unused)) void *data)
521 {
522         struct cmd_cs_status_result *res = parsed_result;
523         struct cs_block *csb;
524         uint8_t loop = 0;
525         uint8_t print_pid = 0, print_cs = 0;
526         
527         csb = cs_from_name(res->cs.csname);
528         if (csb == NULL) {
529                 printf_P(PSTR("null csb\r\n"));
530                 return;
531         }
532         if (strcmp_P(res->arg, PSTR("on")) == 0) {
533                 csb->on = 1;
534                 printf_P(PSTR("%s is on\r\n"), res->cs.csname);
535                 return;
536         }
537         else if (strcmp_P(res->arg, PSTR("off")) == 0) {
538                 csb->on = 0;
539                 printf_P(PSTR("%s is off\r\n"), res->cs.csname);
540                 return;
541         }
542         else if (strcmp_P(res->arg, PSTR("show")) == 0) {
543                 print_cs = 1;
544         }
545         else if (strcmp_P(res->arg, PSTR("loop_show")) == 0) {
546                 loop = 1;
547                 print_cs = 1;
548         }
549         else if (strcmp_P(res->arg, PSTR("pid_show")) == 0) {
550                 print_pid = 1;
551         }
552         else if (strcmp_P(res->arg, PSTR("pid_loop_show")) == 0) {
553                 print_pid = 1;
554                 loop = 1;
555         }
556
557         printf_P(PSTR("%s cs is %s\r\n"), res->cs.csname, csb->on ? "on":"off");
558         do {
559                 if (print_cs)
560                         dump_cs(res->cs.csname, &csb->cs);
561                 if (print_pid)
562                         dump_pid(res->cs.csname, &csb->pid);
563                 wait_ms(100);
564         } while(loop && !cmdline_keypressed());
565 }
566
567 prog_char str_cs_status_arg0[] = "cs_status";
568 parse_pgm_token_string_t cmd_cs_status_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_cs_status_result, cs.cmdname, str_cs_status_arg0);
569 prog_char str_cs_status_arg[] = "pid_show#pid_loop_show#show#loop_show#on#off";
570 parse_pgm_token_string_t cmd_cs_status_arg = TOKEN_STRING_INITIALIZER(struct cmd_cs_status_result, arg, str_cs_status_arg);
571
572 prog_char help_cs_status[] = "Show cs status";
573 parse_pgm_inst_t cmd_cs_status = {
574         .f = cmd_cs_status_parsed,  /* function to call */
575         .data = NULL,      /* 2nd arg of func */
576         .help_str = help_cs_status,
577         .tokens = {        /* token list, NULL terminated */
578                 (prog_void *)&cmd_cs_status_arg0, 
579                 (prog_void *)&cmd_csb_name_tok, 
580                 (prog_void *)&cmd_cs_status_arg, 
581                 NULL,
582         },
583 };
584
585
586 /**********************************************************/
587 /* Blocking_I for control system */
588
589 /* this structure is filled when cmd_blocking_i is parsed successfully */
590 struct cmd_blocking_i_result {
591         struct cmd_cs_result cs;
592         int32_t k1;
593         int32_t k2;
594         uint32_t i;
595         uint16_t cpt;
596 };
597
598 /* function called when cmd_blocking_i is parsed successfully */
599 static void cmd_blocking_i_parsed(void *parsed_result, void *show)
600 {
601         struct cmd_blocking_i_result * res = parsed_result;
602         
603         struct cs_block *csb;
604
605         csb = cs_from_name(res->cs.csname);
606         if (csb == NULL) {
607                 printf_P(PSTR("null csb\r\n"));
608                 return;
609         }
610
611         if (!show)
612                 bd_set_current_thresholds(&csb->bd, res->k1, res->k2,
613                                           res->i, res->cpt);
614
615         printf_P(PSTR("%s %s %ld %ld %ld %d\r\n"), 
616                  res->cs.cmdname,
617                  res->cs.csname,
618                  csb->bd.k1,
619                  csb->bd.k2,
620                  csb->bd.i_thres,
621                  csb->bd.cpt_thres);
622 }
623
624 prog_char str_blocking_i_arg0[] = "blocking";
625 parse_pgm_token_string_t cmd_blocking_i_arg0 = TOKEN_STRING_INITIALIZER(struct cmd_blocking_i_result, cs.cmdname, str_blocking_i_arg0);
626 parse_pgm_token_num_t cmd_blocking_i_k1 = TOKEN_NUM_INITIALIZER(struct cmd_blocking_i_result, k1, INT32);
627 parse_pgm_token_num_t cmd_blocking_i_k2 = TOKEN_NUM_INITIALIZER(struct cmd_blocking_i_result, k2, INT32);
628 parse_pgm_token_num_t cmd_blocking_i_i = TOKEN_NUM_INITIALIZER(struct cmd_blocking_i_result, i, UINT32);
629 parse_pgm_token_num_t cmd_blocking_i_cpt = TOKEN_NUM_INITIALIZER(struct cmd_blocking_i_result, cpt, UINT16);
630
631 prog_char help_blocking_i[] = "Set blocking detection values (k1, k2, i, cpt)";
632 parse_pgm_inst_t cmd_blocking_i = {
633         .f = cmd_blocking_i_parsed,  /* function to call */
634         .data = NULL,      /* 2nd arg of func */
635         .help_str = help_blocking_i,
636         .tokens = {        /* token list, NULL terminated */
637                 (prog_void *)&cmd_blocking_i_arg0, 
638                 (prog_void *)&cmd_csb_name_tok, 
639                 (prog_void *)&cmd_blocking_i_k1, 
640                 (prog_void *)&cmd_blocking_i_k2, 
641                 (prog_void *)&cmd_blocking_i_i, 
642                 (prog_void *)&cmd_blocking_i_cpt,
643                 NULL,
644         },
645 };
646
647 /* show */
648
649 struct cmd_blocking_i_show_result {
650         struct cmd_cs_result cs;
651         fixed_string_t show;
652 };
653
654 prog_char str_blocking_i_show_arg[] = "show";
655 parse_pgm_token_string_t cmd_blocking_i_show_arg = TOKEN_STRING_INITIALIZER(struct cmd_blocking_i_show_result, show, str_blocking_i_show_arg);
656
657 prog_char help_blocking_i_show[] = "Show blocking detection values";
658 parse_pgm_inst_t cmd_blocking_i_show = {
659         .f = cmd_blocking_i_parsed,  /* function to call */
660         .data = (void *)1,      /* 2nd arg of func */
661         .help_str = help_blocking_i_show,
662         .tokens = {        /* token list, NULL terminated */
663                 (prog_void *)&cmd_blocking_i_arg0, 
664                 (prog_void *)&cmd_csb_name_tok, 
665                 (prog_void *)&cmd_blocking_i_show_arg, 
666                 NULL,
667         },
668 };
669
670