Limit Test code

#define LIMIT_SWITCH_PIN 10

void setup() {
  pinMode(LIMIT_SWITCH_PIN, INPUT);  // No pull-up, since hardware pull-up is used
  Serial.begin(9600);
  pinMode(0, OUTPUT);
}

void loop() {
  if (digitalRead(LIMIT_SWITCH_PIN) == LOW) {
    Serial.println("Limit switch PRESSED");
    digitalWrite(0, HIGH);
  } else {
    Serial.println("Limit switch RELEASED");
    digitalWrite(0, LOW);
  }

  delay(300);  // Debounce delay
}

sample code

#define STEP_PIN 9
#define DIR_PIN 8
#define ENABLE_PIN 3
#define LIMIT_SWITCH_PIN 10  // Match your test code
#define LED_PIN 0

const int stepsPerRevolution = 12000; // 1/32 microstepping mode
const int delayBetweenSteps = 50;   // Microseconds between steps
bool direction = true;               // Initial direction: Forward
bool switchPressed = false;          // To track limit switch state

void setup() {
  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  pinMode(LIMIT_SWITCH_PIN, INPUT);  // Hardware pull-up is used
  pinMode(LED_PIN, OUTPUT);
  
  Serial.begin(9600);
  
  digitalWrite(ENABLE_PIN, LOW); // Enable the motor driver
  digitalWrite(DIR_PIN, direction);
}

void loop() {
  // Read limit switch state
  if (digitalRead(LIMIT_SWITCH_PIN) == LOW) { 
    if (!switchPressed) { 
      direction = !direction; // Reverse direction only once per press
      digitalWrite(DIR_PIN, direction);
      digitalWrite(LED_PIN, HIGH); // Turn on LED
      Serial.println("Limit switch PRESSED - Reversing Direction");
      switchPressed = true;
      delay(500); // Simple debounce
    }
  } else {
    if (switchPressed) {
      Serial.println("Limit switch RELEASED");
      digitalWrite(LED_PIN, LOW); // Turn off LED
      switchPressed = false;
    }
  }

  // Move stepper motor
  digitalWrite(STEP_PIN, HIGH);
  delayMicroseconds(delayBetweenSteps);
  digitalWrite(STEP_PIN, LOW);
  delayMicroseconds(delayBetweenSteps);
}

I2C test (Master)

#include <Wire.h>

#define SLAVE_ADDR 0x08
volatile byte receivedData = 0;

void receiveEvent(int bytes) {
  receivedData = Wire.read();  // Read incoming byte
}

void requestEvent() {
  Wire.write(0x55);  // Send ACK byte
}

void setup() {
  Wire.begin(SLAVE_ADDR);
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent);
}

void loop() {
  // Optional: Blink LED on receiving
}

I2C test (Slave)

#include <Wire.h>

#define SLAVE_ADDR 0x08  // Same on both sides

void setup() {
  Wire.begin(21, 22); // SDA, SCL for ESP32
  Serial.begin(115200);
  delay(1000);
}

void loop() {
  Serial.println("Sending 0xAA to Slave");

  Wire.beginTransmission(SLAVE_ADDR);
  Wire.write(0xAA);
  Wire.endTransmission();

  delay(100);

  Wire.requestFrom(SLAVE_ADDR, 1);  // Ask for 1 byte
  if (Wire.available()) {
    byte response = Wire.read();
    Serial.print("Slave Responded with: 0x");
    Serial.println(response, HEX);
  } else {
    Serial.println("No response from Slave");
  }

  delay(1000);
}

1st iteration (just up and down movement )

master

#include <Wire.h>

#define SLAVE_ADDR 0x08

#define STEP_PIN 9
#define DIR_PIN 8
#define ENABLE_PIN 3
#define LIMIT_SWITCH_PIN 10
#define LED_PIN 0

volatile byte command = 0;
volatile bool runMotor = false;

void receiveEvent(int bytes) {
  if (Wire.available()) {
    command = Wire.read();

    if (command == 0x01) {        // Move Forward
      digitalWrite(DIR_PIN, HIGH);
      runMotor = true;
    } else if (command == 0x02) { // Move Reverse
      digitalWrite(DIR_PIN, LOW);
      runMotor = true;
    } else if (command == 0x03) { // Stop Motor
      runMotor = false;
    }
  }
}

void requestEvent() {
  Wire.write(0xA5); // Always send ACK
}

void setup() {
  Wire.begin(SLAVE_ADDR);
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent);

  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  pinMode(LIMIT_SWITCH_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);

  digitalWrite(ENABLE_PIN, LOW); // Enable motor driver
  digitalWrite(DIR_PIN, HIGH);   // Default direction
}

void loop() {
  if (runMotor) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(100); // Step pulse width
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(100);
  }

  // Optional: Limit switch handling
  if (digitalRead(LIMIT_SWITCH_PIN) == LOW) {
    digitalWrite(LED_PIN, HIGH); // Hit
  } else {
    digitalWrite(LED_PIN, LOW); // Not hit
  }
}

slave