src/laser-io/cmd_pxmc.c

   1 /*******************************************************************
   2   Components for embedded applications builded for
   3   laboratory and medical instruments firmware
   4
   5   cmd_stm.c - interconnection of Stepper Motor control
   6               subsystem with RS-232 command processor
   7               used mainly for controller tuning
   8
   9   Copyright (C) 2001 by Pavel Pisa pisa@cmp.felk.cvut.cz
  10             (C) 2002 by PiKRON Ltd. http://www.pikron.com
  11
  12  *******************************************************************/
  13
  14 #include <types.h>
  15 #include <ctype.h>
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <utils.h>
  19 #include <cmd_proc.h>
  20 #include <cpu_def.h>
  21 #include <pxmc.h>
  22
  23 /**
  24  * cmd_opchar_getreg - selects the right axis
  25  *
  26  * pxmc is designed for multi axis motion control, so each axis must be identificated.
  27  * This done by a capital letter. The first axis must be A, the 2nd B, etc.
  28  */
  29 pxmc_state_t *cmd_opchar_getreg(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  30 {
  31   unsigned chan;
  32   pxmc_state_t *mcs;
  33   chan=*param[1]-'A';
  34   if(chan>=pxmc_main_list.pxml_cnt) return NULL;
  35   mcs=pxmc_main_list.pxml_arr[chan];
  36   if(!mcs) return NULL;
  37   return mcs;
  38 }
  39
  40 /**
  41  * cmd_do_reg_go - checks the command format validity and calls pxmc_go.
  42  *
  43  * if pxmc_go returns -1, cmd_do_reg_go returns -1.
  44  */
  45 int cmd_do_reg_go(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  46 {
  47   long val;
  48   pxmc_state_t *mcs;
  49   if(*param[2]!=':') return -CMDERR_OPCHAR;
  50   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
  51   val=atol(param[3])<<PXMC_SUBDIV(mcs);
  52   val=pxmc_go(mcs,val,0,0);
  53   if(val<0)
  54     return val;
  55   return 0;
  56 }
  57
  58
  59 /**
  60  * cmd_do_pwm - checks the command format validity and calls pxmc_set_const_out.
  61  *
  62  */
  63 int cmd_do_pwm(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  64 {
  65   int val;
  66   pxmc_state_t *mcs;
  67   if(*param[2]!=':') return -CMDERR_OPCHAR;
  68   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
  69   val=atoi(param[3]);
  70   pxmc_set_const_out(mcs,val);
  71   return 0;
  72 }
  73
  74 /**
  75  * cmd_do_reg_hh - checks the command format validity and calls pxmc_hh (home hardware).
  76  *
  77  * if pxmc_hh returns -1, cmd_do_reg_hh returns -1.
  78  */
  79 int cmd_do_reg_hh(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  80 {
  81   long val;
  82   pxmc_state_t *mcs;
  83   if(*param[2]!=':') return -CMDERR_OPCHAR;
  84   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
  85   val=pxmc_hh(mcs);
  86   if(val<0)
  87     return val;
  88   return 0;
  89 }
  90
  91
  92 /**
  93  * cmd_do_reg_spd - checks the command format validity and calls pxmc_spd.
  94  *
  95  * if pxmc_spd returns -1, cmd_do_reg_spd returns -1.
  96  */
  97 int cmd_do_reg_spd(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  98 {
  99   long val;
 100   pxmc_state_t *mcs;
 101   if(*param[2]!=':') return -CMDERR_OPCHAR;
 102   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 103   val=atol(param[3]);
 104   val=pxmc_spd(mcs,val,0);
 105   if(val<0)
 106     return val;
 107   return 0;
 108 }
 109
 110 /**
 111  * cmd_do_reg_spdfg - checks the command format validity and calls pxmc_spdfg.
 112  *
 113  * if pxmc_spdfg returns -1, cmd_do_reg_spdfg returns -1.
 114  */
 115 int cmd_do_reg_spdfg(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 116 {
 117   long val;
 118   pxmc_state_t *mcs;
 119   if(*param[2]!=':') return -CMDERR_OPCHAR;
 120   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 121   val=atol(param[3]);
 122   val=pxmc_spdfg(mcs,val,0);
 123   if(val<0)
 124     return val;
 125   return 0;
 126 }
 127
 128 /**
 129  * cmd_do_stop - checks the command format validity and calls pxmc_stop.
 130  *
 131  */
 132 int cmd_do_stop(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 133 {
 134   pxmc_state_t *mcs;
 135   if(*param[2]!=':') return -CMDERR_OPCHAR;
 136   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 137   pxmc_stop(mcs,0);
 138   return 0;
 139 }
 140
 141 /**
 142  * cmd_do_release - checks the command format validity and calls pxmc_set_const_out(mcs,0).
 143  *
 144  */
 145 int cmd_do_release(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 146 {
 147   pxmc_state_t *mcs;
 148   if(*param[2]!=':') return -CMDERR_OPCHAR;
 149   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 150   pxmc_set_const_out(mcs,0);
 151   return 0;
 152 }
 153
 154 /**
 155  * cmd_do_clrerr - checks the command format validity, clears the error flag.
 156  *
 157  * it also stop the rotation calling pxmc_set_const_out(mcs,0)
 158  */
 159 int cmd_do_clrerr(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 160 {
 161   pxmc_state_t *mcs;
 162   if(*param[2]!=':') return -CMDERR_OPCHAR;
 163   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 164   pxmc_set_const_out(mcs,0);
 165   pxmc_clear_flag(mcs,PXMS_ERR_b);
 166   return 0;
 167 }
 168
 169 /**
 170  * cmd_do_zero - checks the command format validity, sets axis position to 0.
 171  *
 172  * it also stop the rotation calling pxmc_set_const_out(mcs,0)
 173  */
 174 int cmd_do_zero(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 175 {
 176   pxmc_state_t *mcs;
 177   if(*param[2]!=':') return -CMDERR_OPCHAR;
 178   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 179   pxmc_set_const_out(mcs,0);
 180   pxmc_axis_set_pos(mcs,0);
 181   return 0;
 182 }
 183
 184 /**
 185  * cmd_do_align - checks the command format validity, sets offset between table and IRC counter to 0 .
 186  *
 187  * it also stop the rotation calling pxmc_set_const_out(mcs,0) and sets axis position to 0.
 188  */
 189 int cmd_do_align(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 190 {
 191   pxmc_state_t *mcs;
 192   if(*param[2]!=':') return -CMDERR_OPCHAR;
 193   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 194   pxmc_set_const_out(mcs,0);
 195   pxmc_axis_set_pos(mcs,0);
 196   mcs->pxms_ptofs=0;
 197   return 0;
 198 }
 199
 200 /**
 201  * cmd_do_reg_rw_pos - read or write function, param is converted in 'long' and shifted
 202  *
 203  * if the command typed is a write function, records the value,
 204  * if it is a read function returns the value asked.
 205  */
 206
 207 int cmd_do_reg_rw_pos(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 208 {
 209   long val;
 210   long *ptr;
 211   int opchar;
 212   pxmc_state_t *mcs;
 213
 214   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 215   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 216   ptr=(long*)((long)des->info[0]+(char*)mcs);
 217   if(opchar==':'){
 218     val=atol(param[3]);
 219     *ptr=val<<PXMC_SUBDIV(mcs);
 220   }else{
 221     return cmd_opchar_replong(cmd_io, param, (*ptr)>>PXMC_SUBDIV(mcs), 0, 0);
 222   }
 223   return 0;
 224 }
 225
 226 /**
 227  * cmd_do_reg_short_val - read or write function, param is converted in 'integer'
 228  *
 229  * if the command typed is a write function, records the value,
 230  * if it is a read function returns the value asked.
 231  */
 232
 233 int cmd_do_reg_short_val(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 234 {
 235   int val;
 236   short *ptr;
 237   int opchar;
 238   pxmc_state_t *mcs;
 239
 240   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 241   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 242   ptr=(short*)((long)des->info[0]+(char*)mcs);
 243   if(opchar==':'){
 244     val=atoi(param[3]);
 245     *ptr=val;
 246   }else{
 247     return cmd_opchar_replong(cmd_io, param, (long)*ptr, 0, 0);
 248   }
 249   return 0;
 250 }
 251
 252 /**
 253  * cmd_do_reg_long_val - read or write function, param is converted in 'long'
 254  *
 255  * if the command typed is a write function, records the value,
 256  * if it is a read function returns the value asked.
 257  */
 258 int cmd_do_reg_long_val(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 259 {
 260   long val;
 261   long *ptr;
 262   int opchar;
 263   pxmc_state_t *mcs;
 264
 265   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 266   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 267   ptr=(long*)((long)des->info[0]+(char*)mcs);
 268   if(opchar==':'){
 269     val=atol(param[3]);
 270     *ptr=val;
 271   }else{
 272     return cmd_opchar_replong(cmd_io, param, (long)*ptr, 0, 0);
 273   }
 274   return 0;
 275 }
 276
 277
 278 /**
 279  * cmd_do_axis_mode - checks the command format and busy flag validity, calls pxmc_axis_mode
 280  *
 281  * if pxmc_axis_mode returns -1, cmd_do_axis_mode returns -1.
 282  */
 283 int cmd_do_axis_mode(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 284 {
 285   int val;
 286   pxmc_state_t *mcs;
 287   if(*param[2]!=':') return -CMDERR_OPCHAR;
 288   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 289   if(mcs->pxms_flg&PXMS_BSY_m) return -CMDERR_BSYREG;
 290   val=atol(param[3]);
 291   val=pxmc_axis_mode(mcs,val);
 292   if(val<0)
 293     return val;
 294   return 0;
 295 }
 296
 297
 298 int cmd_do_regptmod_short_val(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 299 {
 300   int val;
 301   short *ptr;
 302   int opchar;
 303   pxmc_state_t *mcs;
 304
 305   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 306   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 307   ptr=(short*)((long)des->info[0]+(char*)mcs);
 308   if(opchar==':'){
 309     if(mcs->pxms_flg&PXMS_BSY_m) return -CMDERR_BSYREG;
 310     pxmc_set_const_out(mcs,0);
 311     val=atoi(param[3]);
 312     if((val<((long)des->info[1])) || (val>((long)des->info[2])))
 313       return -CMDERR_BADPAR;
 314     *ptr=val;
 315     val=pxmc_axis_mode(mcs,0);
 316     if(val<0)
 317       return val;
 318   }else{
 319     return cmd_opchar_replong(cmd_io, param, (long)*ptr, 0, 0);
 320   }
 321   return 0;
 322 }
 323
 324
 325 /**
 326  * cmd_do_reg_type - no code written, will set controller structure
 327  */
 328 int cmd_do_reg_type(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 329 {
 330   /* should set controller structure */
 331   return 0;
 332 }
 333
 334
 335 /**
 336  * cmd_do_regsfrq - sets or returns smapling frequency
 337  */
 338 #ifdef WITH_SFI_SEL
 339 int cmd_do_regsfrq(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 340 {
 341   int val;
 342   int opchar;
 343
 344   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 345   if(opchar==':'){
 346     val=atoi(param[3]);
 347     return pxmc_sfi_sel(val);
 348   }else{
 349     return cmd_opchar_replong(cmd_io, param, pxmc_get_sfi_hz(NULL), 0, 0);
 350   }
 351   return 0;
 352 }
 353 #endif /* WITH_SFI_SEL */
 354
 355
 356 /* debugging functions */
 357 int cmd_do_reg_dbgset(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 358 {
 359   pxmc_state_t *mcs;
 360   int val;
 361   int opchar;
 362
 363   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 364   if((mcs=cmd_opchar_getreg(cmd_io,des,param))==NULL) return -CMDERR_BADREG;
 365   if(opchar==':'){
 366     val=atoi(param[3]);
 367     pxmc_dbgset(mcs,pxmc_dbg_ene_as,val);
 368   }else{
 369     cmd_io_write(cmd_io,param[0],param[2]-param[0]);
 370     cmd_io_putc(cmd_io,'=');
 371     cmd_io_putc(cmd_io,mcs->pxms_flg&PXMS_DBG_m?'1':'0');
 372   }
 373   return 0;
 374 }
 375
 376
 377 int cmd_do_reg_dbgpre(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 378 {
 379   pxmc_dbg_hist_t *hist;
 380   long count, val;
 381   int i;
 382   int opchar;
 383   char *ps;
 384
 385   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 386   ps=param[3];
 387   if(si_long(&ps,&count,0)<0) return -CMDERR_BADPAR;
 388   if(!count||(count>0x10000)) return -CMDERR_BADPAR;
 389   pxmc_dbg_histfree(NULL);
 390   if((hist=pxmc_dbg_histalloc(count+2))==NULL) return -CMDERR_NOMEM;
 391   for(i=0;i<count;i++){
 392     /* ps=cmd_rs232_rdline(cmd_io,1); */ /* !!!!!!!!! */
 393     if(si_long(&ps,&val,0)<0) return -CMDERR_BADPAR;
 394     hist->buff[i]=val;
 395   }
 396   pxmc_dbg_hist=hist;
 397   return 0;
 398 }
 399
 400
 401 int cmd_do_reg_dbghis(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 402 {
 403   pxmc_dbg_hist_t *hist;
 404   long count, val;
 405   int i, opchar;
 406   char *ps;
 407
 408   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 409   ps=param[3];
 410   if(si_long(&ps,&count,0)<0) return -CMDERR_BADPAR;
 411   if(!count||(count>0x10000)) return -CMDERR_BADPAR;
 412   hist=pxmc_dbg_hist;
 413   for(i=0;i<count;i++){
 414     if(hist&&(&hist->buff[i]<hist->end))
 415       val=hist->buff[i];
 416     else
 417       val=0;
 418     /* printf("%ld\r\n",val); */ /* !!!!!!!! */
 419   }
 420   return 0;
 421 }
 422
 423
 424 int cmd_do_reg_dbggnr(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 425 {
 426   pxmc_state_t *mcs;
 427   int i;
 428   int opchar;
 429
 430   if((opchar=cmd_opchar_check(cmd_io,des,param))<0) return opchar;
 431   for(i=0;i<pxmc_main_list.pxml_cnt;i++){
 432     mcs=pxmc_main_list.pxml_arr[i];
 433     if(mcs&&(mcs->pxms_flg&PXMS_DBG_m)){
 434       if(pxmc_dbg_gnr(mcs)<0){
 435         for(i=0;i<pxmc_main_list.pxml_cnt;i++){
 436           mcs=pxmc_main_list.pxml_arr[i];
 437           if(mcs&&(mcs->pxms_flg&PXMS_DBG_m))
 438               pxmc_stop(pxmc_main_list.pxml_arr[i],0);
 439         }
 440         return -CMDERR_BADREG;
 441       }
 442     }
 443   }
 444   pxmc_dbg_hist->ptr=pxmc_dbg_hist->buff;
 445   return 0;
 446 }
 447
 448
 449 /* motor executable commands */
 450 cmd_des_t const cmd_des_go={0, CDESM_OPCHR|CDESM_RW,
 451                         "G?","go to target position",cmd_do_reg_go,{}};
 452 cmd_des_t const cmd_des_pwm={0, CDESM_OPCHR|CDESM_RW,
 453                         "PWM?","direct axis PWM output",cmd_do_pwm,{}};
 454 cmd_des_t const cmd_des_hh={0, CDESM_OPCHR,"HH?","hard home request for axis",cmd_do_reg_hh,{}};
 455 cmd_des_t const cmd_des_spd={0, CDESM_OPCHR,"SPD?","speed request for axis",cmd_do_reg_spd,{}};
 456 cmd_des_t const cmd_des_spdfg={0, CDESM_OPCHR,"SPDFG?",
 457                         "fine grained speed request for axis",cmd_do_reg_spdfg,{}};
 458 cmd_des_t const cmd_des_stop={0, CDESM_OPCHR,
 459                         "STOP?","stop motion of requested axis",cmd_do_stop,{}};
 460 cmd_des_t const cmd_des_release={0, CDESM_OPCHR,
 461                         "RELEASE?","releases axis closed loop control",cmd_do_release,{}};
 462 cmd_des_t const cmd_des_zero={0, CDESM_OPCHR,
 463                         "ZERO?","zero actual position",cmd_do_zero,{}};
 464 cmd_des_t const cmd_des_align={0, CDESM_OPCHR,
 465                         "ALIGN?","align commutator",cmd_do_align,{}};
 466 cmd_des_t const cmd_des_clrerr={0, CDESM_OPCHR,
 467     "PURGE?"," clear 'axis in error state' flag",cmd_do_clrerr,{}};
 468 /* motors and controllers variables */
 469 cmd_des_t const cmd_des_ap={0, CDESM_OPCHR|CDESM_RD,
 470                         "AP?","actual position",cmd_do_reg_rw_pos,
 471                         {(char*)pxmc_state_offs(pxms_ap),
 472                          0}};
 473 cmd_des_t const cmd_des_st={0, CDESM_OPCHR|CDESM_RD,
 474                         "ST?","axis status bits encoded in number",cmd_do_reg_short_val,
 475                         {(char*)pxmc_state_offs(pxms_flg),
 476                          0}};
 477 cmd_des_t const cmd_des_axerr={0, CDESM_OPCHR|CDESM_RD,
 478                         "AXERR?","last axis error code",cmd_do_reg_short_val,
 479                         {(char*)pxmc_state_offs(pxms_errno),
 480                          0}};
 481 #if 0
 482 cmd_des_t const cmd_des_r_one={0, CDESM_OPCHR,
 483                         "R?","send R?! or FAIL?! at axis finish",cmd_do_r_one,{}};
 484 #endif
 485 cmd_des_t const cmd_des_regp={0, CDESM_OPCHR|CDESM_RW,
 486                         "REGP?","controller proportional gain",cmd_do_reg_short_val,
 487                         {(char*)pxmc_state_offs(pxms_p),
 488                          0}};
 489 cmd_des_t const cmd_des_regi={0, CDESM_OPCHR|CDESM_RW,
 490                         "REGI?","controller integral gain",cmd_do_reg_short_val,
 491                         {(char*)pxmc_state_offs(pxms_i),
 492                          0}};
 493 cmd_des_t const cmd_des_regd={0, CDESM_OPCHR|CDESM_RW,
 494                         "REGD?","controller derivative gain",cmd_do_reg_short_val,
 495                         {(char*)pxmc_state_offs(pxms_d),
 496                          0}};
 497 cmd_des_t const cmd_des_regs1={0, CDESM_OPCHR|CDESM_RW,
 498                         "REGS1?","controller S1",cmd_do_reg_short_val,
 499                         {(char*)pxmc_state_offs(pxms_s1),
 500                          0}};
 501 cmd_des_t const cmd_des_regs2={0, CDESM_OPCHR|CDESM_RW,
 502                         "REGS2?","controller S2",cmd_do_reg_short_val,
 503                         {(char*)pxmc_state_offs(pxms_s2),
 504                          0}};
 505 cmd_des_t const cmd_des_regmd={0, CDESM_OPCHR|CDESM_RW,
 506                         "REGMD?","maximal allowed position error",cmd_do_reg_rw_pos,
 507                         {(char*)pxmc_state_offs(pxms_md),
 508                          0}};
 509 cmd_des_t const cmd_des_regms={0, CDESM_OPCHR|CDESM_RW,
 510                         "REGMS?","maximal speed",cmd_do_reg_long_val,
 511                         {(char*)pxmc_state_offs(pxms_ms),
 512                          0}};
 513 cmd_des_t const cmd_des_regacc={0, CDESM_OPCHR|CDESM_RW,
 514                         "REGACC?","maximal acceleration",cmd_do_reg_long_val,
 515                         {(char*)pxmc_state_offs(pxms_ma),
 516                          0}};
 517 cmd_des_t const cmd_des_regme={0, CDESM_OPCHR|CDESM_RW,
 518                         "REGME?","maximal PWM energy or voltage for axis",cmd_do_reg_short_val,
 519                         {(char*)pxmc_state_offs(pxms_me),
 520                          0}};
 521 cmd_des_t const cmd_des_regcfg={0, CDESM_OPCHR|CDESM_RW,
 522                         "REGCFG?","hard home and profile configuration",cmd_do_reg_short_val,
 523                         {(char*)pxmc_state_offs(pxms_cfg),
 524                          0}};
 525 cmd_des_t const cmd_des_ptirc={0, CDESM_OPCHR|CDESM_RW,
 526                         "REGPTIRC?","number of irc pulses per phase table",cmd_do_regptmod_short_val,
 527                         {(char*)pxmc_state_offs(pxms_ptirc),
 528                          (char*)4,(char*)10000}};
 529 cmd_des_t const cmd_des_ptper={0, CDESM_OPCHR|CDESM_RW,
 530                         "REGPTPER?","number of elmag. revolutions per phase table",cmd_do_regptmod_short_val,
 531                         {(char*)pxmc_state_offs(pxms_ptper),
 532                          (char*)1,(char*)100}};
 533 cmd_des_t const cmd_des_ptshift={0, CDESM_OPCHR|CDESM_RW,
 534                         "REGPTSHIFT?","shift (in irc) of generated phase curves",cmd_do_reg_short_val,
 535                         {(char*)pxmc_state_offs(pxms_ptshift),
 536                          0}};
 537 cmd_des_t const cmd_des_ptvang={0, CDESM_OPCHR|CDESM_RW,
 538                         "REGPTVANG?","angle (in irc) between rotor and stator mag. fld.",cmd_do_reg_short_val,
 539                         {(char*)pxmc_state_offs(pxms_ptvang),
 540                          0}};
 541 cmd_des_t const cmd_des_pwm1cor={0, CDESM_OPCHR|CDESM_RW,
 542                         "REGPWM1COR?","PWM1 correction",cmd_do_reg_short_val,
 543                         {(char*)pxmc_state_offs(pxms_pwm1cor),
 544                          0}};
 545 cmd_des_t const cmd_des_pwm2cor={0, CDESM_OPCHR|CDESM_RW,
 546                         "REGPWM2COR?","PWM2 correction",cmd_do_reg_short_val,
 547                         {(char*)pxmc_state_offs(pxms_pwm2cor),
 548                          0}};
 549 cmd_des_t const cmd_des_axis_mode={0, CDESM_OPCHR|CDESM_WR,
 550                         "REGMODE?","axis working mode",cmd_do_axis_mode,
 551                         {}};
 552 #ifdef WITH_SFI_SEL
 553 cmd_des_t const cmd_des_regsfrq={0, CDESM_OPCHR|CDESM_RW,
 554                         "REGSFRQ","set new sampling frequency",cmd_do_regsfrq,{}};
 555 #endif /* WITH_SFI_SEL */
 556 /* axes debugging and tuning */
 557 cmd_des_t const cmd_des_reg_type={0, CDESM_OPCHR|CDESM_RW,
 558                         "REGTYPE?","unused",cmd_do_reg_type,{}};
 559 cmd_des_t const cmd_des_reg_dbgset={0, CDESM_OPCHR|CDESM_RW,
 560                         "REGDBG?","sets debug flag",cmd_do_reg_dbgset,{}};
 561 cmd_des_t const cmd_des_reg_dbgpre={0, CDESM_OPCHR|CDESM_WR,
 562                         "REGDBGPRE","store reference course",cmd_do_reg_dbgpre,{}};
 563 cmd_des_t const cmd_des_reg_dbghis={0, CDESM_OPCHR|CDESM_WR,
 564                         "REGDBGHIS","read history course",cmd_do_reg_dbghis,{}};
 565 cmd_des_t const cmd_des_reg_dbggnr={0, CDESM_OPCHR|CDESM_WR,
 566                         "REGDBGGNR","controller response to HIST course",cmd_do_reg_dbggnr,{}};
 567
 568 cmd_des_t const *cmd_stm_default[]={
 569   &cmd_des_go,
 570   &cmd_des_pwm,
 571   /*&cmd_des_hh,*/
 572   &cmd_des_spd,
 573   &cmd_des_spdfg,
 574   &cmd_des_stop,
 575   &cmd_des_release,
 576   &cmd_des_zero,
 577   &cmd_des_align,
 578   &cmd_des_clrerr,
 579   &cmd_des_ap,
 580   &cmd_des_st,
 581   &cmd_des_axerr,
 582   /*&cmd_des_r_one,*/
 583   &cmd_des_regp,
 584   &cmd_des_regi,
 585   &cmd_des_regd,
 586   &cmd_des_regs1,
 587   &cmd_des_regs2,
 588   &cmd_des_regmd,
 589   &cmd_des_regms,
 590   &cmd_des_regacc,
 591   &cmd_des_regme,
 592   &cmd_des_regcfg,
 593   &cmd_des_ptirc,
 594   &cmd_des_ptper,
 595   &cmd_des_ptshift,
 596   &cmd_des_ptvang,
 597   &cmd_des_pwm1cor,
 598   &cmd_des_pwm2cor,
 599   &cmd_des_axis_mode,
 600   &cmd_des_reg_type,
 601 #ifdef WITH_SFI_SEL
 602   &cmd_des_regsfrq,
 603 #endif /* WITH_SFI_SEL */
 604   &cmd_des_reg_dbgset,
 605   &cmd_des_reg_dbgpre,
 606   &cmd_des_reg_dbghis,
 607   &cmd_des_reg_dbggnr,
 608   NULL
 609 };