;
;                              YADRO
;
;                   Configuration file for a mill
;
;           For more comments, see www.motor-manufaktur.de
;
; *************************************************************************
; *** Demo                                                              ***
; ***                                                                   ***
; *** If you want to use YADRO without the digital interface, (demo)    ***
; *** you have to comment out (put ";" at the leftmost of a line)       ***
; *** the next 5 lines (starting with "Interp: and ending with ":EndI   ***
; *************************************************************************
Interp:
  display("ConnectAs", 0, 0);
  display("ConnectAs", 2, 1);
  display("ConnectAs", 2, 2);
:EndI
;
; *************************************************************************
; *** Internal macros                                                   ***
; *************************************************************************
;
; *** var decl.
Interp:
  fvar intStatusAbsX, intStatusAbsY, intStatusAbsZ;
  fvar intStatusAbsXSave, intStatusAbsYSave, intStatusAbsZSave;
:EndI
; *** macros
; ---------------------------------------
Macro:internalStatusAbsX
  intStatusAbsX = 1;
  display("Status", 1, 2, "abs");
:EndM
; ---------------------------------------
Macro:internalStatusAbsY
  intStatusAbsY = 1;
  display("Status", 2, 2, "abs");
:EndM
; ---------------------------------------
Macro:internalStatusAbsZ
  intStatusAbsZ = 1;
  display("Status", 3, 2, "abs");
:EndM
; ---------------------------------------
Macro:internalStatusRelX
  intStatusAbsX = 0;
  display("Status", 1, 2, "rel");
:EndM
; ---------------------------------------
Macro:internalStatusRelY
  intStatusAbsY = 0;
  display("Status", 2, 2, "rel");
:EndM
; ---------------------------------------
Macro:internalStatusRelZ
  intStatusAbsZ = 0;
  display("Status", 3, 2, "rel");
:EndM
; ---------------------------------------
Macro:internalStatusAbsSave
  intStatusAbsXSave = intStatusAbsX;
  intStatusAbsYSave = intStatusAbsY;
  intStatusAbsZSave = intStatusAbsZ;
:EndM
; ---------------------------------------
Macro:internalStatusAbsRestore
  if (intStatusAbsXSave) { execmacro("internalStatusAbsX") }
  else { execmacro("internalStatusAbsX") }

  if (intStatusAbsYSave) { execmacro("internalStatusAbsY") }
  else { execmacro("internalStatusAbsY") }

  if (intStatusAbsZSave) { execmacro("internalStatusAbsZ") }
  else { execmacro("internalStatusAbsZ") }
:EndM
; ---------------------------------------
Macro:internalMetric
  fvar count;

  Dev0Scaling = Dev0ScalingMetric;
  Dev1Scaling = Dev1ScalingMetric;
  Dev2Scaling = Dev2ScalingMetric;
  UnitScaling = 1;

  count = 1;
  while (count <= 3) {
    display("Status",       count, 1, "mm");
    display("Precision",    count, PrecisionMetric);
    display("SecPrecision", count, PrecisionMetric);
    count = count + 1;
  }
:EndM
; ---------------------------------------
Macro:internalInch
  fvar count;

  Dev0Scaling = Dev0ScalingInch;
  Dev1Scaling = Dev1ScalingInch;
  Dev2Scaling = Dev2ScalingInch;
  UnitScaling = 1 / 25.4;
  
  count = 1;
  while (count <= 3) {
    display("Status",       count, 1, "inch");
    display("Precision",    count, PrecisionInch);
    display("SecPrecision", count, PrecisionInch);
    count = count + 1;
  }
:EndM
; ---------------------------------------
Macro:internalZAX
  senddevice("c0C");
:EndM
; ---------------------------------------
Macro:internalZAY
  senddevice("c1C");
:EndM
; ---------------------------------------
Macro:internalZAZ
  senddevice("c2C");
:EndM
; ---------------------------------------
Macro:internalZAA
  execmacro("internalZAX");
  execmacro("internalZAY");
  execmacro("internalZAZ");
:EndM
; ---------------------------------------
Macro:internalFTA
    senddevice("c0D");
    senddevice("c0C");

    senddevive("c1D");
    senddevice("c1C");

    senddevice("c2D");
    senddevice("c2C");
:EndM
; *****************************************************************
; *** user macros                                               ***
; *****************************************************************
;
Macro:SM Metric
  execmacro("internalMetric");
:EndM:BindKey:F1
; ---------------------------------------
Macro:SI Inch
  execmacro("internalInch");
:EndM:BindKey:F2
; ---------------------------------------
Macro:ZA Zero all axes
  ShdwOffs0 = -(Dev0 * Dev0Scaling * SignX * UnitScaling);
  ShdwOffs1 = -(Dev1 * Dev1Scaling * SignY * UnitScaling);
  ShdwOffs2 = -(Dev2 * Dev2Scaling * SignZ * UnitScaling);

  OffsetX = 0;
  OffsetY = 0;
  OffsetZ = 0;
:EndM:BindKey:F10
; ---------------------------------------
Macro:HCXY Hole circle X
  fvar HCHoles, HCAngle, HCDiam;
  fvar HCCenterX, HCCenterY;
  fvar HCOldOffsX, HCOldOffsY;
  fvar HCIncrement, HCIAngle, HCSteps;

  if (HCCenterX == 0) { HCCenterX = Disp1 }
  if (HCCenterY == 0) { HCCenterY = Disp2 }
  if (HCHoles == 0) { HCHoles = 4; }

  if (input("Hole Circle",
         "Center X (Disp1):", HCCenterX,
         "Center Y (Disp2):", HCCenterY,
          "Number of holes:", HCHoles,
                 "Diameter:", HCDiam,
           "Starting angle:", HCAngle)) {

    HCOldOffsX = OffsetX;
    HCOldOffsY = OffsetY;
    execmacro("internalStatusAbsSave");
    execmacro("internalStatusRelX");
    execmacro("internalStatusRelY");

    HCIncrement = 360 / HCHoles;
    HCIAngle = HCAngle;
    HCSteps = HCHoles;
    while (HCSteps > 0) {
      OffsetX = HCCenterX;
      OffsetY = HCCenterY;
      OffsetX = OffsetX + sin(HCIAngle) * HCDiam / 2;
      OffsetY = OffsetY + cos(HCIAngle) * HCDiam / 2;

      if (!getnext("Move to X/Y = 0")) { break; }

      HCIAngle = HCIAngle + HCIncrement;
      HCSteps = HCSteps - 1;
    }

    OffsetX = HCOldOffsX;
    OffsetY = HCOldOffsY;

    execmacro("internalStatusAbsRestore");
  }
:EndM:BindKey:F3
; ---------------------------------------
Macro:AX Absolute X
  OffsetX = 0;
  execmacro("internalStatusAbsX");
:EndM
; ---------------------------------------
Macro:AY Absolute Y
  OffsetY = 0;
  execmacro("internalStatusAbsY");
:EndM
; ---------------------------------------
Macro:AZ Absolute Z
  OffsetZ = 0;
  execmacro("internalStatusAbsZ");
:EndM
; ---------------------------------------
Macro:AA Absolute all (X,Y,Z)
  OffsetX = 0;
  OffsetY = 0;
  OffsetZ = 0;
  execmacro("internalStatusAbsX");
  execmacro("internalStatusAbsY");
  execmacro("internalStatusAbsZ");
:EndM
; ---------------------------------------
Macro:ZX Relative X, w. curr pos as 0
  OffsetX = OffsetX - Disp1;
  execmacro("internalStatusRelX");
:EndM
; ---------------------------------------
Macro:ZY Relative Y, w. curr pos as 0
  OffsetY = OffsetY - Disp2;
  execmacro("internalStatusRelY");
:EndM
; ---------------------------------------
Macro:ZZ Relative Z, w. curr pos as 0
  OffsetZ = OffsetZ -Disp3;
  execmacro("internalStatusRelZ");
:EndM
; ---------------------------------------
Macro:SX Step rel. offs. by value
  fvar SXoffs;
  if (input("Offset rel-X by value", "offset:", SXoffs)) {
    execmacro("internalStatusRelX");
    OffsetX = OffsetX + SXoffs;
  }
:EndM
; ---------------------------------------
Macro:SY Step rel. offs. by value
  fvar syOffs;
  if (input("Offset rel-Y by value", "offset:", syOffs)) {
    execmacro("internalStatusRelY");
    OffsetY = OffsetY + syOffs;
  }
:EndM
; ---------------------------------------
Macro:SZ Step rel. offs. by value
  fvar szOffs;
  if (input("Offset rel-Z by value", "offset:", szOffs)) {
    execmacro("internalStatusRelZ");
    OffsetZ = OffsetZ + szOffs;
  }
:EndM
; ---------------------------------------
Macro:OX Offset abs X by value
  fvar oxOffs;
  if (input("Offset X by value", "offset:", oxOffs)) {
    OffsetX = oxOffs;
    execmacro("internalStatusRelX");
  }
:EndM
; ---------------------------------------
Macro:OY Offset abs Y by value
  fvar oyOffs;
  if (input("Offset Y by value", "offset:", oyOffs)) {
    OffsetY = oyOffs;
    execmacro("internalStatusRelY");
  }
:EndM
; ---------------------------------------
Macro:OZ Offset abs Z by value
  fvar ozOffs;
  if (input("Offset Z by value", "offset:", ozOffs)) {
    OffsetZ = ozOffs;
    execmacro("internalStatusRelZ");
  }
:EndM
; ---------------------------------------
Macro:C2PXY Center w. 2 points XY-plane
  fvar c2pX1, c2pX2, c2pY1, c2pY2;
  fvar c2poox, c2pooy;

  c2pX1 = Disp1;
  c2pY1 = Disp2;
  if (input("2 point center. First point is current position")) {
    if (getnext("Move to 2nd point")) {
      c2pX2 = Disp1;
      c2pY2 = Disp2;

      c2poox = OffsetX;
      c2pooy = OffsetY;
      execmacro("internalStatusAbsSave");
      execmacro("internalStatusRelX");
      execmacro("internalStatusRelY");

      OffsetX = OffsetX - c2pX1 + (c2pX1 - c2pX2) / 2;
      OffsetY = OffsetY - c2PY1 + (c2pY1 - c2pY2) / 2;


      getnext("move to X/Y = 0 for center");
      OffsetX = c2poox;
      OffsetY = c2pooy;

      execmacro("internalStatusAbsRestore");
    }
  }
:EndM
; ---------------------------------------
Macro:-X Change sign X
  SignX = -SignX;
  if (SignX < 0) { display("Status", 1, 3, "NEG"); }
  if (SignX > 0) { display("Status", 1, 3, ""); }
:Endm
; ---------------------------------------
Macro:-Y Change sign Y
  SignY = SignY * -1;
  if (SignY < 0) { display("Status", 2, 3, "NEG"); }
  if (SignY > 0) { display("Status", 2, 3, ""); }
:Endm
; ---------------------------------------
Macro:-Z Change sign Z
  SignZ = SignZ * -1;
  if (SignZ < 0) { display("Status", 3, 3, "NEG"); }
  if (SignZ > 0) { display("Status", 3, 3, ""); }
:Endm
; ---------------------------------------
; ***********************************************************************
; *** Setup/Configuration of YADRO                                                  ***
; ***********************************************************************
Interp:
  fvar Dev0ScalingMetric, Dev0ScalingInch;
  fvar Dev1ScalingMetric, Dev1ScalingInch;
  fvar Dev2ScalingMetric, Dev2ScalingInch;
  fvar PrecisionMetric, PrecisionInch;
  fvar OffsetX, OffsetY, OffsetZ;
  fvar ShdwOffs0, ShdwOffs1, ShdwOffs2;
  fvar SignX, SignY, SignZ;
  fvar Dev0Scaling, Dev1Scaling, Dev2Scaling;
  fvar UnitScaling;

  Dev0ScalingMetric = 1 / 100;
  Dev0ScalingInch =   1 / (100 * 25.4);

  Dev1ScalingMetric = 1 / (-20480 / 25.4);
  Dev1ScalingInch   = 1 / -20480;

  Dev2ScalingMetric = Dev1ScalingMetric;
  Dev2ScalingInch   = Dev1ScalingInch;

  PrecisionMetric = 2;
  PrecisionInch = 4;

  SignX = 1;
  SignY = 1;
  SignZ = 1;
  UnitScaling = 1;


  display("AxName", 1, "X");
  display("AxName", 2, "Y");
  display("AxName", 3, "Z");
  display("AxSecName", 1, "X (abs)");
  display("AxSecName", 2, "Y (abs)");
  display("AxSecName", 3, "Z (abs)");
  display("Average",    "GAT", 20, 0.05);
  display("SecAverage", "WA",  20, 0.85);

  execmacro("internalMetric");
  display("Source", 1, "Dev0 * Dev0Scaling * SignX + (ShdwOffs0 + OffsetX) * UnitScaling");
  display("Source", 2, "Dev1 * Dev1Scaling * SignY + (ShdwOffs1 + OffsetY) * UnitScaling");
  display("Source", 3, "Dev2 * Dev2Scaling * SignZ + (ShdwOffs2 + OffsetZ) * UnitScaling");

  display("SecSource", 1, "Dev0 * Dev0Scaling + ShdwOffs0 * UnitScaling");
  display("SecSource", 2, "Dev1 * Dev1Scaling + ShdwOffs1 * UnitScaling");
  display("SecSource", 3, "Dev2 * Dev2Scaling + ShdwOffs2 * UnitScaling");

  execmacro("internalStatusAbsX");
  execmacro("internalStatusAbsY");
  execmacro("internalStatusAbsZ");
:EndI
; ********************************************************************
; *** Final setup of YADRO                                         ***
; ********************************************************************
Interp:
  if (input("Initialize Devices?")) {
    if (input("Hardware-Zero devices?")) {
      execmacro("internalZAA");
    }
    if (input("Switch to FT-Mode?")) {
      execmacro("internalFTA");
    }
  }
:endI