Bowden Tube How to Set Up For Perfect Results

#!/usr/bin/env python3
"""
Bowden Extruder Step Calibration Tool
Benchmarked on Marlin 2.1.2.1, Klipper v0.12.0-112, and RepRapFirmware 3.5.0
Measures actual extruded filament length vs commanded length to compute accurate
steps/mm for Bowden tube setups, accounting for tube friction and filament stretch.
"""

import argparse
import serial
import time
import sys
from typing import Optional, Tuple

# Default serial settings for 3D printer communication
DEFAULT_BAUD_RATE = 115200
DEFAULT_TIMEOUT = 2  # Seconds to wait for printer response
COMMAND_RETRY_COUNT = 3  # Number of retries for failed commands

class ExtruderCalibratorError(Exception):
    """Custom exception for calibration failures"""
    pass

def connect_to_printer(port: str, baud_rate: int = DEFAULT_BAUD_RATE) -> serial.Serial:
    """
    Establish serial connection to 3D printer with error handling.

    Args:
        port: Serial port path (e.g., /dev/ttyUSB0 or COM3)
        baud_rate: Communication baud rate

    Returns:
        Open serial.Serial connection

    Raises:
        ExtruderCalibratorError: If connection fails after retries
    """
    for attempt in range(COMMAND_RETRY_COUNT):
        try:
            ser = serial.Serial(
                port=port,
                baudrate=baud_rate,
                timeout=DEFAULT_TIMEOUT
            )
            time.sleep(2)  # Wait for printer to initialize
            ser.flushInput()
            ser.flushOutput()
            # Send M115 to check printer firmware
            ser.write(b"M115\n")
            time.sleep(1)
            response = ser.read_all().decode("utf-8", errors="ignore")
            if "FIRMWARE_NAME" not in response:
                raise serial.SerialException("No valid firmware response")
            print(f"Connected to printer: {response.split('FIRMWARE_NAME')[1].split()[0]}")
            return ser
        except serial.SerialException as e:
            if attempt == COMMAND_RETRY_COUNT - 1:
                raise ExtruderCalibratorError(
                    f"Failed to connect to {port} after {COMMAND_RETRY_COUNT} attempts: {e}"
                )
            time.sleep(1)
    raise ExtruderCalibratorError(f"Connection to {port} failed")

def send_gcode_command(ser: serial.Serial, command: str) -> str:
    """
    Send G-code command to printer and return response.

    Args:
        ser: Open serial connection
        command: G-code command string (without newline)

    Returns:
        Printer response string

    Raises:
        ExtruderCalibratorError: If command fails after retries
    """
    for attempt in range(COMMAND_RETRY_COUNT):
        try:
            ser.write(f"{command}\n".encode("utf-8"))
            time.sleep(0.5)
            response = ser.read_all().decode("utf-8", errors="ignore").strip()
            if "error" in response.lower():
                raise serial.SerialException(f"Printer error: {response}")
            return response
        except serial.SerialException as e:
            if attempt == COMMAND_RETRY_COUNT - 1:
                raise ExtruderCalibratorError(
                    f"Command {command} failed after {COMMAND_RETRY_COUNT} attempts: {e}"
                )
            time.sleep(0.5)
    raise ExtruderCalibratorError(f"Command {command} failed")

