Output Devices

KiCad Optimization: I discovered an option to pre-configure track widths, which saves significant time during design.

Predefined track configuration.

Design rules must set the minimum value among all defaults to avoid errors.

Design Note: This must be done before routing, as flipping creates a mirror effect on the pin layout.

Routing Challenges

Managing connections for the DRV8825 was the biggest challenge due to the high density of pins, which caused traces to cross frequently.

How I solved my routing problem:

Managing connections for the DRV8825 was a complex task due to the high density of pins and the need for thick power traces (1.5mm). I encountered two main obstacles:

• Trace Intersections: To resolve the frequent crossing of signal lines without using a double-sided board, I implemented zero-ohm resistors (R1-R10) as jumpers. This allowed me to "hop" over power traces while maintaining the signal integrity of the micro-stepping and enable lines.
• The Vref Tuning Loop: During the hardware setup, I noticed the motors were vibrating but not turning. The solution was a precise calibration using a multimeter. I placed the positive probe on the driver's potentiometer and the negative probe on GND, adjusting until reaching 0.6V. This specific value provides the necessary 1.2A current (71% of nominal) required for the NEMA 17 to overcome its holding torque.

Zero-ohm (0Ω) resistors are your best allies! They form a physical bridge that allows your trace to continue its path while simultaneously letting another trapped trace cross right underneath it.
NOTE: In electronics design, this is not considered the cleanest or most formal industry practice, but it is an incredibly useful and practical workaround for single-sided boards.

#include  // Includes the AccelStepper library for advanced, non-blocking motor control with acceleration ramps

#define STEP_PIN_1    D1  // Maps GPIO D1 to control the speed and step generation of Driver 1 via square-wave pulses
#define DIR_PIN_1     D0  // Maps GPIO D0 to set the rotation direction of Motor 1 (HIGH for clockwise, LOW for CCW)
#define ENABLE_PIN_1  D3  // Maps GPIO D3 to manage the power state of Driver 1's internal coil bridges
#define STEP_PIN_2    D8  // Maps GPIO D8 to control the speed and step generation of Driver 2 via square-wave pulses
#define DIR_PIN_2     D7  // Maps GPIO D7 to set the rotation direction of Motor 2 (HIGH for clockwise, LOW for CCW)
#define ENABLE_PIN_2  D6  // Maps GPIO D6 to manage the power state of Driver 2's internal coil bridges

#define FULL_STEPS_PER_REV 200 // Defines the physical motor resolution (standard 1.8 degree step angle equals 200 full steps per revolution)
#define MICROSTEP          1   // Set to 1 because M0, M1, and M2 pins are disconnected, defaulting the driver to Full-Step mode

const long TEST_STEPS = FULL_STEPS_PER_REV * MICROSTEP; // Calculates total step pulses needed for one full 360-degree rotation (200 * 1 = 200)
const float MAX_SPEED  = 1000.0; // Sets the velocity upper limit to 1000 steps per second to prevent high-speed motor stalling
const float ACCEL      = 2000.0; // Sets the acceleration slope to 2000 steps/sec^2 to ramp speed smoothly up and down
const float CONT_SPEED = 750.0;  // Establishes a fallback constant target velocity of 750 steps per second for continuous rotation

AccelStepper stepper1(AccelStepper::DRIVER, STEP_PIN_1, DIR_PIN_1); // Instantiates Motor 1 object using the 2-wire hardware driver interface
AccelStepper stepper2(AccelStepper::DRIVER, STEP_PIN_2, DIR_PIN_2); // Instantiates Motor 2 object using the 2-wire hardware driver interface

bool continuousMode = false; // Declares a state flag variable to toggle between precise positioning (false) and endless rotation (true)

void enableDrivers(bool enable) {
  digitalWrite(ENABLE_PIN_1, enable ? LOW : HIGH); // Uses ternary operator: drives pin LOW (0V) to turn on Driver 1 since ENABLE is Active-Low
  digitalWrite(ENABLE_PIN_2, enable ? LOW : HIGH); // Uses ternary operator: drives pin LOW (0V) to turn on Driver 2 since ENABLE is Active-Low
}

void setup() {
  Serial.begin(115200);         // Initializes the hardware serial interface at 115,200 baud rate for low-latency communication
  pinMode(ENABLE_PIN_1, OUTPUT); // Configures Driver 1 enable pin as a digital output to send control signals
  pinMode(ENABLE_PIN_2, OUTPUT); // Configures Driver 2 enable pin as a digital output to send control signals
  enableDrivers(true);           // Calls custom function to pull active-low enable pins to 0V, energizing the motor coils instantly
  stepper1.setMaxSpeed(MAX_SPEED);   // Binds the maximum velocity ceiling constraint to the Motor 1 software instance
  stepper1.setAcceleration(ACCEL);   // Binds the kinematic acceleration ramp constraint to the Motor 1 software instance
  stepper2.setMaxSpeed(MAX_SPEED);   // Binds the maximum velocity ceiling constraint to the Motor 2 software instance
  stepper2.setAcceleration(ACCEL);   // Binds the kinematic acceleration ramp constraint to the Motor 2 software instance
}

void loop() {
  if (Serial.available()) { // Polls the serial ring-buffer to verify if any incoming bytes are waiting to be processed
    char cmd = Serial.read(); // Reads the oldest single character from the buffer and stores it in the local variable 'cmd'
    switch (cmd) { // Evaluates the value of the character command to branch execution paths
      case '1': continuousMode = false; stepper1.moveTo(stepper1.currentPosition() + TEST_STEPS); stepper2.moveTo(stepper2.currentPosition() + TEST_STEPS); break; // Resets mode flag, reads current position coordinates, adds 200 steps, and schedules target trajectories
      case '0': continuousMode = false; stepper1.stop(); stepper2.stop(); break; // Resets mode flag and computes a dynamic deceleration ramp to bring motors to a smooth halt
    }
  }
  if (continuousMode) { stepper1.runSpeed(); stepper2.runSpeed(); } // If flag is true, executes step pulses at constant velocity without using acceleration slopes
  else { stepper1.run(); stepper2.run(); } // The default core engine: continuously calculates and executes step pulses if mathematically required at this exact millisecond to follow the acceleration curves and reach target positions
}