setup.bak

This is a CNCPro source file. It is include the G-Code interpreter source.

            if((*hardware).h_spd_z>(*hardware).vel_z) {(*hardware).h_spd_z=(*hardware).vel_z; warning=TRUE;}
            if((*hardware).h_spd_a>(*hardware).vel_a) {(*hardware).h_spd_a=(*hardware).vel_a; warning=TRUE;}
            if(warning==TRUE)
              {box(22,19,59,24, RED,BLACK,WHITE,WHITE);
               gotoxy(4,3); cprintf("Speed or Speeds Exceed Max Value");
               gotoxy(4,4); cprintf("Max Value Will Be Used <Any Key>");
               getch(); warning=FALSE;}
            }
         else _setcursortype(_NOCURSOR);
        }
     }
}    

int calibration(struct hard_setup *hardware, struct soft_setup *software)
{
   static char item[20][35];
   int ch, i, curnt=0, change=FALSE, warning=FALSE;
   float value;
   
   while(1)
     {window(21,1,60,25);
      textbackground(LIGHTGRAY);
      clrscr();
      box(21,1,60,20, LIGHTGRAY,BLACK,WHITE,BLUE);
      window(21,1,60,25);
      gotoxy(15,1); cprintf("<Esc> TO EXIT");
      if((*software).units==IN)
        {      sprintf(item[0], "<X> Backlash Value (IN)    %s",prn_val((*hardware).back_x));
               sprintf(item[1], "<Y> Backlash Value (IN)    %s",prn_val((*hardware).back_y));
               sprintf(item[2], "<Z> Backlash Value (IN)    %s",prn_val((*hardware).back_z));
               sprintf(item[4], "<X> Steps Per Inch         %s",prn_val(1/(*hardware).x_per_step));
               sprintf(item[5], "<Y> Steps Per Inch         %s",prn_val(1/(*hardware).y_per_step));
               sprintf(item[6], "<Z> Steps Per Inch         %s",prn_val(1/(*hardware).z_per_step));
         if((*software).time==SEC)
           {   sprintf(item[8], "<X> Max Velocity (IN/SEC)  %s",prn_val((*hardware).vel_x));
               sprintf(item[9], "<Y> Max Velocity (IN/SEC)  %s",prn_val((*hardware).vel_y));
               sprintf(item[10],"<Z> Max Velocity (IN/SEC)  %s",prn_val((*hardware).vel_z));
           }
         else
           {   sprintf(item[8], "<X> Max Velocity (IN/MIN)  %s",prn_val((*hardware).vel_x*60));
               sprintf(item[9], "<Y> Max Velocity (IN/MIN)  %s",prn_val((*hardware).vel_y*60));
               sprintf(item[10],"<Z> Max Velocity (IN/MIN)  %s",prn_val((*hardware).vel_z*60));
           }
               sprintf(item[12],"<X> Max Accel (FT/SEC^2)   %s",prn_val((*hardware).accel_x/12));
               sprintf(item[13],"<Y> Max Accel (FT/SEC^2)   %s",prn_val((*hardware).accel_y/12));
               sprintf(item[14],"<Z> Max Accel (FT/SEC^2)   %s",prn_val((*hardware).accel_z/12));
               sprintf(item[16],"<X> Max Stop Distance (IN) %s",prn_val((*hardware).vel_x*(*hardware).vel_x/(2*(*hardware).accel_x)));
               sprintf(item[17],"<Y> Max Stop Distance (IN) %s",prn_val((*hardware).vel_y*(*hardware).vel_y/(2*(*hardware).accel_y)));
               sprintf(item[18],"<Z> Max Stop Distance (IN) %s",prn_val((*hardware).vel_z*(*hardware).vel_z/(2*(*hardware).accel_z)));
        }
      else
        {      sprintf(item[0], "<X> Backlash Distance (MM) %s",prn_val((*hardware).back_x));
               sprintf(item[1], "<Y> Backlash Distance (MM) %s",prn_val((*hardware).back_y));
               sprintf(item[2], "<Z> Backlash Distance (MM) %s",prn_val((*hardware).back_z));
               sprintf(item[4], "<X> Steps Per Millimeter   %s",prn_val(1/(*hardware).x_per_step));
               sprintf(item[5], "<Y> Steps Per Millimeter   %s",prn_val(1/(*hardware).y_per_step));
               sprintf(item[6], "<Z> Steps Per Millimeter   %s",prn_val(1/(*hardware).z_per_step));
         if((*software).time==SEC)
           {   sprintf(item[8], "<X> Max Velocity (MM/SEC)  %s",prn_val((*hardware).vel_x));
               sprintf(item[9], "<Y> Max Velocity (MM/SEC)  %s",prn_val((*hardware).vel_y));
               sprintf(item[10],"<Z> Max Velocity (MM/SEC)  %s",prn_val((*hardware).vel_z));
           }
         else
           {   sprintf(item[8], "<X> Max Velocity (MM/MIN)  %s",prn_val((*hardware).vel_x*60));
               sprintf(item[9], "<Y> Max Velocity (MM/MIN)  %s",prn_val((*hardware).vel_y*60));
               sprintf(item[10],"<Z> Max Velocity (MM/MIN)  %s",prn_val((*hardware).vel_z*60));
           }
               sprintf(item[12],"<X> Max Accel (M/SEC^2)    %s",prn_val((*hardware).accel_x*.001));
               sprintf(item[13],"<Y> Max Accel (M/SEC^2)    %s",prn_val((*hardware).accel_y*.001));
               sprintf(item[14],"<Z> Max Accel (M/SEC^2)    %s",prn_val((*hardware).accel_z*.001));
               sprintf(item[16],"<X> Max Stop Distance (MM) %s",prn_val((*hardware).vel_x*(*hardware).vel_x/(2*(*hardware).accel_x)));
               sprintf(item[17],"<Y> Max Stop Distance (MM) %s",prn_val((*hardware).vel_y*(*hardware).vel_y/(2*(*hardware).accel_y)));
               sprintf(item[18],"<Z> Max Stop Distance (MM) %s",prn_val((*hardware).vel_z*(*hardware).vel_z/(2*(*hardware).accel_z)));
        }
      if((*software).a_units==IN)
        {      sprintf(item[3], "<Aux>Backlash Distance(IN) %s",prn_val((*hardware).back_a));
               sprintf(item[7], "<Aux> Steps Per Inch       %s",prn_val(1/(*hardware).a_per_step));
         if((*software).a_time==SEC)
               sprintf(item[11],"<Aux> Max Velocity(IN/SEC) %s",prn_val((*hardware).vel_a));
         else  sprintf(item[11],"<Aux> Max Velocity(IN/MIN) %s",prn_val((*hardware).vel_a*60));
               sprintf(item[15],"<Aux> Max Accel (FT/SEC^2) %s",prn_val((*hardware).accel_a/12));
               sprintf(item[19],"<Aux>Max Stop Distance(IN) %s",prn_val((*hardware).vel_a*(*hardware).vel_a/(2*(*hardware).accel_a)));
        }
      if((*software).a_units==MM)
        {      sprintf(item[3], "<Aux>Backlash Distance(MM) %s",prn_val((*hardware).back_a));
               sprintf(item[7], "<Aux> Steps Per Millimeter %s",prn_val(1/(*hardware).a_per_step));
         if((*software).a_time==SEC)
               sprintf(item[11],"<Aux> Max Velocity(MM/SEC) %s",prn_val((*hardware).vel_a));
         else  sprintf(item[11],"<Aux> Max Velocity(MM/MIN) %s",prn_val((*hardware).vel_a*60));
               sprintf(item[15],"<Aux> Max Accel (M/SEC^2)  %s",prn_val((*hardware).accel_a*.001));
               sprintf(item[19],"<Aux> Max Stop Angle (MM)  %s",prn_val((*hardware).vel_a*(*hardware).vel_a/(2*(*hardware).accel_a)));
        }
      if((*software).a_units==RAD)
        {      sprintf(item[3], "<Aux> Backlash Angle (RAD) %s",prn_val((*hardware).back_a));
               sprintf(item[7], "<Aux> Steps Per Radian     %s",prn_val(1/(*hardware).a_per_step));
         if((*software).a_time==SEC)
               sprintf(item[11],"<Aux>Max Velocity(RAD/SEC) %s",prn_val((*hardware).vel_a));
         else  sprintf(item[11],"<Aux>Max Velocity(RAD/MIN) %s",prn_val((*hardware).vel_a*60));
               sprintf(item[15],"<Aux> Max Accel(RAD/SEC^2) %s",prn_val((*hardware).accel_a));
               sprintf(item[19],"<Aux> Max Stop Angle(RAD)  %s",prn_val((*hardware).vel_a*(*hardware).vel_a/(2*(*hardware).accel_a)));
        }
      if((*software).a_units==DEG)
        {      sprintf(item[3], "<Aux> Backlash Angle (DEG) %s",prn_val((*hardware).back_a));
               sprintf(item[7], "<Aux> Steps Per Degree     %s",prn_val(1/(*hardware).a_per_step));
         if((*software).a_time==SEC)
               sprintf(item[11],"<Aux>Max Velocity(DEG/SEC) %s",prn_val((*hardware).vel_a));
         else  sprintf(item[11],"<Aux>Max Velocity(DEG/MIN) %s",prn_val((*hardware).vel_a*60));
               sprintf(item[15],"<Aux> Max Accel(DEG/SEC^2) %s",prn_val((*hardware).accel_a));
               sprintf(item[19],"<Aux> Max Stop Angle(DEG)  %s",prn_val((*hardware).vel_a*(*hardware).vel_a/(2*(*hardware).accel_a)));
        }

      for(i=0;i<16;i++) {gotoxy(4,i+3); cprintf("%s",item[i]);}
      textcolor(YELLOW); for(i=16;i<20;i++) {gotoxy(4,i+5); cprintf("%s",item[i]);} textcolor(BLUE);
      while (1)
        {gotoxy(4,curnt+3); textbackground(BROWN);
         cprintf("%s",item[curnt]); ch=getch();
         if (ch == 13 || ch == 32)
           {gotoxy(4,curnt+3); textbackground(GREEN);
            cprintf("%s",item[curnt]); textbackground(LIGHTGRAY);
            change=TRUE;
            break;
           }
         gotoxy(4,curnt+3); textbackground(LIGHTGRAY);
         cprintf("%s",item[curnt]);
         if (ch == 27) return change;
         if (ch > 0) continue;
         ch = getch();
         switch (ch)
           {case 72 : --curnt; break;  //up arrow
            case 80 : ++curnt; break;  //down arrow
            case 59 :
              switch(curnt)
                {case 0: case 1: case 2: case 3: help(37); break;
                 case 4: case 5: case 6: case 7: help(38); break;
                 case 8: case 9: case 10: case 11: help(39); break;
                 case 12: case 13: case 14: case 15: help(40); break;
                }
           }
         if(curnt<0) curnt=15;
         if(curnt>15) curnt=0;
        }
      
      if(curnt>=8 && curnt<=15) double_box(30,3,50,8, RED,WHITE,BLUE);
      else double_box(30,12,50,17, RED,WHITE,BLUE);
      gotoxy(4,3); cprintf("Enter New Value");
      _setcursortype(_NORMALCURSOR);
      gotoxy(8,4);
      if((i=get_value(&value))!=ESC && i!=NULL)
        {_setcursortype(_NOCURSOR);
         if(curnt==0) {if(value>.000009) (*hardware).back_x=value; else (*hardware).back_x=0;}
         if(curnt==1) {if(value>.000009) (*hardware).back_y=value; else (*hardware).back_y=0;}
         if(curnt==2) {if(value>.000009) (*hardware).back_z=value; else (*hardware).back_z=0;}
         if(curnt==3) {if(value>.000009) (*hardware).back_a=value; else (*hardware).back_a=0;}
         if(curnt==4 && value>.000009) (*hardware).x_per_step=1/value;
         if(curnt==5 && value>.000009) (*hardware).y_per_step=1/value;
         if(curnt==6 && value>.000009) (*hardware).z_per_step=1/value;
         if(curnt==7 && value>.000009) (*hardware).a_per_step=1/value;
         if((*software).time==SEC)
           {if(curnt==8 && value>.000009) (*hardware).vel_x=value;
            if(curnt==9 && value>.000009) (*hardware).vel_y=value;
            if(curnt==10 && value>.000009) (*hardware).vel_z=value;
           }
         else
           {if(curnt==8 && value>.000009) (*hardware).vel_x=value/60;
            if(curnt==9 && value>.000009) (*hardware).vel_y=value/60;
            if(curnt==10 && value>.000009) (*hardware).vel_z=value/60;
           }
         if((*software).a_time==SEC)
           {if(curnt==11 && value>.000009) (*hardware).vel_a=value;}
         else
           {if(curnt==11 && value>.000009) (*hardware).vel_a=value/60;}
         if((*software).units==IN)
           {if(curnt==12 && value>.000009) (*hardware).accel_x=value*12;
            if(curnt==13 && value>.000009) (*hardware).accel_y=value*12;
            if(curnt==14 && value>.000009) (*hardware).accel_z=value*12;
           }
         else
           {if(curnt==12 && value>.000009) (*hardware).accel_x=value*1000;
            if(curnt==13 && value>.000009) (*hardware).accel_y=value*1000;
            if(curnt==14 && value>.000009) (*hardware).accel_z=value*1000;
           }
         if((*software).a_units==RAD || (*software).a_units==DEG) if(curnt==15) if(value!=0) (*hardware).accel_a=value;
         if((*software).a_units==MM) if(curnt==15) if(value>.000009) (*hardware).accel_a=value*1000;
         if((*software).a_units==IN) if(curnt==15) if(value>.000009) (*hardware).accel_a=value*12;

         //reset maximum velocities
         if((*hardware).x_per_step/2<(*software).dt*(*hardware).vel_x)
           {(*hardware).vel_x=(*hardware).x_per_step/(2*(*software).dt); warning=TRUE;}
         if((*hardware).y_per_step/2<(*software).dt*(*hardware).vel_y)
           {(*hardware).vel_y=(*hardware).y_per_step/(2*(*software).dt); warning=TRUE;}
         if((*hardware).z_per_step/2<(*software).dt*(*hardware).vel_z)
           {(*hardware).vel_z=(*hardware).z_per_step/(2*(*software).dt); warning=TRUE;}
         if((*hardware).a_per_step/2<(*software).dt*(*hardware).vel_a)
           {(*hardware).vel_a=(*hardware).a_per_step/(2*(*software).dt); warning=TRUE;}

         //reset minimum velocity
         (*hardware).min_vel_x=sqrt((*hardware).accel_x*(*hardware).x_per_step);
         (*hardware).min_vel_y=sqrt((*hardware).accel_y*(*hardware).y_per_step);
         (*hardware).min_vel_z=sqrt((*hardware).accel_z*(*hardware).z_per_step);
         (*hardware).min_vel_a=sqrt((*hardware).accel_a*(*hardware).a_per_step);

         //check and reset other speed settings
         if((*hardware).h_spd_x>(*hardware).vel_x) (*hardware).h_spd_x=(*hardware).vel_x;
         if((*hardware).h_spd_y>(*hardware).vel_y) (*hardware).h_spd_y=(*hardware).vel_y;
         if((*hardware).h_spd_z>(*hardware).vel_z) (*hardware).h_spd_z=(*hardware).vel_z;
         if((*hardware).h_spd_a>(*hardware).vel_a) (*hardware).h_spd_a=(*hardware).vel_a;
         if((*software).fjog_x>(*hardware).vel_x) (*software).fjog_x=(*hardware).vel_x;
         if((*software).fjog_y>(*hardware).vel_y) (*software).fjog_y=(*hardware).vel_y;
         if((*software).fjog_z>(*hardware).vel_z) (*software).fjog_z=(*hardware).vel_z;
         if((*software).fjog_a>(*hardware).vel_a) (*software).fjog_a=(*hardware).vel_a;
         if((*software).sjog_x>(*hardware).min_vel_x) (*software).sjog_x=(*hardware).min_vel_x;
         if((*software).sjog_y>(*hardware).min_vel_y) (*software).sjog_y=(*hardware).min_vel_y;
         if((*software).sjog_z>(*hardware).min_vel_z) (*software).sjog_z=(*hardware).min_vel_z;
         if((*software).sjog_a>(*hardware).min_vel_a) (*software).sjog_a=(*hardware).min_vel_a;

         if(warning==TRUE)
              {box(22,19,59,24, RED,BLACK,WHITE,WHITE);
               gotoxy(4,3); cprintf("Speed or Speeds Exceed Max Value");
               gotoxy(4,4); cprintf("Max Value Will Be Used <Any Key>");
               getch(); warning=FALSE;}
        }
      else _setcursortype(_NOCURSOR);
     }
}