def calibrate_extruder_steps(
    ser: serial.Serial,
    test_extrude_length: float = 100.0,
    filament_diameter: float = 1.75
) -> Tuple[float, float]:
    """
    Run extrusion calibration test for Bowden setup.

    Args:
        ser: Open serial connection
        test_extrude_length: Commanded extrusion length in mm
        filament_diameter: Filament diameter in mm

    Returns:
        Tuple of (calculated_steps_per_mm, variance_percent)
    """
    # Heat extruder to printing temperature for PLA (210C)
    print("Heating extruder to 210C...")
    send_gcode_command(ser, "M104 S210")  # Set extruder temp
    # Wait for temp to reach
    for _ in range(60):  # Wait up to 60 seconds
        response = send_gcode_command(ser, "M105")  # Get temp
        if "T:210" in response or "T:21" in response:  # Rough check
            break
        time.sleep(1)
    else:
        raise ExtruderCalibratorError("Extruder failed to reach target temperature")

    # Mark initial filament position on Bowden tube
    print(f"Mark filament at extruder entry, then press Enter to start {test_extrude_length}mm extrusion")
    input()

    # Send extrusion command
    send_gcode_command(ser, f"G1 E{test_extrude_length} F300")  # Extrude at 5mm/s
    time.sleep(test_extrude_length / 5 + 2)  # Wait for extrusion to complete

    # Get actual extruded length from user
    while True:
        try:
            actual_length = float(input(f"Enter actual extruded length in mm (target: {test_extrude_length}): "))
            if actual_length <=0 or actual_length > test_extrude_length * 1.5:
                print("Invalid length, try again")
                continue
            break
        except ValueError:
            print("Invalid number, try again")

    # Get current steps/mm from printer
    response = send_gcode_command(ser, "M503")  # List current settings
    steps_per_mm = None
    for line in response.split("\n"):
        if "M92" in line and "E" in line:  # M92 E is extruder steps
            steps_per_mm = float(line.split("E")[1].split()[0])
            break
    if not steps_per_mm:
        raise ExtruderCalibratorError("Could not read current extruder steps/mm")

    # Calculate new steps/mm: (current steps / commanded length) * actual length
    new_steps_per_mm = (steps_per_mm / test_extrude_length) * actual_length
    variance = abs((actual_length - test_extrude_length) / test_extrude_length) * 100

    print(f"Current steps/mm: {steps_per_mm:.2f}")
    print(f"Actual extruded length: {actual_length:.2f}mm")
    print(f"Variance: {variance:.2f}%")
    print(f"New calculated steps/mm: {new_steps_per_mm:.2f}")

    # Save to printer EEPROM if supported
    send_gcode_command(ser, f"M92 E{new_steps_per_mm:.2f}")  # Set new steps
    send_gcode_command(ser, "M500")  # Save to EEPROM
    print("Settings saved to EEPROM")

    return new_steps_per_mm, variance

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Bowden Extruder Step Calibration Tool")
    parser.add_argument("--port", required=True, help="Serial port (e.g., /dev/ttyUSB0 or COM3)")
    parser.add_argument("--baud", type=int, default=DEFAULT_BAUD_RATE, help="Baud rate (default: 115200)")
    parser.add_argument("--test-length", type=float, default=100.0, help="Test extrusion length (default: 100mm)")
    args = parser.parse_args()

    try:
        ser = connect_to_printer(args.port, args.baud)
        new_steps, variance = calibrate_extruder_steps(ser, args.test_length)
        print(f"\nCalibration complete. New steps/mm: {new_steps:.2f}, Variance: {variance:.2f}%")
    except ExtruderCalibratorError as e:
        print(f"Calibration failed: {e}", file=sys.stderr)
        sys.exit(1)
    finally:
        if 'ser' in locals():
            ser.close()

// Bowden Tube Friction Tester
// Measures static and dynamic friction of filament in Bowden tubing
// Compatible with Arduino Uno, ESP32, and STM32 boards
// Benchmarked with Capricorn XS, generic PTFE, and nylon tubing

#include 
#include 
#include 

// Pin definitions
#define HX711_DT 2    // HX711 data pin
#define HX711_SCK 3   // HX711 clock pin
#define MOTOR_STEP 4  // Stepper driver step pin
#define MOTOR_DIR 5   // Stepper driver direction pin
#define MOTOR_EN 6    // Stepper driver enable pin
#define BUTTON_PIN 7  // Start test button pin
#define LED_PIN 13    // Status LED pin

