// CutterZsaw for for LLM Foam Cutter
// Motion: cut downwards on Z, rotate 90°, repeat 4 times = 4 side faces, then cut top/bottom  faces on X



// Pins Mapping
#define X_STEP 17  // X motor STEP pin
#define X_DIR  16  // X motor DIR pin
#define ENX    18  // X motor Enable pin

#define Z_STEP 20  // Z motor STEP pin
#define Z_DIR  19  // Z motor DIR pin
#define ENZ    21  // Z motor Enable pin

#define Y_STEP 5   // Y motor STEP pin
#define Y_DIR  6   // Y motor DIR pin
#define ENY    4   // Y motor Enable pin

// Limit Switches
#define LIMIT_X 9
#define LIMIT_Z 11

// Motion parameters
const int steps_per_mm_z         = 400;  // Z motor 1/16 microstepping, 8 mm lead screw
const int steps_per_mm_x         = 80;   // X motor 1/16 microstepping, rack & pinion
const int rotation_steps_per_rev = 3200; // Y motor 1/16 microstepping
const int cube_size_mm           = 30;   // Cube size in mm

void setup() {
  Serial.begin(9600); // Start serial communication

  // Setup limit switches
  pinMode(LIMIT_X, INPUT_PULLUP);
  pinMode(LIMIT_Z, INPUT_PULLUP);

   // Stepper pins
  pinMode(X_STEP, OUTPUT); pinMode(X_DIR, OUTPUT); pinMode(ENX, OUTPUT);
  pinMode(Y_STEP, OUTPUT); pinMode(Y_DIR, OUTPUT); pinMode(ENY, OUTPUT);
  pinMode(Z_STEP, OUTPUT); pinMode(Z_DIR, OUTPUT); pinMode(ENZ, OUTPUT);

  // Enable motors
  digitalWrite(ENX, LOW);
  digitalWrite(ENY, LOW);
  digitalWrite(ENZ, LOW);

  Serial.println("Waiting 2 seconds before homing...");
  delay(2000);

  homeX();
  delay(5000);
  homeZ();
  delay(50);
  Serial.println("Waiting 2 seconds... Homing complete. Ready to cut!");
  delay(1000);

  // back off from switches
  Serial.println("Reference move: back off away from switches");
  moveZ(true, steps_per_mm_z * 65); //upwards
  delay(50);
  moveX(false, steps_per_mm_x * 123); //backwards
  delay(50);
  moveZ(false, steps_per_mm_z * 13); //downwards
  delay(2000);

  //to start the cut
  moveX(true, steps_per_mm_x * 15); //forwards

  runCubeCut();

  // done
  while (true) {}
}

void loop() {
  // Nothing!
}
// Homing functions
// Home Z‑axis by moving up until limit switch triggers

void homeZ() {
  Serial.print("Homing Z...");
  digitalWrite(Z_DIR, LOW);           // down
  while (digitalRead(LIMIT_Z) == HIGH) {
    step(Z_STEP);
    delayMicroseconds(200);
  }
  // bounce back 1 mm
  digitalWrite(Z_DIR, HIGH);          // up
  for (int i = 0; i < steps_per_mm_z; i++) {
    step(Z_STEP);
    delayMicroseconds(200);
  }
  Serial.println(" homed and bounced");
}

// Home X‑axis by moving backward until limit switch triggers
void homeX() {
  Serial.print("Homing X...");
  digitalWrite(X_DIR, HIGH);          // forward
  while (digitalRead(LIMIT_X) == HIGH) {
    step(X_STEP);
    delayMicroseconds(200);
  }
  // bounce back 1 mm
  digitalWrite(X_DIR, LOW);           // backward
  for (int i = 0; i < steps_per_mm_x; i++) {
    step(X_STEP);
    delayMicroseconds(200);
  }
  Serial.println(" X homed and bounced.");
}

