navratil_ad/cmd_pxmc.c

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