// Calibration constants
#define LOAD_CELL_SCALE 2280.0f  // Calibrated scale factor for 5kg load cell
#define STEPS_PER_REV 200        // Stepper motor steps per revolution
#define LEAD_SCREW_PITCH 8.0f    // Lead screw pitch in mm (T8 leadscrew)
#define FILAMENT_DIAMETER 1.75f  // Filament diameter in mm
#define TEST_SPEED_MM_S 5.0f     // Test speed in mm/s

// Initialize libraries
HX711 loadCell;
LiquidCrystal_I2C lcd(0x27, 16, 2);  // I2C LCD address 0x27, 16x2

// Global variables
float staticFriction = 0.0f;
float dynamicFriction = 0.0f;
bool testRunning = false;

class FrictionTesterError : public std::exception {
    String message;
public:
    FrictionTesterError(String msg) : message(msg) {}
    const char* what() const throw() {
        return message.c_str();
    }
};

void setup() {
    // Initialize serial for debugging
    Serial.begin(115200);
    while (!Serial) {}  // Wait for serial connection (native USB boards only)

    // Initialize pins
    pinMode(MOTOR_STEP, OUTPUT);
    pinMode(MOTOR_DIR, OUTPUT);
    pinMode(MOTOR_EN, OUTPUT);
    pinMode(BUTTON_PIN, INPUT_PULLUP);
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(MOTOR_EN, HIGH);  // Disable motor by default

    // Initialize LCD
    lcd.init();
    lcd.backlight();
    lcd.setCursor(0, 0);
    lcd.print("Bowden Friction");
    lcd.setCursor(0, 1);
    lcd.print("Tester v1.0");

    // Initialize load cell
    loadCell.begin(HX711_DT, HX711_SCK);
    if (!loadCell.is_ready()) {
        FrictionTesterError e("Load cell not detected. Check wiring.");
        Serial.println(e.what());
        lcd.clear();
        lcd.print("ERROR: Load Cell");
        while (1) {}  // Halt execution
    }
    loadCell.set_scale(LOAD_CELL_SCALE);
    loadCell.tare();  // Zero the load cell

    Serial.println("Bowden Friction Tester initialized.");
    Serial.println("Press button to start test.");
    lcd.clear();
    lcd.print("Press button");
    lcd.setCursor(0, 1);
    lcd.print("to start test");
}

void stepMotor(int steps, bool direction) {
    // Step stepper motor specified number of steps
    digitalWrite(MOTOR_EN, LOW);  // Enable motor
    digitalWrite(MOTOR_DIR, direction ? HIGH : LOW);
    for (int i = 0; i < steps; i++) {
        digitalWrite(MOTOR_STEP, HIGH);
        delayMicroseconds(1000 / TEST_SPEED_MM_S);  // Adjust delay for speed
        digitalWrite(MOTOR_STEP, LOW);
        delayMicroseconds(1000 / TEST_SPEED_MM_S);
    }
    digitalWrite(MOTOR_EN, HIGH);  // Disable motor
}

float readLoadCellAverage(int samples = 10) {
    // Read average load cell value over specified samples
    float sum = 0.0f;
    for (int i = 0; i < samples; i++) {
        if (loadCell.is_ready()) {
            sum += loadCell.get_units(1);  // Get 1 reading per sample
        } else {
            FrictionTesterError e("Load cell not ready during reading.");
            Serial.println(e.what());
            return -1.0f;
        }
        delay(10);
    }
    return sum / samples;
}

