Untitled

import time
from gpiozero import OutputDevice

class StepperController:
    def __init__(self, pulse_pin, direction_pin, enable_plus, enable_minus):
        self.pulse = OutputDevice(pulse_pin)
        self.direction = OutputDevice(direction_pin)
        self.enable_plus = OutputDevice(enable_plus)
        self.enable_minus = OutputDevice(enable_minus)
        self.current_position = 0
        
        # Reduced speed parameters
        self.max_speed = 400       # Slower max speed (steps/sec)
        self.acceleration_steps = 500  # Increased acceleration steps
        self.min_delay = 1.0 / self.max_speed  # 0.0025s
        self.accel_start_delay = self.min_delay * 4  # Start acceleration at 0.01s
        
        # Hardware constraints
        self.min_pulse_width = 3e-6  # Maintain TB6600 compatibility
        self.enable_state = False

    def enable(self, state=True):
        """Enable/disable the driver with proper polarity"""
        self.enable_plus.value = not state
        self.enable_minus.value = state
        self.enable_state = state
        time.sleep(0.02)  # Extended enable stabilization

    def move(self, target_steps):
        """Movement with extended acceleration profile"""
        if not self.enable_state:
            self.enable(True)
            
        direction = target_steps > 0
        steps = abs(target_steps)
        self.direction.value = direction

        # Adaptive acceleration profile
        accel_steps = min(steps//2, self.acceleration_steps)
        cruise_steps = steps - 2 * accel_steps
        
        # Smooth acceleration ramp
        self._move_segment(accel_steps, direction, 
                         self.accel_start_delay, self.min_delay)
        
        # Constant speed phase
        if cruise_steps > 0:
            self._move_segment(cruise_steps, direction,
                             self.min_delay, self.min_delay)
        
        # Gradual deceleration
        self._move_segment(accel_steps, direction,
                         self.min_delay, self.accel_start_delay)

        self.current_position += target_steps

    def _move_segment(self, steps, direction, start_delay, end_delay):
        """Enhanced movement core with dynamic speed ramping"""
        if steps == 0:
            return

        # Calculate delay increments per step
        delay_diff = end_delay - start_delay
        delay_step = delay_diff / steps if steps != 0 else 0
        current_delay = start_delay

        for _ in range(steps):
            # Generate pulse with proper timing
            self.pulse.on()
            time.sleep(self.min_pulse_width)
            self.pulse.off()
            
            # Dynamic delay adjustment
            actual_delay = max(current_delay, self.min_pulse_width)
            time.sleep(actual_delay)
            current_delay += delay_step

# Initialize with your GPIO pins
stepper = StepperController(
    pulse_pin=21,
    direction_pin=20,
    enable_plus=23,
    enable_minus=24
)

# Example usage with smooth movement:
if __name__ == "__main__":
    try:
        stepper.enable(True)
        while True:
            stepper.move(2000)   # Slow forward movement
            time.sleep(1.5)      # Extended pause
            stepper.move(-2000)  # Slow reverse movement
            time.sleep(1.5)
    finally:
        stepper.enable(False)