void change_units(struct hard_setup *hardware, struct soft_setup *software, int units, int a_units)
{
   if((*software).units==IN && units==MM)
     {(*software).units=MM;
      (*hardware).x_per_step=(*hardware).x_per_step*25.4;
      (*hardware).y_per_step=(*hardware).y_per_step*25.4;
      (*hardware).z_per_step=(*hardware).z_per_step*25.4;
      (*hardware).accel_x=(*hardware).accel_x*25.4;
      (*hardware).accel_y=(*hardware).accel_y*25.4;
      (*hardware).accel_z=(*hardware).accel_z*25.4;
      (*hardware).vel_x=(*hardware).vel_x*25.4;
      (*hardware).vel_y=(*hardware).vel_y*25.4;
      (*hardware).vel_z=(*hardware).vel_z*25.4;
      (*hardware).h_spd_x=(*hardware).h_spd_x*25.4;
      (*hardware).h_spd_y=(*hardware).h_spd_y*25.4;
      (*hardware).h_spd_z=(*hardware).h_spd_z*25.4;
      (*hardware).back_x=(*hardware).back_x*25.4;
      (*hardware).back_y=(*hardware).back_y*25.4;
      (*hardware).back_z=(*hardware).back_z*25.4;
      (*hardware).debo_x=(*hardware).debo_x*25.4;
      (*hardware).debo_y=(*hardware).debo_y*25.4;
      (*hardware).debo_z=(*hardware).debo_z*25.4;
      (*hardware).len_x=(*hardware).len_x*25.4;
      (*hardware).len_y=(*hardware).len_y*25.4;
      (*hardware).len_z=(*hardware).len_z*25.4;