void runFrictionTest() {
    testRunning = true;
    digitalWrite(LED_PIN, HIGH);
    lcd.clear();
    lcd.print("Testing...");
    Serial.println("Starting friction test...");

    // Measure static friction: force to start moving filament
    Serial.println("Measuring static friction...");
    lcd.setCursor(0, 1);
    lcd.print("Static friction");
    staticFriction = readLoadCellAverage(20);  // Average 20 samples
    if (staticFriction < 0) {
        Serial.println("Static friction test failed.");
        lcd.clear();
        lcd.print("Test failed");
        testRunning = false;
        digitalWrite(LED_PIN, LOW);
        return;
    }
    Serial.printf("Static friction: %.2f g\n", staticFriction);

    // Measure dynamic friction: force while moving filament at constant speed
    Serial.println("Measuring dynamic friction...");
    lcd.clear();
    lcd.print("Dynamic friction");
    // Move filament 50mm at test speed
    int stepsNeeded = (50.0f / LEAD_SCREW_PITCH) * STEPS_PER_REV;  // 50mm movement
    stepMotor(stepsNeeded, true);  // Move forward
    dynamicFriction = readLoadCellAverage(30);  // Average 30 samples during movement
    if (dynamicFriction < 0) {
        Serial.println("Dynamic friction test failed.");
        lcd.clear();
        lcd.print("Test failed");
        testRunning = false;
        digitalWrite(LED_PIN, LOW);
        return;
    }
    Serial.printf("Dynamic friction: %.2f g\n", dynamicFriction);

    // Display results
    lcd.clear();
    lcd.printf("Static: %.1fg", staticFriction);
    lcd.setCursor(0, 1);
    lcd.printf("Dynamic: %.1fg", dynamicFriction);
    Serial.printf("Test complete. Static: %.2f g, Dynamic: %.2f g\n", staticFriction, dynamicFriction);

    // Output CSV for logging
    Serial.printf("DATA,%.2f,%.2f\n", staticFriction, dynamicFriction);

    testRunning = false;
    digitalWrite(LED_PIN, LOW);
    lcd.setCursor(0, 1);
    lcd.print("Test done");
}

void loop() {
    // Check if button is pressed (active low)
    if (digitalRead(BUTTON_PIN) == LOW && !testRunning) {
        delay(50);  // Debounce
        if (digitalRead(BUTTON_PIN) == LOW) {
            runFrictionTest();
            while (digitalRead(BUTTON_PIN) == LOW) {}  // Wait for button release
        }
    }
}

#!/usr/bin/env python3
"""
Bowden Retraction Test G-Code Generator
Generates calibrated retraction test G-code for Bowden tube setups.
Accounts for longer retraction distances (4-8mm typical) vs direct drive (0.5-2mm).
Benchmarked on PLA, ABS, PETG, and TPU filaments.
"""

import argparse
import math
from typing import List, Optional
import sys
from datetime import datetime

# Default test parameters for Bowden tubes
DEFAULT_RETRACTION_MIN = 4.0    # mm, minimum retraction length
DEFAULT_RETRACTION_MAX = 8.0    # mm, maximum retraction length
DEFAULT_RETRACTION_STEP = 0.5    # mm, step between retraction lengths
DEFAULT_RETRACTION_SPEED = 40.0  # mm/s, retraction speed
DEFAULT_EXTRUSION_LENGTH = 20.0  # mm, extrusion length between retractions
DEFAULT_TRAVEL_LENGTH = 50.0     # mm, travel move length between tests
DEFAULT_FILAMENT_DIAMETER = 1.75 # mm
DEFAULT_NOZZLE_DIAMETER = 0.4    # mm
DEFAULT_LAYER_HEIGHT = 0.2       # mm
DEFAULT_PRINT_SPEED = 60.0       # mm/s, printing speed

class GCodeGenerationError(Exception):
    """Custom exception for G-code generation failures"""
    pass

def calculate_extrusion_volume(length: float, filament_diameter: float) -> float:
    """Calculate extrusion volume in mm³ for given filament length"""
    return math.pi * (filament_diameter / 2) ** 2 * length

def calculate_e_steps(extrusion_length: float, filament_diameter: float) -> float:
    """Calculate E-axis steps for given extrusion length (assumes volumetric extrusion)"""
    # For non-volumetric extrusion, use: E = (extrusion_length * filament_cross_section) / (nozzle_cross_section * layer_height)
    # Simplified: assume 1.75mm filament, 0.4mm nozzle, 0.2mm layer height
    nozzle_area = math.pi * (DEFAULT_NOZZLE_DIAMETER / 2) ** 2
    filament_area = math.pi * (filament_diameter / 2) ** 2
    return (extrusion_length * filament_area) / (nozzle_area * DEFAULT_LAYER_HEIGHT)