void runCubeCut() {
    for (int face = 0; face < 4; face++) {
      // side cut
      moveZ(false,  steps_per_mm_z * cube_size_mm); //down
      delay(200);
      moveZ(true, steps_per_mm_z * cube_size_mm); //up
      delay(200);
      rotateY(true, rotation_steps_per_rev / 4); //rotate 90°
      delay(250);
    }
  
      // top/bottom cut
      moveZ(false,  steps_per_mm_z * cube_size_mm); //down
      delay(200);
      moveX(false, steps_per_mm_x * cube_size_mm); //backward
      delay(250);
      moveZ(true,  steps_per_mm_z * cube_size_mm*2); //up
      delay(200);
  
      Serial.println("Cube cut complete.");
    
  }
  
  // Rotate Y‑axis table CW or CCW
  void rotateY(bool clockwise, int steps) {
    digitalWrite(Y_DIR, clockwise ? HIGH : LOW);
    for (int i = 0; i < steps; i++) {
      step(Y_STEP);
      delayMicroseconds(200);
    }
  }
  
  // Move Z‑axis alone (down/up)
  void moveZ(bool down, int steps) {
    digitalWrite(Z_DIR, down ? HIGH : LOW);
    for (int i = 0; i < steps; i++) {
      step(Z_STEP);
      delayMicroseconds(200);
    }
  }
  
  // Move X‑axis alone (inward/outward)
  void moveX(bool inward, int steps) {
    digitalWrite(X_DIR, inward ? HIGH : LOW);
    for (int i = 0; i < steps; i++) {
      step(X_STEP);
      delayMicroseconds(200);
    }
  }
  
  // Generic step pulse generator
  void step(int pin) {
    digitalWrite(pin, HIGH);
    delayMicroseconds(60);
    digitalWrite(pin, LOW);
    delayMicroseconds(600);
  }
  
                                
                            

// Pi Pico 2W Version: Diagonal Cube Cutter for LLM Foam Cutter
// Cuts four diagonal faces (Z+X sync), then top & bottom faces horizontally

// Pins Mapping
#define X_STEP   17  // X motor STEP pin
#define X_DIR    16  // X motor DIR pin
#define ENX      18  // X motor Enable pin

#define Z_STEP   20  // Z motor STEP pin
#define Z_DIR    19  // Z motor DIR pin
#define ENZ      21  // Z motor Enable pin

#define Y_STEP    5  // Y motor STEP pin
#define Y_DIR     6  // Y motor DIR pin
#define ENY       4  // Y motor Enable pin

// Limit Switches and Hot Wire Pin
#define LIMIT_X   9  // X-axis limit switch pin
#define LIMIT_Z   8  // Z-axis limit switch pin
#define HOTWIRE   7  // Hot wire MOSFET control pin

// Safety Buttons
#define BTN_HOME  11 // Button to home axes
#define BTN_CUT   12 // Button to start cube cutting

// Motion settings
const int steps_per_mm_z   = 200;         // Z: 1/8 microstepping → 1600/8 = 200 µsteps/mm
const int steps_per_mm_x   = 41;          // X: ≈1600 microsteps / 39.5 mm ≃ 40.5 steps/mm
const int rotation_steps_per_rev   = 200;       // Y: 90° rotation = 200 microsteps/rev 
const int cube_size_mm     = 40;          // Cube side length in mm
const float inset_mm = cube_size_mm / 1.41421356f; // from Pythagorean theorem  → 40 mm / √2  ≃ 28.28 mm

