Subversion Repositories f9daq

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2. 8mru
  3.   sudo ./usmc_ctrl -n 0 -p 1 -s 1000 -h 0 -p 0
  4.   sudo ./usmc_ctrl -n 0 -p 1 -s 1000 -m +1210 -p 0
  5.   sudo ./usmc_ctrl -n 0 -p 1 -s 1000 -m -1210 -p 0
  6.    
  7.  
  8. usmc_ctrl -a
  9. usmc_ctrl -n 0 -i
  10. usmc_ctrl -n 0 -p 1 -s 5000 -m 10000 - p 0
  11. usmc_ctrl -n 0 -p 1 -h -p 0
  12.  
  13.  
  14. */
  15. #include <stdlib.h>
  16. #include <stdio.h>
  17. #include <string.h>
  18.  
  19. #ifndef _WINDOWS
  20. #include "libusmc.h"      
  21. #include <getopt.h>
  22. #include <time.h>
  23.  
  24. void sleep_us(unsigned long microseconds)
  25. {
  26.     struct timespec ts;
  27.     ts.tv_sec = microseconds / 1000000;             // whole seconds
  28.     ts.tv_nsec = (microseconds % 1000000) * 1000;    // remainder, in nanoseconds
  29.     nanosleep(&ts, NULL);
  30. }
  31.  
  32. #define Delay(x) sleep_us((int)(x*1000000))
  33. #else
  34. #include "USMCDLL.H"
  35. #include <utility.h>
  36. #include <ansi_c.h>  
  37.  
  38.  
  39.  
  40. #define ERR(s, c)       if(opterr) fprintf(stderr,"%s %c\n",s,c);  
  41.  
  42.  
  43. int     opterr = 1;
  44. int     optind = 1;
  45. int     optopt;
  46. char    *optarg;
  47.  
  48. int     getopt(int argc, char **argv, char *opts){
  49.         static int sp = 1;
  50.         int c;
  51.         char *cp;
  52.  
  53.         if(sp == 1)
  54.                 if(optind >= argc ||
  55.                    argv[optind][0] != '-' || argv[optind][1] == '\0')
  56.                         return(EOF);
  57.                 else if(strcmp(argv[optind], "--") == NULL) {
  58.                         optind++;
  59.                         return(EOF);
  60.                 }
  61.         optopt = c = argv[optind][sp];
  62.         if(c == ':' || (cp=strchr(opts, c)) == NULL) {
  63.                 ERR(": illegal option -- ", c);
  64.                 if(argv[optind][++sp] == '\0') {
  65.                         optind++;
  66.                         sp = 1;
  67.                 }
  68.                 return('?');
  69.         }
  70.         if(*++cp == ':') {
  71.                 if(argv[optind][sp+1] != '\0')
  72.                         optarg = &argv[optind++][sp+1];
  73.                 else if(++optind >= argc) {
  74.                         ERR(": option requires an argument -- ", c);
  75.                         sp = 1;
  76.                         return('?');
  77.                 } else
  78.                         optarg = argv[optind++];
  79.                 sp = 1;
  80.         } else {
  81.                 if(argv[optind][++sp] == '\0') {
  82.                         sp = 1;
  83.                         optind++;
  84.                 }
  85.                 optarg = NULL;
  86.         }
  87.         return(c);
  88. }
  89.  
  90. #endif
  91.  
  92. #define MAXNODES 4
  93. USMC_Devices devices;
  94. USMC_StartParameters parstart[MAXNODES];
  95. USMC_Parameters      parameters[MAXNODES];
  96. USMC_State parstate[MAXNODES];
  97. USMC_EncoderState parencstate[MAXNODES];
  98. #define ERRLEN 128
  99. char errstr[ERRLEN];
  100.  
  101. // Function that prints information about device parameters to console
  102. void print_parameters(USMC_Parameters *Parameters)
  103. {
  104.         printf( "The parameters are:\n" );
  105.         printf( "Full acceleration time - %.0f ms\n", (double) Parameters->AccelT );
  106.         printf( "Full deceleration time - %.0f ms\n", (double) Parameters->DecelT );
  107.         printf( "Power reduction timeout - %.0f ms\n", (double) Parameters->PTimeout );
  108.         printf( "Button speedup timeout 1 - %.0f ms\n", (double) Parameters->BTimeout1 );
  109.         printf( "Button speed after timeout 1 - %.2f steps/s\n", (double) Parameters->BTO1P );
  110.         printf( "Button speedup timeout 2 - %.0f ms\n", (double) Parameters->BTimeout2 );
  111.         printf( "Button speed after timeout 2 - %.2f steps/s\n", (double) Parameters->BTO2P );
  112.         printf( "Button speedup timeout 3 - %.0f ms\n", (double) Parameters->BTimeout3 );
  113.         printf( "Button speed after timeout 3 - %.2f steps/s\n", (double) Parameters->BTO3P );
  114.         printf( "Button speedup timeout 4 - %.0f ms\n", (double) Parameters->BTimeout4 );
  115.         printf( "Button speed after timeout 4 - %.2f steps/s\n", (double) Parameters->BTO4P );
  116.         printf( "Button reset timeout - %.0f ms\n", (double) Parameters->BTimeoutR );
  117.         printf( "Button reset operation speed - %.2f steps/s\n", (double) Parameters->MinP );
  118.         printf( "Backlash operation distance - %d steps\n", (int)Parameters->MaxLoft );
  119.         printf( "Revolution distance - %d steps\n", (int)Parameters->RTDelta );
  120.         printf( "Minimal revolution distance error - %d steps\n", (int)Parameters->RTMinError );
  121.         printf( "Power off temperature - %.2f\xf8\x43\n", (double)Parameters->MaxTemp );
  122.         printf( "Duration of the output synchronization pulse - ");
  123.         if(Parameters->SynOUTP == 0)
  124.                 printf( "minimal\n");
  125.         else
  126.                 printf( "%.1f * [Tact Period]\n", Parameters->SynOUTP - 0.5);
  127.         printf( "Speed of the last phase of the backlash operation - ");
  128.         if(Parameters->LoftPeriod == 0.0f)
  129.                 printf( "normal\n" );
  130.         else
  131.                 printf( "%.2f steps/s\n", (double)Parameters->LoftPeriod );
  132.         printf( "<Angular Encoder Step> Equals <Angular Step Motor Step>/<%.2f>\n", Parameters->EncMult);
  133.  
  134. }
  135.  
  136. // Function that prints information about device start parameters to console
  137. void print_start_params ( const USMC_StartParameters sp ){
  138.         printf ( "* Steps Divisor - %d\n", sp.SDivisor );
  139.  
  140.         if ( sp.SDivisor == 1 )
  141.                 printf ( "* Slow start/stop mode - %s\n", sp.SlStart ? "Enabled" : "Disabled" );
  142.         else if ( sp.LoftEn ) {
  143.                 printf ( "* Automatic backlash operation - Enabled\n" );
  144.                 printf ( "* Automatic backlash operation direction - %s\n", sp.DefDir ? "CCW" : "CW" );
  145.                 printf ( "* Force automatic backlash operation - %s\n", sp.ForceLoft ? "TRUE" : "FALSE" );
  146.         } else {
  147.                 printf ( "* Automatic backlash operation - Disabled\n" );
  148.         }
  149.         if ( sp.WSyncIN )
  150.                 printf ( "* Controller will wait for input synchronization signal to start\n" );
  151.         else
  152.                 printf ( "* Input synchronization signal ignored \n" );
  153.  
  154.         printf ( "* Output synchronization counter will %sbe reset\n", sp.SyncOUTR ? "" : "not " );
  155. }
  156.  
  157. // Function that prints information about device state to console
  158. void print_state(USMC_State *State)
  159. {
  160.         printf( " The state is:\n" );
  161.         printf( "- Current Position in microsteps - %d\n", State->CurPos );
  162.         printf( "- Temperature - %.2f\xf8\x43\n", State->Temp );
  163.         printf( "- Step Divisor - %d\n", State->SDivisor);
  164.         printf( "- Loft State - %s\n", State->Loft?"Indefinite":"Fixed" );
  165.         printf( "- Power - %s\n", State->Power?(State->FullPower?"Full":"Half"):"Off" );
  166.         if(State->RUN)
  167.                 printf( "- Step Motor is Running in %s Direction %s\n",
  168.                                 State->CW_CCW?"CCW":"CW", ((State->SDivisor==1) && State->FullSpeed)?"at Full Speed":"" );
  169.         else
  170.                 printf( "- Step Motor is Not Running\n" );
  171.         printf( "- Device %s\n", State->AReset?"is After Reset":"Position Already Set" );
  172.         printf( "- Input Synchronization Logical Pin State - %s\n", State->SyncIN?"TRUE":"FALSE" );
  173.         printf( "- Output Synchronization Logical Pin State - %s\n", State->SyncOUT?"TRUE":"FALSE" );
  174.         printf( "- Rotary Transducer Logical Pin State - %s\n", State->RotTr?"TRUE":"FALSE" );
  175.         printf( "- Rotary Transducer Error Flag - %s\n", State->RotTrErr?"Error":"Clear" );
  176.         printf( "- Emergency Disable Button - %s\n", State->EmReset?"Pushed":"Unpushed" );
  177.         printf( "- Trailer 1 Press State - %s\n", State->Trailer1?"Pushed":"Unpushed" );
  178.         printf( "- Trailer 2 Press State - %s\n", State->Trailer2?"Pushed":"Unpushed" );
  179.         if( State->Voltage == 0.0f )
  180.                 printf( "- Input Voltage - Low\n");
  181.         else
  182.                 printf( "- Input Voltage - %.1fV\n", State->Voltage);
  183.  
  184. }
  185.  
  186. void print_enc_state ( USMC_EncoderState enc_state )
  187. {
  188.         printf ( "# The encoder state is:\n" );
  189.         printf ( "#    Current Position in \"Half of Encoder Step\"s - %d\n", enc_state.ECurPos );
  190.         printf ( "#    Encoder Position in \"Half of Encoder Step\"s - %d\n", enc_state.EncoderPos );
  191.  
  192. }
  193.  
  194.  
  195. // Function that prints information about connected devices to console
  196. void printdevices(USMC_Devices DVS)
  197. {
  198.     DWORD i;
  199.         for( i = 0; i < DVS.NOD; i++)
  200.         {
  201.                 printf("Device - %d,\tSerial Number - %.16s,\tVersion - %.4s\n",i,DVS.Serial[i],DVS.Version[i]);
  202.         }
  203. }
  204.  
  205.  
  206.  
  207. void usmc_SwapSwitches ( int cur_dev, int swap ){
  208.        
  209.         USMC_Mode mode;
  210.         if ( USMC_GetMode ( cur_dev, &mode ) ) return;
  211.         mode.TrSwap = swap;
  212.         if ( USMC_SetMode ( cur_dev, &mode ) ) return;
  213.         printf ( "Now, Switches of %d are %s swapped.\n", cur_dev, mode.TrSwap ? "" : "not" );
  214. }
  215.  
  216. void usmc_EnableSwitches ( int cur_dev, int enable ){
  217.        
  218.         USMC_Mode mode;
  219.         if ( USMC_GetMode ( cur_dev, &mode ) ) return;
  220.         mode.Tr1En = enable;
  221.         mode.Tr2En = enable;
  222.         if ( USMC_SetMode ( cur_dev, &mode ) ) return;
  223.         printf ( "Now, Switches of %d are %s.\n", cur_dev, mode.Tr1En ? "enabled" : "disabled" );
  224. }
  225.  
  226.  
  227. int usmc_Set_Parameters(int Dev, int mode)
  228. {
  229.    
  230.         if( USMC_GetParameters(Dev, &parameters[Dev]) )
  231.                 return TRUE;
  232.  
  233. switch (mode) {
  234. case 0:
  235. // Rotation stage
  236.        
  237.         usmc_SwapSwitches(Dev,1);
  238.         parameters[Dev].MaxTemp = 70.0f;
  239.         parameters[Dev].AccelT = 200.0f;
  240.         parameters[Dev].DecelT = 200.0f;
  241.         parameters[Dev].BTimeout1 = 500.0f;
  242.         parameters[Dev].BTimeout2 = 500.0f;
  243.         parameters[Dev].BTimeout3 = 500.0f;
  244.         parameters[Dev].BTimeout4 = 500.0f;
  245.         parameters[Dev].BTO1P = 10.0f;
  246.         parameters[Dev].BTO2P = 20.0f;
  247.         parameters[Dev].BTO3P = 30.0f;
  248.         parameters[Dev].BTO4P = 60.0f;
  249.         parameters[Dev].MinP = 60.0f;
  250.         parameters[Dev].BTimeoutR = 500.0f;
  251.         parameters[Dev].LoftPeriod = 50.0f;
  252.         parameters[Dev].RTDelta = 20;
  253.         parameters[Dev].RTMinError = 15;
  254.         parameters[Dev].EncMult = 2.5f;
  255.         parameters[Dev].MaxLoft = 32;
  256.         parameters[Dev].PTimeout = 100.0f;
  257.         parameters[Dev].SynOUTP = 1;
  258.         break;
  259. case 1:
  260. // Linear stage
  261.         usmc_SwapSwitches(Dev,0);
  262.         parameters[Dev].MaxTemp = 70.0f;
  263.         parameters[Dev].AccelT = 200.0f;
  264.         parameters[Dev].DecelT = 200.0f;
  265.         parameters[Dev].BTimeout1 = 500.0f;
  266.         parameters[Dev].BTimeout2 = 500.0f;
  267.         parameters[Dev].BTimeout3 = 500.0f;
  268.         parameters[Dev].BTimeout4 = 500.0f;
  269.         parameters[Dev].BTO1P = 100.0f;
  270.         parameters[Dev].BTO2P = 200.0f;
  271.         parameters[Dev].BTO3P = 300.0f;
  272.         parameters[Dev].BTO4P = 600.0f;
  273.         parameters[Dev].MinP = 500.0f;
  274.         parameters[Dev].BTimeoutR = 500.0f;
  275.         parameters[Dev].LoftPeriod = 500.0f;
  276.         parameters[Dev].RTDelta = 200;
  277.         parameters[Dev].RTMinError = 15;
  278.         parameters[Dev].EncMult = 2.5f;
  279.         parameters[Dev].MaxLoft = 32;
  280.         parameters[Dev].PTimeout = 100.0f;
  281.         parameters[Dev].SynOUTP = 1;
  282.         break;
  283.         }
  284.  
  285.         //
  286.  
  287.         if( USMC_SetParameters( Dev, &parameters[Dev] ) )
  288.                 return TRUE;
  289.  
  290.         if( USMC_SaveParametersToFlash( Dev ) )
  291.                 return TRUE;
  292.  
  293.         //system("cls");
  294.         print_parameters( &parameters[Dev] );
  295.         printf("\nThese Parameters are Saved to Flash");
  296.  
  297.         return FALSE;
  298. }
  299.  
  300. int usmc_Init(int node, int mode){
  301.     printf("\nNode %d\n",node);
  302.         USMC_GetStartParameters(node,&parstart[node]);
  303.     USMC_GetLastErr(errstr,ERRLEN);  if (strlen(errstr)) printf("i1 %s\n",errstr);
  304.    
  305.         USMC_GetState(node,&parstate[node]);
  306.     USMC_GetLastErr(errstr,ERRLEN);  if (strlen(errstr)) printf("i2 %s\n",errstr);
  307.  
  308.         USMC_GetEncoderState(node,&parencstate[node]);
  309.     USMC_GetLastErr(errstr,ERRLEN);  if (strlen(errstr)) printf("i3 %s\n",errstr);
  310.  
  311.         print_state(&parstate[node]);
  312.     print_enc_state ( parencstate[node]);
  313.         print_start_params (parstart[node] );
  314.         usmc_Set_Parameters(node, mode);
  315.         return 0;
  316. }
  317.  
  318. float usmc_speed=10000;
  319. int usmc_Move(int node, int pos,  BOOL absrel){
  320.   time_t tcur=0, tprev=-1;
  321.   USMC_GetStartParameters(node,&parstart[node]);
  322.   USMC_GetLastErr(errstr,ERRLEN);  if (strlen(errstr)) printf("x1 %s\n",errstr);
  323.  
  324.   parstart[node].WSyncIN=absrel;
  325.   parstart[node].SlStart=1;
  326.   parstart[node].LoftEn=0;  
  327.   print_start_params ( parstart[node] );
  328.   if (absrel) printf("usmc_Move relative for %d\n",pos);
  329.   else printf("usmc_Move absolute %d\n",pos);
  330.   USMC_Start(node,pos,&usmc_speed, &parstart[node]);
  331.   Delay(0.1);
  332.   USMC_GetLastErr(errstr,ERRLEN);  if (strlen(errstr)) printf("x2 %s speed %f\n",errstr,usmc_speed);
  333.  
  334.   do {
  335.     USMC_GetState(node,&parstate[node]);
  336.     USMC_GetLastErr(errstr,ERRLEN); // if (strlen(errstr)) printf("x3 %s\n",errstr);
  337.         tcur= time(NULL);
  338.         if (tcur != tprev){
  339.     printf("%d CurPos %d L%d R%d Rot%d %s %s\n",node,
  340.                         parstate[node].CurPos,parstate[node].Trailer1,parstate[node].Trailer2, parstate[node].RotTr,
  341.                         parstate[node].RUN?"Run":"Stopped",parstate[node].Power?"On":"Off" );
  342.     tprev= tcur;
  343.     }
  344.    
  345.   } while ( parstate[node].RUN == 1 );
  346.   USMC_GetState(node,&parstate[node]);
  347.   printf("***** %d CurPos %d L%d R%d %s %s\n",node,
  348.                         parstate[node].CurPos,parstate[node].Trailer1,parstate[node].Trailer2,
  349.                         parstate[node].RUN?"Run":"Stopped",parstate[node].Power?"On":"Off" );
  350.   USMC_GetParameters(node,&parameters[node]);  
  351.                      USMC_GetEncoderState(node,&parencstate[node]);
  352.                      printf("node %d ECurPos 0x%0x %f EncoderPos =0x%04x %f\n",node,
  353.                      parencstate[node].ECurPos, (((parencstate[node].ECurPos)>>5)&0x8FFFFF)/parameters[node].EncMult,
  354.                      parencstate[node].EncoderPos,((parencstate[node].EncoderPos >> 5)&0x8FFFFF)/parameters[node].EncMult);                      
  355.  
  356.  
  357.         return 0;
  358. }
  359.  
  360.  
  361.  
  362. void usmc_PowerOnOff ( int cur_dev, int smpower ){
  363.        
  364.         USMC_Mode mode;
  365.         if ( USMC_GetMode ( cur_dev, &mode ) ) return;
  366.         mode.ResetD = !smpower;
  367.         if ( USMC_SetMode ( cur_dev, &mode ) ) return;
  368.         printf ( "Now, Power of the node %d is %s\n", cur_dev, mode.ResetD ? "Off" : "On" );
  369. }
  370.  
  371. int usmc_MoveTo(int node, int pos){
  372.   return usmc_Move(node,pos, FALSE);
  373. }
  374.  
  375.  
  376. int usmc_RelMove(int node, int pos){
  377.   //return usmc_Move(node,pos, TRUE);// does not work - don't know why
  378.  
  379.   USMC_GetState(node,&parstate[node]);
  380.   return usmc_MoveTo( node, pos + parstate[node].CurPos );
  381. }
  382.  
  383. int Revert_Start_Position_to_0(int node)
  384. {
  385.     USMC_Parameters Prms;
  386.         // Initialize structures (in case this function runs first)
  387.         if( USMC_GetParameters(node, &Prms) )
  388.                 return TRUE;
  389.         Prms.StartPos = 0;
  390.         if( USMC_SetParameters( node, &Prms ) )
  391.                 return TRUE;
  392.         // Then of Course You Need to SaveToFlash
  393.         if( USMC_SaveParametersToFlash( node ) )
  394.                 return TRUE;
  395.         //system("cls");
  396.         printf("\nStart Position is Reset to 0\n");
  397.         printf("\nPress any key to exit");
  398.         return FALSE;
  399. }
  400.  
  401. int usmc_Reset(int node, int mode){
  402.  
  403. usmc_Init(node,mode);
  404. USMC_SetCurrentPosition(node, 0);
  405. Revert_Start_Position_to_0(node);
  406. return 0;
  407. }
  408.  
  409. int usmc_ReferenceMove(int node, int mode){
  410.  
  411. int pos = 1000000;
  412. int dir=1;
  413. if (!mode) usmc_SwapSwitches(node,1);
  414. else usmc_SwapSwitches(node,0);
  415.  
  416. usmc_EnableSwitches(node,1);
  417.  
  418. USMC_GetState(node,&parstate[node]);
  419. usmc_MoveTo(node, parstate[node].CurPos -2 *pos * dir);
  420. USMC_GetState(node,&parstate[node]);
  421. pos = 5000;
  422. if (!mode) pos=500;
  423. usmc_MoveTo(node, parstate[node].CurPos + pos * dir);
  424. USMC_GetState(node,&parstate[node]);
  425. usmc_speed /=5;
  426. usmc_MoveTo(node, parstate[node].CurPos -2 *pos * dir);
  427. USMC_GetState(node,&parstate[node]);
  428. pos = 2000;
  429. if (!mode) pos=200;
  430. usmc_MoveTo(node, parstate[node].CurPos + pos *dir);
  431. USMC_GetState(node,&parstate[node]);
  432. usmc_speed /= 10;
  433. usmc_MoveTo(node, parstate[node].CurPos -2 *pos * dir);
  434. USMC_GetState(node,&parstate[node]);
  435. USMC_SetCurrentPosition(node, 0);
  436. Revert_Start_Position_to_0(node);
  437.  
  438. usmc_EnableSwitches(node,0);
  439. return 0;
  440. }
  441.  
  442. int help(){
  443. fprintf(stderr, "Usage: mikro [-i node][-n node] [-u up] [-d down] [-r node] [-h node] [-a] [-g] [-m pos]\n");
  444.                    fprintf(stderr,"      Options:\n");
  445.                    fprintf(stderr," -n node -i mode  .. initialize node\n");
  446.                    fprintf(stderr," -n node -h <endswitch_direction>  .. homing procedure for node\n");
  447.                    fprintf(stderr," -n node -p 1   .. power on\n");
  448.                    fprintf(stderr," -n node -p 0   .. power off\n");
  449.                    fprintf(stderr," -n node -r mode  .. reset node\n");
  450.                    fprintf(stderr," -n node -u <steps>  .. move node for <steps>\n");
  451.                    fprintf(stderr," -a   .. current status of the nodes\n");
  452.                    fprintf(stderr," -n node -v value -f cmd   .. set value of the cmd on the node\n");
  453.                    fprintf(stderr," -n node -g cmd   .. get value of the cmd on the node\n");          
  454.                    fprintf(stderr," -n node -m position  -s speed .. move node to position at speed (default 10000)\n");
  455.                    fprintf(stderr," -l delaysec  .. loop test with the delay delaysec\n");          
  456. return 0;
  457. }
  458.  
  459. int main (int argc, char ** argv){
  460.   int i,j,k;
  461.   int node=0,opt,value=0;
  462.   int EOldPos=-1;      
  463.   if ( USMC_Init ( &devices ) ) abort();
  464.  
  465.  
  466.   while ((opt = getopt(argc, argv, "i:av:f:l:u:n:m:s:v:gh:r:p:")) != -1) {
  467.                switch (opt) {
  468.                case 'i':
  469.                    usmc_Init (node, atoi(optarg));
  470.                    
  471.                    break;
  472.                case 'a':
  473.                    printdevices(devices);
  474.                    for (i=0;i<devices.NOD;i++){
  475.                      USMC_GetState(i,&parstate[i]);
  476.                      printf("%d CurPos %d L%d R%d %s %s\t",i,
  477.                         parstate[i].CurPos,parstate[i].Trailer1,parstate[i].Trailer2,
  478.                         parstate[i].RUN?"Run":"Stopped",parstate[i].Power?"On":"Off" );
  479.                      USMC_GetParameters(i,&parameters[i]);  
  480.                      USMC_GetEncoderState(i,&parencstate[i]);
  481.                      printf("node %d ECurPos 0x%0x %f EncoderPos =0x%04x %f\n",i,
  482.                      parencstate[i].ECurPos, (((parencstate[i].ECurPos)>>5)&0x8FFFFF)/parameters[i].EncMult,
  483.                      parencstate[i].EncoderPos,((parencstate[i].EncoderPos >> 5)&0x8FFFFF)/parameters[i].EncMult);
  484.                      
  485.                    }
  486.                    break;
  487.  
  488.                case 'l':
  489.                    printf("usmc_MoveTo Loop\n");
  490.                    for (i=0;i<5;i++){
  491.                      int xpos=i*1000+10000;                  
  492.                      usmc_MoveTo (0, xpos);
  493.                                            for (j=0;j<5;j++){
  494.                                              int ypos=j*1000+10000;                      
  495.                                              usmc_MoveTo (1, ypos);
  496.                          for (k=0;k<50;k++){
  497.                            int zpos=k*1000+10000;                        
  498.                            usmc_MoveTo (2, zpos);
  499.                            printf("x=%d y=%d z=%d\n",xpos,ypos,zpos);
  500.                            Delay(atof(optarg));
  501.                    
  502.                        }
  503.                      }
  504.                    }
  505.                    break;
  506.                case 'n':
  507.                   node = atoi(optarg);
  508.                   break;
  509.                case 's':
  510.                   usmc_speed = atoi(optarg);
  511.                   break;  
  512.                case 'p':
  513.                   usmc_PowerOnOff(node,atoi(optarg));
  514.                   break;
  515.                case 'm':
  516.                    usmc_EnableSwitches(node,1);
  517.                    usmc_MoveTo (node, atoi(optarg));
  518.                    usmc_EnableSwitches(node,0);
  519.                    printf("usmc_MoveTo node=%d pos=%d \n",node,atoi(optarg));
  520.                    
  521.                    break;
  522.              
  523.                case 'v':
  524.                    value=atoi(optarg);
  525.                    break;
  526.                                                                          /*
  527.                case 'f':
  528.                    MIKRO_Set (node,optarg,value);
  529.                    printf("MIKRO_Set node %d  cmd=%s val=%d\n",node,optarg, value);
  530.                    break;
  531. */
  532.                case 'g':
  533.                      
  534.                      USMC_GetState(node,&parstate[node]);
  535.                      printf("node %d CurPos %d L%d R%d %s %s\n",node,
  536.                         parstate[node].CurPos,parstate[node].Trailer1,parstate[node].Trailer2,
  537.                         parstate[node].RUN?"Run":"Stopped",parstate[node].Power?"On":"Off" );
  538.  
  539.      
  540.                    break;
  541.                
  542.                
  543.               case 'r':
  544.                       printf("usmc_Reset node=%d mode=%d\n",node, atoi(optarg));
  545.                       usmc_Reset (node, atoi(optarg));
  546.                       break;
  547.                      
  548.                case 'h':
  549.                       printf("usmc_ReferenceMove node=%d endswitch=%d\n",node, atoi(optarg));
  550.                       usmc_ReferenceMove (node, atoi(optarg));
  551.                       break;
  552.                      
  553.                case 'u':
  554.                   usmc_EnableSwitches(node,1);
  555.                   usmc_RelMove(node, atoi(optarg));
  556.                   usmc_EnableSwitches(node,0);
  557.                   break;
  558.  
  559.                default: /* '?' */
  560.                    help();
  561.                        
  562.                    break;
  563.                }
  564.            }
  565.          if (argc==1) help();
  566.  
  567.  
  568.          USMC_Close ();
  569. #ifdef _WINDOWS
  570.          getchar();
  571. #endif   
  572.   return 0;
  573. }
  574.