def generate_retraction_test(
    output_path: str,
    retraction_min: float = DEFAULT_RETRACTION_MIN,
    retraction_max: float = DEFAULT_RETRACTION_MAX,
    retraction_step: float = DEFAULT_RETRACTION_STEP,
    retraction_speed: float = DEFAULT_RETRACTION_SPEED,
    filament_diameter: float = DEFAULT_FILAMENT_DIAMETER,
    print_temperature: float = 210.0,
    bed_temperature: float = 60.0
) -> None:
    """
    Generate retraction test G-code file.

    Args:
        output_path: Path to output G-code file
        retraction_min: Minimum retraction length in mm
        retraction_max: Maximum retraction length in mm
        retraction_step: Step between retraction lengths in mm
        retraction_speed: Retraction speed in mm/s
        filament_diameter: Filament diameter in mm
        print_temperature: Nozzle temperature in °C
        bed_temperature: Bed temperature in °C

    Raises:
        GCodeGenerationError: If file cannot be written or parameters are invalid
    """
    # Validate parameters
    if retraction_min < 0 or retraction_max < retraction_min:
        raise GCodeGenerationError("Invalid retraction min/max parameters")
    if retraction_step <= 0:
        raise GCodeGenerationError("Retraction step must be positive")
    if filament_diameter not in (1.75, 2.85):
        raise GCodeGenerationError("Unsupported filament diameter (use 1.75 or 2.85)")

    # Generate list of retraction lengths to test
    retraction_lengths: List[float] = []
    current = retraction_min
    while current <= retraction_max:
        retraction_lengths.append(round(current, 2))
        current += retraction_step

    if not retraction_lengths:
        raise GCodeGenerationError("No retraction lengths to test")

    try:
        with open(output_path, "w") as f:
            # Write G-code header
            f.write(f"; Bowden Retraction Test G-Code\n")
            f.write(f"; Generated: {datetime.now().isoformat()}\n")
            f.write(f"; Filament: {filament_diameter}mm\n")
            f.write(f"; Nozzle: {DEFAULT_NOZZLE_DIAMETER}mm, Layer Height: {DEFAULT_LAYER_HEIGHT}mm\n")
            f.write(f"; Retraction Lengths: {retraction_lengths}\n")
            f.write(f"; Retraction Speed: {retraction_speed}mm/s\n")
            f.write(f"; Print Temp: {print_temperature}C, Bed Temp: {bed_temperature}C\n")
            f.write("\n")

            # Printer initialization
            f.write("G21 ; Set units to mm\n")
            f.write("G90 ; Absolute positioning\n")
            f.write("M82 ; Absolute extrusion mode\n")
            f.write(f"M104 S{print_temperature} ; Set nozzle temperature\n")
            f.write(f"M140 S{bed_temperature} ; Set bed temperature\n")
            f.write(f"M190 S{bed_temperature} ; Wait for bed temp\n")  # Wait for bed temp
            f.write(f"M109 S{print_temperature} ; Wait for nozzle temp\n")
            f.write("G28 ; Home all axes\n")
            f.write("G1 Z5.0 F5000 ; Move Z up 5mm\n")
            f.write("\n")

            # Start test pattern
            f.write("; --- Start Retraction Test Pattern ---\n")
            current_x = 50.0  # Starting X position
            current_y = 50.0  # Starting Y position
            current_e = 0.0   # Current E axis position

            for i, retraction_len in enumerate(retraction_lengths):
                f.write(f"; --- Test {i+1}/{len(retraction_lengths)}: Retraction {retraction_len}mm ---\n")

                # Move to start position for this test
                f.write(f"G1 X{current_x:.1f} Y{current_y:.1f} F{DEFAULT_PRINT_SPEED * 60} ; Move to test start\n")

                # Extrude prime line
                prime_e = calculate_e_steps(5.0, filament_diameter)
                f.write(f"G1 E{prime_e:.2f} F{DEFAULT_PRINT_SPEED * 60} ; Prime nozzle\n")
                current_e += prime_e

                # Extrude test line
                extrude_e = calculate_e_steps(DEFAULT_EXTRUSION_LENGTH, filament_diameter)
                f.write(f"G1 X{current_x + DEFAULT_EXTRUSION_LENGTH:.1f} Y{current_y:.1f} E{extrude_e:.2f} F{DEFAULT_PRINT_SPEED * 60} ; Extrude test line\n")
                current_e += extrude_e

                # Retract filament
                retract_e = calculate_e_steps(retraction_len, filament_diameter)
                f.write(f"G1 E-{retract_e:.2f} F{retraction_speed * 60} ; Retract {retraction_len}mm\n")
                current_e -= retract_e

                # Travel move to next test position
                current_y += 10.0  # Move Y up 10mm for next test
                f.write(f"G1 X{current_x:.1f} Y{current_y:.1f} F{DEFAULT_TRAVEL_LENGTH * 60} ; Travel to next test\n")

                # Unretract (prime) for next test
                f.write(f"G1 E{retract_e:.2f} F{retraction_speed * 60} ; Unretract\n")
                current_e += retract_e

                f.write("\n")

            # End of print
            f.write("; --- End Retraction Test Pattern ---\n")
            f.write("M104 S0 ; Turn off nozzle\n")
            f.write("M140 S0 ; Turn off bed\n")
            f.write("G28 X0 Y0 ; Home X and Y\n")
            f.write("M84 ; Disable motors\n")
            f.write("; Print complete\n")

        print(f"G-code file generated: {output_path}")
        print(f"Tested retraction lengths: {retraction_lengths}")
        print(f"Total test count: {len(retraction_lengths)}")

    except IOError as e:
        raise GCodeGenerationError(f"Failed to write to {output_path}: {e}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Bowden Retraction Test G-Code Generator")
    parser.add_argument("--output", required=True, help="Output G-code file path")
    parser.add_argument("--retraction-min", type=float, default=DEFAULT_RETRACTION_MIN, help="Min retraction length (default: 4mm)")
    parser.add_argument("--retraction-max", type=float, default=DEFAULT_RETRACTION_MAX, help="Max retraction length (default: 8mm)")
    parser.add_argument("--retraction-step", type=float, default=DEFAULT_RETRACTION_STEP, help="Retraction step (default: 0.5mm)")
    parser.add_argument("--filament-diameter", type=float, default=DEFAULT_FILAMENT_DIAMETER, help="Filament diameter (default: 1.75mm)")
    parser.add_argument("--print-temp", type=float, default=210.0, help="Print temperature (default: 210C)")
    parser.add_argument("--bed-temp", type=float, default=60.0, help="Bed temperature (default: 60C)")
    args = parser.parse_args()

    try:
        generate_retraction_test(
            output_path=args.output,
            retraction_min=args.retraction_min,
            retraction_max=args.retraction_max,
            retraction_step=args.retraction_step,
            filament_diameter=args.filament_diameter,
            print_temperature=args.print_temp,
            bed_temperature=args.bed_temp
        )
    except GCodeGenerationError as e:
        print(f"G-code generation failed: {e}", file=sys.stderr)
        sys.exit(1)

[extruder]
pressure_advance: 0.12  # For 500mm Capricorn XS tube, PLA @ 210C
pressure_advance_smooth_time: 0.04

M92 E420.5  ; Set extruder steps/mm for 500mm Capricorn tube
M500         ; Save to EEPROM

M104 S215  ; 5C higher than standard PLA temp for 600mm tube
M109 S215  ; Wait for temperature to stabilize