void setup() {
  Serial.begin(9600);             // Start serial monitor

  // Limit switch inputs
  pinMode(LIMIT_X, INPUT_PULLUP);
  pinMode(LIMIT_Z, INPUT_PULLUP);

  // Motor driver outputs
  for (int p : {X_STEP, X_DIR, ENX,
                Y_STEP, Y_DIR, ENY,
                Z_STEP, Z_DIR, ENZ})
    pinMode(p, OUTPUT);

  // Hot‑wire control
  pinMode(HOTWIRE, OUTPUT);
  digitalWrite(HOTWIRE, LOW);       // Hot wire OFF initially

  // Safety buttons
  pinMode(BTN_HOME, INPUT);
  pinMode(BTN_CUT,  INPUT);

  // Enable all drivers
  digitalWrite(ENX, LOW);
  digitalWrite(ENY, LOW);
  digitalWrite(ENZ, LOW);

  Serial.println("Ready: BTN_HOME→home, BTN_CUT→cut cube.");
}

void loop() {
  // If Home button pressed, home X & Z:
  if (digitalRead(BTN_HOME) == LOW) {
    Serial.println("BTN_HOME pressed → homing axes");
    homeZ(); delay(300);
    homeX(); delay(300);
    Serial.println("Homing done");
    while(digitalRead(BTN_HOME)==LOW) delay(10); // simple debounce/wait release
  }

  // If Cut button pressed, perform the full diagonal cube cut:
  if (digitalRead(BTN_CUT) == LOW) {
     homeZ();
     homeX(); // ensure we start from zero position!
    Serial.println("BTN_CUT pressed → starting diagonal cube cut");
    digitalWrite(HOTWIRE, HIGH);     // Turn hot wire ON

   // Four bevel cuts, one per corner
    for (int i = 0; i < 4; i++) {
      diagonalCut(inset_mm);                   // true 45° over inset_mm
      delay(500);
      moveZ(false, int(steps_per_mm_z * inset_mm)); // lift back up
      delay(200);
      rotateY(true, rotation_steps_per_rev / 4);              // swing to next corner
      delay(800);
    }
    // Top face horizontally 
     moveZ(false, int(steps_per_mm_z * cube_size_mm));  // Raise wire to top face
    delay(500);
    moveX(true, steps_per_mm_x * cube_size_mm);          // X forward top cut
    delay(800);

    // Bottom face horizontally 
    moveZ(true, steps_per_mm_z * cube_size_mm);          // Z down full cube height
    delay(500);
    moveX(false, steps_per_mm_x * cube_size_mm);         // X back bottom cut
    delay(800);

    digitalWrite(HOTWIRE, LOW);    // Turn hot wire OFF
    Serial.println("Cube Cut Done. Halting.");
    while (1) delay(10);           // Stop further execution
  }
}

// True 45° inset bevel, Bresenham‑style
void diagonalCut(float mm) {
  int sx = int(mm * steps_per_mm_x + 0.5f);
  int sz = int(mm * steps_per_mm_z + 0.5f);
  int err = sx - sz;

  digitalWrite(X_DIR, HIGH);  // inward
  digitalWrite(Z_DIR, HIGH);  // downward

  while (sx > 0 || sz > 0) {
    int e2 = err * 2;
    if (e2 > -sz && sx > 0) {
      step(X_STEP);
      err -= sz;
      sx--;
    }
    if (e2 <  sx && sz > 0) {
      step(Z_STEP);
      err += sx;
      sz--;
    }
    delayMicroseconds(500);
  }
}

// Home Z‑axis by moving up until limit switch triggers
void homeZ() {
  digitalWrite(Z_DIR, LOW);          // Z upward
  while (digitalRead(LIMIT_Z) == HIGH) {
    step(Z_STEP);
    delayMicroseconds(700);
  }
  Serial.println("Z homed");
}

// Home X‑axis by moving backward until limit switch triggers
void homeX() {
  digitalWrite(X_DIR, LOW);          // X backward
  while (digitalRead(LIMIT_X) == HIGH) {
    step(X_STEP);
    delayMicroseconds(700);
  }
  Serial.println("X homed");
}

// Rotate Y‑axis table CW or CCW
void rotateY(bool clockwise, int steps) {
  digitalWrite(Y_DIR, clockwise ? HIGH : LOW);
  for (int i = 0; i < steps; i++) step(Y_STEP);
}

// Move Z‑axis alone (down/up)
void moveZ(bool down, int steps) {
  digitalWrite(Z_DIR, down ? HIGH : LOW);
  for (int i = 0; i < steps; i++) step(Z_STEP);
}

// Move X‑axis alone (inward/outward)
void moveX(bool inward, int steps) {
  digitalWrite(X_DIR, inward ? HIGH : LOW);
  for (int i = 0; i < steps; i++) step(X_STEP);
}

// Generic step pulse generator
void step(int pin) {
  digitalWrite(pin, HIGH);
  delayMicroseconds(500);
  digitalWrite(pin, LOW);
  delayMicroseconds(500);
}
                                
                            

// Pi Pico 2W Version: Wave Cut Mode for LLM Foam Cutter 
// Z-axis performs wavy motion while descending
// X-axis nudges in and out for slight ripple along cut

// Pins Mapping
#define X_STEP   17  // X motor STEP pin
#define X_DIR    16  // X motor DIR pin
#define ENX      18  // X motor Enable pin

#define Z_STEP   20  // Z motor STEP pin
#define Z_DIR    19  // Z motor DIR pin
#define ENZ      21  // Z motor Enable pin

#define Y_STEP    5  // Y motor STEP pin
#define Y_DIR     6  // Y motor DIR pin
#define ENY       4  // Y motor Enable pin

// Limit Switches and Hot Wire Pin
#define LIMIT_X   9  // X-axis limit switch pin
#define LIMIT_Z   8  // Z-axis limit switch pin
#define HOTWIRE   7  // Hot wire MOSFET control pin

// Safety Buttons
#define BTN_HOME  11 // Button to home axes
#define BTN_CUT   12 // Button to start cube cutting

// Motion Parameters
const int steps_per_mm_z    = 200;  // Z: 1/8 microstepping → 1600/8 = 200 steps per mm
const int steps_per_mm_x    = 41;   // X: ≈1600 microsteps / 39.5 mm ≃ 40.5 steps/mm
const int rotation_steps_per_rev       = 200;// Y: 90° rotation = 200 microsteps/rev 
const int nudge_mm = 1;
const int   nudge_steps = nudge_mm * steps_per_mm_x;
const int cube_size_mm      = 40;   // Cube side length in mm

void setup() {
  Serial.begin(9600);           // Start serial communication

  // Set pins for limit switches
  pinMode(LIMIT_X, INPUT_PULLUP);
  pinMode(LIMIT_Z, INPUT_PULLUP);

  // Set pins for motors
  pinMode(X_STEP, OUTPUT); pinMode(X_DIR, OUTPUT); pinMode(ENX, OUTPUT);
  pinMode(Y_STEP, OUTPUT); pinMode(Y_DIR, OUTPUT); pinMode(ENY, OUTPUT);
  pinMode(Z_STEP, OUTPUT); pinMode(Z_DIR, OUTPUT); pinMode(ENZ, OUTPUT);

  // Set hot wire output
  pinMode(HOTWIRE, OUTPUT); digitalWrite(HOTWIRE, LOW); // Start with hot wire OFF

  // Set safety buttons
  pinMode(BTN_HOME, INPUT);
  pinMode(BTN_CUT,  INPUT);

  // Enable all motor drivers
  digitalWrite(ENX, LOW);
  digitalWrite(ENY, LOW);
  digitalWrite(ENZ, LOW);

  // Initial homing at power‑up
  Serial.println("Initial homing...");
  homeZ(); delay(300);          // Home Z-axis
  homeX(); delay(300);          // Home X-axis
  Serial.println("Ready: BTN_HOME→home, BTN_CUT→wave cut.");
}

void loop() {
  // If Home button pressed, re‑home axes:
  if (digitalRead(BTN_HOME) == LOW) {
    Serial.println("BTN_HOME pressed → homing axes");
    homeZ(); delay(300);
    homeX(); delay(300);
    Serial.println("Homing done");
    while (digitalRead(BTN_HOME) == LOW) delay(10); // wait release
  }

  // If Cut button pressed, perform the wave‑cube cut:
  if (digitalRead(BTN_CUT) == LOW) {
    homeZ();
    homeX(); // ensure we start from zero position!
    Serial.println("BTN_CUT pressed → starting wave cube cut");
    digitalWrite(HOTWIRE, HIGH); // Turn hot wire ON

    // Four wavy side faces
    for (int face = 0; face < 4; face++) {
      waveCut(cube_size_mm);                         // Wave‑pattern descent
      delay(300);
      moveZ(false, steps_per_mm_z * cube_size_mm);   // Return Z to top
      delay(200);
      rotateY(true,  rotation_steps_per_rev / 4);                    // Rotate table 90°
      delay(400);
    }

    // Top face horizontal cut
    moveZ(false, steps_per_mm_z * cube_size_mm);     // Ensure Z at top surface
    moveX(true,  steps_per_mm_x * cube_size_mm);     // X forward across top
    delay(500);

    // Bottom face horizontal cut
    moveZ(true,  steps_per_mm_z * cube_size_mm);     // Lower Z full cube height
    delay(200);
    moveX(false, steps_per_mm_x * cube_size_mm);     // X backward across bottom
    delay(500);

    digitalWrite(HOTWIRE, LOW);   // Turn hot wire OFF
    Serial.println("Wave Cube Cut Done. Halting.");
    while (1) delay(10);          // Stop execution
  }
}

// Wave side‑face cut 
void waveCut(int mm) {
  digitalWrite(Z_DIR, HIGH);                 // Z downward
  digitalWrite(X_DIR, HIGH);                 // X inward
  for (int row = 0; row < mm; row++) {
    // descend 1 mm
    for (int z = 0; z < steps_per_mm_z; z++) step(Z_STEP);
     // nudge X every 4 mm (forward on row % 4 == 0, back on row % 4 == 2):
    if (row % 4 == 0) {
      for (int i = 0; i < nudge_steps; i++) step(X_STEP);
    } 
    else if (row % 4 == 2) {
      digitalWrite(X_DIR, LOW);
      for (int i = 0; i < nudge_steps; i++) step(X_STEP);
      digitalWrite(X_DIR, HIGH);
    }
  }
}

// Homing Z-axis by moving up until limit switch triggers
void homeZ() {
  digitalWrite(Z_DIR, LOW);                 // Z upward
  while (digitalRead(LIMIT_Z) == HIGH) {
    step(Z_STEP);
    delayMicroseconds(700);
  }
  Serial.println("Z homed");
}

// Homing X-axis by moving backward until limit switch triggers
void homeX() {
  digitalWrite(X_DIR, LOW);                 // X backward
  while (digitalRead(LIMIT_X) == HIGH) {
    step(X_STEP);
    delayMicroseconds(700);
  }
  Serial.println("X homed");
}

// Rotate table (Y-axis rotation) CW or CCW
void rotateY(bool cw, int steps) {
  digitalWrite(Y_DIR, cw ? HIGH : LOW);
  for (int i = 0; i < steps; i++) step(Y_STEP);
}

// Move Z-axis up/down by `steps` pulses
void moveZ(bool down, int steps) {
  digitalWrite(Z_DIR, down ? HIGH : LOW);
  for (int i = 0; i < steps; i++) step(Z_STEP);
}

// Move X-axis inward/outward by `steps` pulses
void moveX(bool inw, int steps) {
  digitalWrite(X_DIR, inw ? HIGH : LOW);
  for (int i = 0; i < steps; i++) step(X_STEP);
}

// Generic step pulse generator
void step(int pin) {
  digitalWrite(pin, HIGH);
  delayMicroseconds(500);
  digitalWrite(pin, LOW);
  delayMicroseconds(500);
}