first version of extruder gearbox working.

hardware/common.scad

     }
 }
 
+module endstop_pcb() {
+    difference() {
+        cube([endstop_pcb_width, endstop_pcb_depth, endstop_pcb_height]);
+        
+        for (i = [0, 1])
+        translate([endstop_pcb_hole_dist_x, -1, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
+        rotate([-90, 0, 0])
+        cylinder(d = endstop_pcb_hole, h = endstop_pcb_depth + 2);
+    }
+    
+    translate([0, 0, endstop_pcb_height - endstop_pcb_switchpoint])
+    rotate([0, -90, 0])
+    cylinder(d = endstop_pcb_hole, h = endstop_pcb_switchpoint);
+}
+
+module endstop_mount_v1() {
+    %color("yellow")
+    translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
+    endstop_pcb();
+    
+    color("blue")
+    difference() {
+        cube([endstop_mount_width, endstop_mount_depth, 40]);
+        
+        for (i = [0, 1])
+        translate([endstop_mount_width / 2, -1, 10 + 20 * i])
+        rotate([-90, 0, 0])
+        cylinder(d = motor_mount_hole_size, h = endstop_mount_depth + 2);
+    }
+    
+    color("blue")
+    difference() {
+        union() {
+            hull() {
+                translate([-endstop_mount_slot_length, 0, 40 - endstop_mount_add_height])
+                cube([endstop_mount_slot_length, endstop_mount_depth, endstop_mount_add_height]);
+                
+                for (i = [0, 1])
+                translate([0, 0, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
+                translate([-endstop_pcb_mount_off_w, -endstop_pcb_mount_off_d, endstop_pcb_mount_off_h - endstop_mount_slot_width / 2])
+                cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
+            }
+        }
+        
+        translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
+        for (i = [0, 1])
+        translate([endstop_pcb_hole_dist_x, -1, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
+        rotate([-90, 0, 0]) {
+            cylinder(d = endstop_pcb_hole, h = endstop_pcb_depth + 20);
+            
+            translate([0, 0, 1 + endstop_pcb_depth + endstop_mount_slot_depth])
+            cylinder(d = endstop_mount_nut_hole, h = 20, $fn = 6);
+        }
+    }
+}
+
+module endstop_mount_v2() {
+    %color("yellow")
+    translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
+    endstop_pcb();
+    
+    color("blue")
+    difference() {
+        cube([endstop_mount_width, endstop_mount_depth, 40]);
+        
+        for (i = [0, 1])
+        translate([endstop_mount_width / 2, -1, 10 + 20 * i])
+        rotate([-90, 0, 0])
+        cylinder(d = motor_mount_hole_size, h = endstop_mount_depth + 2);
+    }
+    
+    color("blue")
+    difference() {
+        union() {
+            hull() {
+                translate([-endstop_mount_slot_length, 0, 40 - endstop_mount_add_height])
+                cube([endstop_mount_slot_length, endstop_mount_depth, endstop_mount_add_height]);
+                
+                translate([0, 0, endstop_pcb_height - endstop_pcb_hole_dist_y - endstop_pcb_hole_dist])
+                translate([-endstop_pcb_mount_off_w, -endstop_pcb_mount_off_d, endstop_pcb_mount_off_h - endstop_mount_slot_width / 2])
+                cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
+            }
+            
+            hull() {
+                for (i = [0, 1])
+                translate([0, 0, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
+                translate([-endstop_pcb_mount_off_w, -endstop_pcb_mount_off_d, endstop_pcb_mount_off_h - endstop_mount_slot_width / 2])
+                cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
+            }
+        }
+        
+        translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
+        for (i = [0, 1])
+        translate([endstop_pcb_hole_dist_x, -1, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
+        rotate([-90, 0, 0]) {
+            cylinder(d = endstop_pcb_hole, h = endstop_pcb_depth + 20);
+            
+            translate([0, 0, 1 + endstop_pcb_depth + endstop_mount_slot_depth])
+            cylinder(d = endstop_mount_nut_hole, h = 20, $fn = 6);
+        }
+    }
+}
+
+module endstop_mount() {
+    if (use_endstop_mount_v2) {
+        endstop_mount_v2();
+    } else {
+        endstop_mount_v1();
+    }
+}
+
 module dispenser_arm() {
     translate([0, dispenser_arm_tab_off, dispenser_arm_tab_hole_off])
     rotate([90, 0, 0])
     cylinder(d = dispenser_handle_dia, h = dispenser_handle_length);
     
     translate([0, dispenser_top_dia / 2 + dispenser_arm_handle_y, dispenser_nozzle_end_length + dispenser_nozzle_cap_height + dispenser_nozzle_mid_height + dispenser_nozzle_top_height + dispenser_top_height + dispenser_arm_handle_z])
-    rotate([dispenser_arm_angle_bottom + anim_pos_extruder * (dispenser_arm_angle_top - dispenser_arm_angle_bottom), 0, 0])
+    rotate([dispenser_arm_angle_bottom + (-anim_pos_extruder + 1) * (dispenser_arm_angle_top - dispenser_arm_angle_bottom), 0, 0])
     dispenser_arm();
 }
 
-dispenser_arm_angle_top = -5;
-dispenser_arm_angle_bottom = 6;
+//endstop_pcb();
+endstop_mount();
 
-dispenser();
+//dispenser();

hardware/config.scad

 // 3d printer specific
 screw_gap = 0.3;
-nut_gap = -0.1;
+nut_gap = -0.2;
+
+dispenser_rim_dia = 210; // TODO
+dispenser_rim_height = 2.0; // TODO
 
 dispenser_top_dia = 200;
 dispenser_top_height = 108;
 dispenser_handle_dia = 21;
 dispenser_handle_length = 100;
 dispenser_handle_angle = 38;
+dispenser_height = dispenser_top_height + dispenser_nozzle_top_height + dispenser_nozzle_mid_height + dispenser_nozzle_cap_height + dispenser_nozzle_end_length;
 
 dispenser_arm_dia = 7.0;
 dispenser_arm_len = 250;
 dispenser_arm_handle_y = 10;
 dispenser_arm_handle_z = 15;
 
+dispenser_arm_angle_top = -5;
+dispenser_arm_angle_bottom = 6;
+
+disp_mount_wall = 20;
+disp_mount_overlap_x = 50;
+disp_mount_overlap_y = 40;
+disp_mount_add_x = 20;
+disp_mount_add_y = 50;
+disp_mount_width = dispenser_rim_dia / 2 - disp_mount_overlap_x + disp_mount_add_x;
+disp_mount_len = dispenser_rim_dia / 2 + disp_mount_overlap_y + disp_mount_add_y;
+disp_mount_off_x = dispenser_rim_dia / 2 - disp_mount_overlap_x;
+disp_mount_off_y = disp_mount_overlap_y;
+
+dispenser_mount_rail_off = dispenser_rim_dia / 2 + disp_mount_add_y;
+
 rail_wheel_height = 11;
 rail_wheel_center_height = 5;
 rail_wheel_outer = 24;
 gears_dist = belt_length_center / 2;
 
 gear_stages = 1;
-gear_stage_height = pulley_height + 2;
+
+// allow room for metal pulleys
+gear_stage_height = pulley_height + 15;
 
 gear_stages_dist = (bearing_height + 1) * 2;
 gearbox_wall = gear_stages_dist; //bearing_height + 1;
 gearbox_width = large_dia + (gearbox_wall + gearbox_gap) * 2;
 gearbox_depth = 2 * gearbox_wall + gear_stages * gear_stage_height + (gear_stages - 1) * gear_stages_dist;
 
-extruder_travel = 60;
-
-piston_dia = 30;
-piston_height = 30;
-piston_gap = 0.1;
-piston_wall = 3;
-piston_radius = 3;
-piston_bottom_gap = piston_wall + 10;
-cylinder_dia = piston_dia + 2 * (piston_wall + piston_gap);
-cylinder_height = piston_height + extruder_travel;
-
-actuator_length = 100;
-
-extruder_lever_width = 10;
-extruder_lever_depth = 5;
-extruder_lever_holes = 4.2; // TODO
-extruder_lever_hole_dist = extruder_travel / 2;
-extruder_lever_length = extruder_lever_hole_dist + 10;
+echo("gearbox_depth", gearbox_depth);
 
+extruder_travel = 60;
 extruder_wall_screw = 3.0;
-extruder_wall_hole_screw = extruder_wall_screw + screw_gap;
-extruder_wall_hole_nut = extruder_wall_screw + nut_gap;
-extruder_wall_hole_depth = 8.0;
+extruder_use_threaded_rods = true;
 
-additional_piston_offset = 8;
+extruder_wall_hole_screw = extruder_wall_screw + screw_gap;
+extruder_wall_hole_nut = extruder_use_threaded_rods ? extruder_wall_hole_screw : (extruder_wall_screw + nut_gap);
+extruder_wall_hole_depth = extruder_use_threaded_rods ? gearbox_height : 8.0;
 
 /***********************************
  ************** Table **************
 point_that_reaches_everywhere_x = -7.5;
 point_that_reaches_everywhere_y = -17.5;
 
-use_anim = false;
+use_anim = true;
 x_axis_position = 1.0;
 y_axis_position = 0.5;
 
 x_axis_animation_position = anim_pos_x * x_axis_travel_len;
 y_axis_animation_position = anim_pos_y * y_axis_travel_len;
 
-extruder_axis_position = 1.0;
+extruder_axis_position = 0.0;
 
-anim_pos_extruder = use_anim ? sin($t * 360) * 0.5 + 0.5 : extruder_axis_position;
-extruder_axis_anim_position = anim_pos_extruder * extruder_travel;
+anim_pos_extruder = use_anim ? -cos($t * 360) * 0.5 + 0.5 : extruder_axis_position;
 
 draw_pulleys = false;
 

hardware/dispenser.scad

+include <config.scad>;
+use <gearbox.scad>;
+use <common.scad>;
+
+module dispenser_mount() {
+    difference() {
+        color("green")
+        cube([disp_mount_width, disp_mount_len, disp_mount_wall]);
+        
+        translate([-disp_mount_off_x, disp_mount_off_y, 0]) {
+            translate([0, 0, -1])
+            cylinder(d = dispenser_top_dia, h = disp_mount_wall + 2, $fn = 100);
+            
+            translate([0, 0, disp_mount_wall - dispenser_rim_height])
+            cylinder(d = dispenser_rim_dia, h = dispenser_rim_height + 1, $fn = 100);
+        }
+    }
+}
+
+disp_rail_len = 2 * (disp_mount_width + disp_mount_off_x);
+disp_mount_height = dispenser_height - disp_mount_wall + dispenser_rim_height;
+
+module dispenser_assembly() {
+    %color("magenta")
+    dispenser();
+    
+    translate([0, 0, disp_mount_height + 130])
+    extruder();
+    
+    for (i = [-1, 1])
+    scale([i, 1, 1])
+    translate([disp_mount_off_x, -disp_mount_off_y, disp_mount_height])
+    dispenser_mount();
+    
+    translate([-disp_rail_len / 2, dispenser_mount_rail_off, disp_mount_height])
+    rail_2020_x(disp_rail_len, "dispenser mount base rail");
+    
+    for (i = [-1, 1])
+    translate([i * disp_rail_len / 2 - ((i + 1) / 2) * 20, -disp_mount_off_y, disp_mount_height - 20])
+    rail_2020_y(disp_mount_len + 20, "dispenser mount arm rail");
+}
+
+dispenser_assembly();

hardware/fuellfix.scad

 include <config.scad>;
 use <table.scad>;
-use <gearbox.scad>;
 use <common.scad>;
+use <dispenser.scad>;
 
 draw_assembly = true;
 
     endstop_mount();
 }
 
-top_rail_len = x_axis_rail_len + plate_x - 70;
-top_rail_height = 200;
-top_rail_off = 150;
-
-echo("top rail length", top_rail_len);
-
 module fuellfix_assembly() {
     xy_table();
     
-    %color("magenta")
-    dispenser();
-    
-    translate([0, 0, 200 + 100])
-    whole_extruder();
-    
-    translate([-top_rail_len / 2, top_rail_off, top_rail_height])
-    rail_2020_x(top_rail_len, "top rail");
+    dispenser_assembly();
 }
 
 echo(); echo(); echo();    

hardware/gearbox.scad

 use <gt2_pulley.scad>;
 use <common.scad>
 
+extruder_slot_gap_vert = 1;
+extruder_slot_gap_horz = 2;
+
+extruder_real_nut_dia = 6.3;
+extruder_add_nut_height = 5.0;
+
+extruder_arm_dia = extruder_travel + extruder_slot_gap_vert;
+extruder_arm_post_dia = 9.5;
+extruder_arm_width = 15.0;
+extruder_arm_axis_dia = 20.0;
+extruder_arm_flare_off = 3.0;
+extruder_arm_axis_h = 10.0;
+extruder_arm_post_h = 20.0;
+extruder_arm_off = 10;
+
+actuator_slot_w = extruder_arm_dia + bearing_outer + extruder_slot_gap_horz;
+actuator_slot_h = bearing_outer + extruder_slot_gap_vert;
+actuator_width = actuator_slot_w + 20;
+actuator_height = actuator_slot_h + 20;
+actuator_wall = bearing_height + 2;
+
+actuator_rod_len = 100;
+actuator_rod_len_add_bottom = 50;
+
+show_extruder_maximum_positions = false;
+extruder_maximum_positions = 12;
+
+linear_bearing_inner = 8.2;
+linear_bearing_outer = 15.0;
+linear_bearing_height = 25.0;
+
+linear_mount_inner = linear_bearing_outer + 0.5;
+linear_mount_wall = 3.0;
+linear_mount_outer = linear_mount_inner + 2 * linear_mount_wall;
+linear_mount_height = linear_bearing_height;
+linear_mount_width = 40.0;
+linear_mount_cut = 5.0;
+linear_mount_tab_off = linear_mount_wall;
+linear_mount_tab_width = 7.0;
+
+linear_mount_add_width = 8.0;
+linear_mount_add_height = 35.0;
+
+actuator_rod = 8.0;
+actuator_rod_wall = 2.5;
+actuator_rod_width = actuator_rod + 2 * actuator_rod_wall;
+actuator_rod_h = 6.0;
+actuator_rod_inset = 3.0;
+actuator_bearing_off = 12.5;
+actuator_bearing_dist = extruder_arm_off + extruder_arm_post_h - actuator_wall + actuator_rod_width - 1.5; // TODO not correct formula, but matches for now
+
+gearbox_spacer = gearbox_wall / 2;
+
+gb_endstop_off = 21;
+gb_endstop_slit_len = 1.0;
+
 $fn = 42;
 
 echo("extruder gear factor", pow(large_teeth / small_teeth, gear_stages));
 
+module linear_bearing() {
+    difference() {
+        cylinder(d = linear_bearing_outer, h = linear_bearing_height);
+        
+        translate([0, 0, -1])
+        cylinder(d = linear_bearing_inner + 1, h = linear_bearing_height + 2);
+    }
+}
+
 module gear_pulley(dia, teeth) {
     if (draw_pulleys) {
         gt2_2mm_pulley(teeth, pulley_teeth_height);
     }
 }
 
-module gearbox() {
-    // back wall
-    color("cyan")
-    translate([-gearbox_width / 2, -gearbox_height / 2, -gearbox_wall])
-    outer_plate();
-    
-    // front wall
-    color("cyan")
-    translate([-gearbox_width / 2, -gearbox_height / 2, gear_stage_height * gear_stages + gear_stages_dist * (gear_stages - 1)])
+module gb_front_wall() {
     difference() {
+        color("cyan")
+        translate([-gearbox_width / 2, -gearbox_height / 2, -gearbox_wall])
         outer_plate();
         
+        for (i = [-1, 1])
+        translate([0, i * gears_dist / 2, -bearing_height])
+        outer_bearings();
+    }
+}
+
+module gb_back_wall() {
+    difference() {
+        color("cyan")
+        translate([-gearbox_width / 2, -gearbox_height / 2, gear_stage_height * gear_stages + gear_stages_dist * (gear_stages - 1)])
+        outer_plate();
+        
+        translate([-gearbox_width / 2, -gearbox_height / 2, gear_stage_height * gear_stages + gear_stages_dist * (gear_stages - 1)])
         translate([0, (gear_stages % 2) ? 0 : gears_dist, 0])
         translate([(gearbox_width - nema17_size) / 2, -nema17_size / 2 + (gearbox_height - gears_dist) / 2, 0]) {
             nema17_holes_face(3, motor_mount_height + 5, nema17_hole_size + screw_gap);
             translate([nema17_size / 2, nema17_size / 2, -1])
             cylinder(d = nema17_center_size + 2, h = gearbox_wall + 2);
         }
+    
+        for (i = [-1, 1])
+        translate([0, i * gears_dist / 2, -bearing_height])
+        outer_bearings();
     }
+}
+
+module gearbox() {
+    gb_back_wall();
+    gb_front_wall();
 
     %color("yellow")
     translate([0, (gear_stages % 2) ? 0 : gears_dist, 0])
     for (i = [0 : gear_stages - 1])
     translate([0, 0, i * (gear_stage_height + gear_stages_dist)])
     rotate([0, 0, i * 180]) {
-        gear_stage();
+        %gear_stage();
         
         color("cyan")
         if (i < (gear_stages - 1))
     cylinder(d = bearing_outer, h = bearing_height + 0.1);
 }
 
-module top_cover() {
+module linear_bearing_mount(w = linear_mount_width) {
+    %color("magenta")
+    linear_bearing();
+    
     difference() {
-        cube([gearbox_width, gearbox_wall, gearbox_depth]);
+        color("green")
+        hull() {
+            cylinder(d = linear_mount_outer, h = linear_mount_height);
+            
+            translate([-w / 2, -(linear_mount_wall + linear_mount_outer) / 2, 0])
+            cube([w, linear_mount_wall, linear_mount_height]);
+        }
         
-        for (i = [0, gearbox_width - gearbox_wall])
-        for (j = [gearbox_wall / 2, gearbox_depth - gearbox_wall / 2])
-        translate([gearbox_wall / 2 + i, -1, j])
-        rotate([-90, 0, 0])
-        cylinder(d = extruder_wall_hole_screw, h = gearbox_wall + 2);
+        translate([0, 0, -1])
+        cylinder(d = linear_mount_inner, h = linear_mount_height + 2);
         
-        for (i = [0, gearbox_width - gear_stages_dist])
-        if (gear_stages > 1)
-        for (j = [1 : gear_stages - 1])
-        translate([gear_stages_dist / 2 + i, -1, j * (gear_stage_height + gear_stages_dist) + gear_stages_dist / 2])
-        rotate([-90, 0, 0])
-        cylinder(d = extruder_wall_hole_screw, h = gearbox_wall + 2);
+        translate([-linear_mount_cut / 2, 0, -1])
+        cube([linear_mount_cut, linear_mount_outer, linear_mount_height + 2]);
+    }
+    
+    for (i = [1, -1])
+    scale([i, 1, 1])
+    translate([linear_mount_cut / 2, linear_mount_outer / 2 - linear_mount_tab_off, 0])
+    difference() {
+        color("green")
+        cube([linear_mount_wall, linear_mount_tab_width + linear_mount_tab_off, linear_mount_height]);
+        
+        for (i = [1, 3])
+        translate([-1, linear_mount_tab_off * 3 / 4 + linear_mount_tab_width / 2, linear_mount_height / 4 * i])
+        rotate([0, 90, 0])
+        cylinder(d = extruder_wall_hole_screw, h = linear_mount_wall + 2);
     }
 }
 
-module gearbox_assembly() {
+module top_cover_holes(h, nuts = 0) {
+    for (i = [0, gearbox_width - gearbox_wall])
+    for (j = [gearbox_wall / 2, gearbox_depth - gearbox_wall / 2])
+    translate([gearbox_wall / 2 + i, -1, j])
+    rotate([-90, 0, 0])
+    if (nuts)
+    rotate([0, 0, 360 / 12])
+    cylinder(d = extruder_real_nut_dia, h = h + 2, $fn = 6);
+    else
+    cylinder(d = extruder_wall_hole_screw, h = h + 2);
+    
+    for (i = [0, gearbox_width - gear_stages_dist])
+    if (gear_stages > 1)
+    for (j = [1 : gear_stages - 1])
+    translate([gear_stages_dist / 2 + i, -1, j * (gear_stage_height + gear_stages_dist) + gear_stages_dist / 2])
+    rotate([-90, 0, 0])
+    cylinder(d = extruder_wall_hole_screw, h = h + 2);
+}
+
+module top_cover_plate(variant = 0) {
     difference() {
-        gearbox();
+        if (variant == 0) {
+            color("green")
+            translate([0, 0, -linear_mount_add_width])
+            cube([gearbox_width, gearbox_wall, gearbox_depth + linear_mount_add_width]);
+        } else if (variant == 1) {
+            color("green")
+            cube([gearbox_width, gearbox_wall, gearbox_depth]);
+        } else if (variant == 2) {
+            color("red")
+            cube([gearbox_width, gearbox_spacer, gearbox_depth]);
+        } else {
+            color("red")
+            translate([-endstop_mount_slot_depth, 0, 0])
+            cube([gearbox_width + endstop_mount_slot_depth, gearbox_spacer, gearbox_depth]);
+        }
         
+        if (variant == 1) {
+            top_cover_holes(gearbox_wall + actuator_bearing_off);
+        } else {
+            top_cover_holes(gearbox_wall);
+        }
+    }
+}
+
+module top_cover(variant) {
+    top_cover_plate(variant);
+    
+    if (variant == 0) {
+        translate([gearbox_width / 2, gearbox_wall + actuator_bearing_off, -actuator_bearing_dist])
+        rotate([-90, 0, 0])
+        linear_bearing_mount();
+    } else if (variant == 1) {
         for (i = [-1, 1])
-        translate([0, i * gears_dist / 2, -bearing_height])
-        outer_bearings();
+        translate([gearbox_width / 2 + i * gearbox_width / 4, gearbox_wall + actuator_bearing_off, -actuator_bearing_dist])
+        rotate([-90, 0, 0])
+        linear_bearing_mount(gearbox_width / 2);
     }
     
     color("green")
-    for (i = [-1, 1])
-    scale([1, i, 1])
-    translate([-gearbox_width / 2, gearbox_height / 2, -gearbox_wall])
-    top_cover();
+    difference() {
+        hull() {
+            if (variant == 0) {
+                translate([(gearbox_width - linear_mount_width) / 2, gearbox_wall + actuator_bearing_off, (linear_mount_wall + linear_mount_outer) / 2 - linear_mount_wall - actuator_bearing_dist])
+                cube([linear_mount_width, linear_mount_height, linear_mount_wall]);
+            } else if (variant == 1) {
+                translate([0, gearbox_wall + actuator_bearing_off, (linear_mount_wall + linear_mount_outer) / 2 - linear_mount_wall - actuator_bearing_dist])
+                cube([gearbox_width, linear_mount_height, linear_mount_wall]);
+            }
+            
+            if (variant == 0) {
+                translate([0, gearbox_wall, -linear_mount_add_width])
+                cube([gearbox_width, linear_mount_add_height, linear_mount_add_width]);
+            } else if (variant == 1) {
+                translate([0, gearbox_wall - 1, 0])
+                cube([gearbox_width, extruder_add_nut_height + 1, gearbox_depth]);
+            }
+        }
+        
+        if (variant == 1) {
+            translate([0, gearbox_wall - 2, 0])
+            top_cover_holes(actuator_bearing_off + linear_mount_height, 1);
+        }
+    }
     
-    %color("grey")
-    for (i = [-1, 1])
-    translate([0, i * gears_dist / 2, -gearbox_wall - 1])
-    cylinder(d = axis_diameter, h = gear_stages * gear_stage_height + gearbox_wall * 2 + gear_stages_dist * (gear_stages - 1) + 2);
+    if (variant == 3) {
+        difference() {
+            union() {
+                translate([-endstop_pcb_depth - endstop_mount_slot_depth, gb_endstop_off, 0])
+                rotate([180, 0, 90]) {
+                    %color("yellow")
+                    endstop_pcb();
+                    
+                    color("red")
+                    hull()
+                    for (i = [0, 1])
+                    translate([0, endstop_pcb_depth, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist - endstop_mount_slot_width / 2])
+                    cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
+                }
+                
+                color("red")
+                hull() {
+                    translate([-endstop_mount_slot_depth, 0, 0])
+                    cube([endstop_mount_slot_depth, gearbox_spacer * 2, gearbox_depth]);
+                    
+                    translate([-endstop_mount_slot_depth, gb_endstop_off, -endstop_pcb_height + endstop_pcb_hole_dist_y + endstop_pcb_hole_dist])
+                    cube([endstop_mount_slot_depth, endstop_mount_slot_length, endstop_pcb_height - endstop_pcb_hole_dist_y - endstop_pcb_hole_dist]);
+                }
+            }
+            
+            // hole slots for endstop pcb
+            translate([-endstop_pcb_depth - endstop_mount_slot_depth, gb_endstop_off, 0])
+            rotate([180, 0, 90])
+            for (i = [0, 1])
+            translate([endstop_pcb_hole_dist_x, 1, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
+            rotate([-90, 0, 0]) {
+                for (j = [-1, 1])
+                translate([-j * gb_endstop_slit_len, 0, 0])
+                cylinder(d = endstop_pcb_hole, h = endstop_mount_slot_depth + 1);
+                
+                translate([-gb_endstop_slit_len, -endstop_pcb_hole / 2, 0])
+                cube([2 * gb_endstop_slit_len, endstop_pcb_hole, endstop_mount_slot_depth + 1]);
+            }
+        }
+    }
 }
 
-module piston() {
-    //cylinder(d = piston_dia, h = piston_height);
-    roundedcylinder(piston_dia, piston_height, piston_radius, true);
+module gearbox_assembly() {
+    gearbox();
+    
+    // spacers
+    for (i = [0, 1])
+    translate([-gearbox_width / 2, gearbox_height / 2 - i * (gearbox_height + gearbox_spacer), -gearbox_wall])
+    top_cover(-i + 3);
+    
+    // top and bottom covers
+    for (i = [0, 1])
+    translate([-gearbox_width / 2, gearbox_height / 2 - i * (gearbox_height + gearbox_wall) - (i * 2 - 1) * gearbox_spacer, -gearbox_wall])
+    top_cover(-i + 1);
+    
+    %color("grey")
+    for (i = [-1, 1])
+    translate([0, i * gears_dist / 2, -gearbox_wall + 1])
+    cylinder(d = axis_diameter, h = gear_stages * gear_stage_height + gearbox_wall * 2 + gear_stages_dist * (gear_stages - 1) - 2);
 }
 
-module piston_cyl() {
+module bearing() {
     difference() {
-        cylinder(d = cylinder_dia, h = cylinder_height);
+        cylinder(d = bearing_outer, h = bearing_height);
         
-        translate([0, 0, piston_wall])
-        cylinder(d = piston_dia + 2 * piston_gap, h = cylinder_height + 2);
+        translate([0, 0, -1])
+        cylinder(d = bearing_inner, h = bearing_height + 2);
     }
 }
 
-module piston_visual() {
-    color("blue")
+module extruder_arm() {
     difference() {
-        piston_cyl();
+        color("blue")
+        union() {
+            // post for axis
+            cylinder(d = extruder_arm_axis_dia, h = extruder_arm_axis_h);
+            
+            // lever body
+            translate([-extruder_arm_width / 2, 0, 0])
+            cube([extruder_arm_width, extruder_arm_dia / 2, extruder_arm_axis_h]);
+            
+            translate([0, extruder_arm_dia / 2, 0]) {
+                // lever body
+                cylinder(d = extruder_arm_width, h = extruder_arm_axis_h);
+                
+                // post for bearing
+                translate([0, 0, extruder_arm_axis_h])
+                cylinder(d1 = extruder_arm_width, d2 = extruder_arm_post_dia, h = extruder_arm_post_h - extruder_arm_axis_h - extruder_arm_flare_off);
+                
+                translate([0, 0, extruder_arm_axis_h + (extruder_arm_post_h - extruder_arm_axis_h - extruder_arm_flare_off)])
+                cylinder(d = extruder_arm_post_dia, h = extruder_arm_flare_off);
+            }
+        }
         
-        translate([-cylinder_dia / 2, -cylinder_dia / 2 - 1, -1])
-        cube([cylinder_dia, cylinder_dia / 2 + 1, cylinder_height + 2]);
-    }
-    
-    translate([0, 0, piston_bottom_gap])
-    translate([0, 0, extruder_axis_anim_position]) {
-        color("green")
-        piston();
+        // holes for axis, bearing post
+        for (i = [0, 1])
+        translate([0, i * extruder_arm_dia / 2, -1])
+        cylinder(d = axis_hole_diameter, h = extruder_arm_post_h + 2);
         
-        %color("orange")
-        translate([0, 0, -actuator_length])
-        cylinder(d = 8, h = actuator_length);
+        // holes for grub screws
+        for(i = [-90, 90])
+        translate([0, 0, extruder_arm_axis_h / 2])
+        rotate([90, 0, i])
+        cylinder(d = belt_pulley_fix_dia, h = extruder_arm_axis_dia);
     }
+            
+    // bearing
+    %color("yellow")
+    translate([0, extruder_arm_dia / 2, extruder_arm_post_h + 1])
+    bearing();
+    
+    // axis
+    %color("grey")
+    translate([0, 0, -extruder_arm_off])
+    cylinder(d = axis_diameter, h = extruder_arm_off + extruder_arm_axis_h);
 }
 
-module extruder_lever() {
-    translate([-extruder_lever_width / 2, 0, -extruder_lever_length + (extruder_lever_length - extruder_lever_hole_dist) / 2])
+module extruder_actuator() {
     difference() {
-        cube([extruder_lever_width, extruder_lever_depth, extruder_lever_length]);
-        
-        translate([extruder_lever_width / 2, -1, (extruder_lever_length - extruder_lever_hole_dist) / 2])
-        rotate([-90, 0, 0]) {
-            for (i = [0, extruder_lever_hole_dist])
-            translate([0, -i, 0])
-            cylinder(d = extruder_lever_holes, h = extruder_lever_depth + 2);
+        color("orange")
+        union() {
+            cube([actuator_width, actuator_wall, actuator_height]);
+            
+            for (i = [0, 1])
+            for (j = [1, -1])
+            translate([i * actuator_width, 0, i * actuator_height])
+            rotate([0, i * 180, 0])
+            hull() {
+            //union() {
+                cube([actuator_width, actuator_wall, (actuator_height - actuator_slot_h) / 2]);
+                    
+                translate([(actuator_width - actuator_rod_width) / 2 + i * gearbox_width / 4 * j, actuator_wall - actuator_rod_width, -actuator_rod_h])
+                cube([actuator_rod_width, actuator_rod_width, actuator_rod_h]);
+            }
         }
+        
+        // slot for bearing
+        translate([(actuator_width - actuator_slot_w) / 2, -1, (actuator_height - actuator_slot_h) / 2])
+        cube([actuator_slot_w, actuator_wall + actuator_rod_width + 2, actuator_slot_h]);
+        
+        // holes for rod
+        for (i = [0, 1])
+        for (j = [1, -1])
+        translate([actuator_width / 2 + i * gearbox_width / 4 * j, actuator_wall - actuator_rod_width / 2, -actuator_rod_h - 1 + i * (actuator_height + actuator_rod_h / 2 + 1)])
+        cylinder(d = actuator_rod, h = actuator_rod_h + actuator_rod_inset + 1);
+        
+        // holes for rod grub screws
+        for (i = [0, 1])
+        for (j = [1, -1])
+        for (r = [-45, 45, 180])
+        translate([actuator_width / 2 + i * gearbox_width / 4 * j, actuator_wall - actuator_rod_width / 2, -actuator_rod_h / 2 + i * (actuator_height + actuator_rod_h)])
+        rotate([90, 0, r])
+        cylinder(d = belt_pulley_fix_dia, h = actuator_rod_width);
     }
+    
+    // rods
+    %color("yellow")
+    for (i = [0, 1])
+    for (j = [1, -1])
+    translate([actuator_width / 2 + (-i + 1) * gearbox_width / 4 * j, actuator_rod_width / 2 + actuator_wall - actuator_rod_width, actuator_height + i * (-actuator_height - actuator_rod_len - actuator_rod_len_add_bottom) + (i - 1) * actuator_rod_inset])
+    cylinder(d = actuator_rod, h = actuator_rod_len + i * actuator_rod_len_add_bottom + actuator_rod_inset);
 }
 
 module extruder() {
-    translate([0, gearbox_depth - gearbox_wall, -gears_dist / 2])
+    translate([0, gearbox_depth - gearbox_wall, gearbox_height / 2 + gearbox_wall])
     rotate([90, 0, 0])
     translate([0, 0, gearbox_depth - gearbox_wall * 2])
     rotate([0, 180, 0])
     gearbox_assembly();
     
-    translate([0, -cylinder_dia / 2, -cylinder_height - extruder_travel / 2]) {
-        translate([0, 0, -additional_piston_offset])
-        piston_visual();
-        
-        color("red")
-        translate([0, 0, cylinder_height + extruder_travel / 2])
-        rotate([0, -acos(anim_pos_extruder * -2 + 1), 0])
-        extruder_lever();
+    translate([0, -extruder_arm_off, gearbox_wall + gearbox_height / 2 + gears_dist / 2])
+    rotate([90, 0, 0])
+    if (show_extruder_maximum_positions) {
+        for (i = [0 : 360 / extruder_maximum_positions : 360])
+        rotate([0, 0, i])
+        extruder_arm();
+    } else {
+        rotate([0, 0, use_anim ? ($t * -360) : (extruder_axis_position * -180)])
+        extruder_arm();
+    }
+    
+    translate([-actuator_width / 2, -actuator_wall - extruder_arm_post_h - extruder_arm_off + 1, -actuator_height / 2 + gearbox_wall + gearbox_height / 2 + gears_dist / 2 + extruder_arm_dia / 2])
+    if (show_extruder_maximum_positions) {
+        for (i = [0 : 2 / extruder_maximum_positions : 1])
+        translate([0, 0, -i * extruder_arm_dia])
+        extruder_actuator();
+    } else {
+        translate([0, 0, -anim_pos_extruder * extruder_arm_dia])
+        extruder_actuator();
     }
 }
 
-module whole_extruder() {
-    translate([0, 0, cylinder_height + extruder_travel / 2 + additional_piston_offset])
-    extruder();
-}
-
-//gearbox_assembly();
-//piston();
-//piston_cyl();
-//extruder_lever();
+//gb_back_wall();
+//gb_front_wall();
 //center_plate();
-//outer_plate();
-//top_cover();
+//top_cover(0);
+//top_cover(1);
+//top_cover(2);
+//top_cover(3);
+//gearbox_assembly();
 
-//piston_visual();
+//extruder_arm();
+//extruder_actuator();
 
-whole_extruder();
+extruder();

hardware/table.scad

  ************** Y-Axis **************
  ************************************/
 
-module endstop_pcb() {
-    difference() {
-        cube([endstop_pcb_width, endstop_pcb_depth, endstop_pcb_height]);
-        
-        for (i = [0, 1])
-        translate([endstop_pcb_hole_dist_x, -1, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
-        rotate([-90, 0, 0])
-        cylinder(d = endstop_pcb_hole, h = endstop_pcb_depth + 2);
-    }
-    
-    translate([0, 0, endstop_pcb_height - endstop_pcb_switchpoint])
-    rotate([0, -90, 0])
-    cylinder(d = endstop_pcb_hole, h = endstop_pcb_switchpoint);
-}
-
-module endstop_mount_v1() {
-    %color("yellow")
-    translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
-    endstop_pcb();
-    
-    color("blue")
-    difference() {
-        cube([endstop_mount_width, endstop_mount_depth, 40]);
-        
-        for (i = [0, 1])
-        translate([endstop_mount_width / 2, -1, 10 + 20 * i])
-        rotate([-90, 0, 0])
-        cylinder(d = motor_mount_hole_size, h = endstop_mount_depth + 2);
-    }
-    
-    color("blue")
-    difference() {
-        union() {
-            hull() {
-                translate([-endstop_mount_slot_length, 0, 40 - endstop_mount_add_height])
-                cube([endstop_mount_slot_length, endstop_mount_depth, endstop_mount_add_height]);
-                
-                translate([0, 0, endstop_pcb_height - endstop_pcb_hole_dist_y - endstop_pcb_hole_dist])
-                translate([-endstop_pcb_mount_off_w, -endstop_pcb_mount_off_d, endstop_pcb_mount_off_h - endstop_mount_slot_width / 2])
-                cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
-                
-                for (i = [0, 1])
-                translate([0, 0, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
-                translate([-endstop_pcb_mount_off_w, -endstop_pcb_mount_off_d, endstop_pcb_mount_off_h - endstop_mount_slot_width / 2])
-                cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
-            }
-        }
-        
-        translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
-        for (i = [0, 1])
-        translate([endstop_pcb_hole_dist_x, -1, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
-        rotate([-90, 0, 0]) {
-            cylinder(d = endstop_pcb_hole, h = endstop_pcb_depth + 20);
-            
-            translate([0, 0, 1 + endstop_pcb_depth + endstop_mount_slot_depth])
-            cylinder(d = endstop_mount_nut_hole, h = 20, $fn = 6);
-        }
-    }
-}
-
-module endstop_mount_v2() {
-    %color("yellow")
-    translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
-    endstop_pcb();
-    
-    color("blue")
-    difference() {
-        cube([endstop_mount_width, endstop_mount_depth, 40]);
-        
-        for (i = [0, 1])
-        translate([endstop_mount_width / 2, -1, 10 + 20 * i])
-        rotate([-90, 0, 0])
-        cylinder(d = motor_mount_hole_size, h = endstop_mount_depth + 2);
-    }
-    
-    color("blue")
-    difference() {
-        union() {
-            hull() {
-                translate([-endstop_mount_slot_length, 0, 40 - endstop_mount_add_height])
-                cube([endstop_mount_slot_length, endstop_mount_depth, endstop_mount_add_height]);
-                
-                translate([0, 0, endstop_pcb_height - endstop_pcb_hole_dist_y - endstop_pcb_hole_dist])
-                translate([-endstop_pcb_mount_off_w, -endstop_pcb_mount_off_d, endstop_pcb_mount_off_h - endstop_mount_slot_width / 2])
-                cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
-            }
-            
-            hull() {
-                for (i = [0, 1])
-                translate([0, 0, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
-                translate([-endstop_pcb_mount_off_w, -endstop_pcb_mount_off_d, endstop_pcb_mount_off_h - endstop_mount_slot_width / 2])
-                cube([endstop_mount_slot_length, endstop_mount_slot_depth, endstop_mount_slot_width]);
-            }
-        }
-        
-        translate([-endstop_pcb_mount_off_w, -endstop_pcb_depth - endstop_pcb_mount_off_d, endstop_pcb_mount_off_h])
-        for (i = [0, 1])
-        translate([endstop_pcb_hole_dist_x, -1, endstop_pcb_height - endstop_pcb_hole_dist_y - i * endstop_pcb_hole_dist])
-        rotate([-90, 0, 0]) {
-            cylinder(d = endstop_pcb_hole, h = endstop_pcb_depth + 20);
-            
-            translate([0, 0, 1 + endstop_pcb_depth + endstop_mount_slot_depth])
-            cylinder(d = endstop_mount_nut_hole, h = 20, $fn = 6);
-        }
-    }
-}
-
-module endstop_mount() {
-    if (use_endstop_mount_v2) {
-        endstop_mount_v2();
-    } else {
-        endstop_mount_v1();
-    }
-}
-
 module belt_mount(h) {
     difference() {
         hull() {
     belt_tensioner(2, x_axis_rail_len, 0);
 }
 
-/************************************
- ************* Assembly *************
- ************************************/
+/*************************************
+ *************** Stuff ***************
+ *************************************/
+
+psu_width = 98.0;
+psu_height = 43.0;
+psu_length = 160;
+psu_cut_gap = 1.0;
+psu_cut_w = psu_width + psu_cut_gap;
+psu_cut_h = psu_height + psu_cut_gap;
+psu_wall = 4;
+psu_mount_len = 40 + psu_wall;
+psu_mount_w = psu_cut_w + 2 * psu_wall;
+psu_mount_h = psu_cut_h + 2 * psu_wall;
+psu_mount_hole_off = 10;
+psu_mount_tri = 3;
+psu_mount_del = psu_mount_tri;
+psu_assembly_mount_off_y = 25;
+psu_assembly_mount_off_z = 6;
+psu_hole_dia = 4.2;
+psu_back_hole_x = 9.5;
+psu_back_hole_y = 18.0;
+psu_cable_hole = 8.0;
+psu_cable_hole_off = 13.0;
+//psu_side_hole_y = 26.0;
+//psu_side_Hole_z = 20.0;
+
+power_socket_width = 48.0;
+power_socket_height = 28.0;
+power_socket_depth = 30;
+power_socket_hole = 2.7;
+power_socket_hole_off = 11.0 - 2.8 - 1.6;
+power_socket_rim = 11;
+power_socket_wr = power_socket_width + 2 * power_socket_rim;
+power_socket_hr = power_socket_height + 2 * power_socket_rim;
+
+power_box_width = 70;
+power_box_height = psu_mount_h;
+power_box_depth = 50;
+
+module power_socket() {
+    translate([-power_socket_width / 2, -power_socket_height / 2, -power_socket_depth])
+    cube([power_socket_width, power_socket_height, power_socket_depth]);
+    
+    difference() {
+        translate([-power_socket_wr / 2, -power_socket_hr / 2, 0])
+        cube([power_socket_wr, power_socket_hr, 2.0]);
+        
+        for (i = [-1, 1])
+        translate([0, i * (power_socket_height / 2 + power_socket_hole_off), -1])
+        cylinder(d = power_socket_hole, h = 4.0);
+    }
+}
 
-module assembly_y_axis_plate() {
-    translate([0, -y_carriage_y / 2 - y_axis_animation_position, 0])
-    y_axis();
+module power_box() {
+    %color("yellow")
+    translate([power_box_width / 2, power_box_depth, power_box_height / 2])
+    rotate([-90, 0, 0])
+    power_socket();
     
-    %translate([-plate_x / 2, -plate_y / 2, 20 + y_carriage_h + y_carriage_rail_dist + carriage_spacer_height])
-    plate();
+    color("cyan")
+    difference() {
+        translate([0, power_box_depth - psu_wall, 0])
+        cube([power_box_width, psu_wall, power_box_height]);
+        
+        translate([(power_box_width - power_socket_width) / 2, power_box_depth - 9, (power_box_height - power_socket_height) / 2])
+        cube([power_socket_width, 10, power_socket_height]);
+        
+        for (i = [1, -1])
+        translate([power_box_width / 2, power_box_depth + 1, (power_box_height - i * power_socket_height) / 2 - power_socket_hole_off * i])
+        rotate([90, 0, 0])
+        cylinder(d = power_socket_hole, h = psu_wall + 15);
+    }
 }
 
-module assembly_x_axis() {
-    x_axis();
+module psu_holder_tab() {
+    difference() {
+        translate([psu_mount_del, 0, 0])
+        cube([20 - psu_mount_del, psu_wall, psu_mount_len]);
+        
+        for (i = [psu_mount_hole_off, psu_mount_len - psu_mount_hole_off])
+        translate([10, -1, i])
+        rotate([-90, 0, 0])
+        cylinder(d = motor_mount_hole_size, h = psu_wall + 2);
+    }
+}
+
+module psu_holder_box(remove_back = 0) {
+    if (!remove_back)
+    translate([-psu_mount_w / 2, -psu_mount_h / 2 - psu_assembly_mount_off_z, 0])
+    cube([psu_mount_w, psu_mount_h, psu_wall]);
     
-    translate([x_axis_animation_position + y_carriage_y / 2, -y_axis_rail_len / 2, 20 + y_carriage_h + y_carriage_rail_dist])
-    translate([10, y_axis_animation_position + y_carriage_y / 2, 20])
-    assembly_y_axis_plate();
+    for (i = [-psu_mount_h / 2, psu_mount_h / 2 - psu_wall])
+    translate([-psu_mount_w / 2, i - psu_assembly_mount_off_z, 0])
+    cube([psu_mount_w, psu_wall, psu_mount_len]);
+    
+    for (i = [-psu_mount_w / 2, psu_mount_w / 2 - psu_wall])
+    translate([i, -psu_mount_h / 2 - psu_assembly_mount_off_z, 0])
+    cube([psu_wall, psu_mount_h, psu_mount_len]);
+    
+    for (i = [/* psu_mount_w / 2, */ -psu_mount_w / 2 - 20])
+    for (j = [10, -10 - psu_wall])
+    translate([i, j, 0])
+    psu_holder_tab();
+    
+    for (i = [0, 1])
+    translate([-psu_mount_w / 2 - i * psu_mount_tri, -psu_mount_tri - 10 - psu_wall + i * (psu_mount_tri + 20 + psu_wall * 2), 0])
+    rotate([0, -90, i * -90])
+    prism(psu_mount_len, psu_mount_tri, psu_mount_tri);
+}
+
+module psu_holder(part) {
+    // 0 is "back side" of psu
+    // 1 is "front" / cable side of psu
+    
+    difference() {
+        union() {
+            color("cyan")
+            translate([0, 0, part * psu_mount_len])
+            scale([1, 1, 1 + part * -2])
+            psu_holder_box(part);
+            
+            if (part == 1) {
+                color("cyan")
+                translate([0, -psu_mount_h / 2 - psu_assembly_mount_off_z, psu_mount_len])
+                hull() {
+                    translate([-power_box_width / 2, 0, power_box_depth - psu_wall - 1])
+                    cube([power_box_width, power_box_height, 1]);
+                    
+                    translate([-psu_mount_w / 2, 0, 0])
+                    cube([psu_mount_w, psu_mount_h, 1]);
+                }
+                
+                translate([-power_box_width / 2, psu_mount_h / 2 - psu_assembly_mount_off_z, psu_mount_len])
+                rotate([90, 0, 0])
+                power_box();
+            }
+        }
+        if (part == 0) {
+            translate([-psu_mount_w / 2 + psu_back_hole_x + psu_wall, psu_mount_h / 2 - psu_assembly_mount_off_z + 1, psu_back_hole_y + psu_wall])
+            rotate([90, 0, 0])
+            cylinder(d = psu_hole_dia, h = psu_wall + 2);
+        } else {
+            translate([0, -psu_mount_h / 2 - psu_assembly_mount_off_z, psu_mount_len])
+            hull() {
+                translate([-power_socket_width / 2, power_socket_height / 2 - psu_wall / 2, power_box_depth - psu_wall])
+                cube([power_socket_width, power_socket_height, 1]);
+                
+                translate([-psu_mount_w / 2 + psu_wall, psu_wall, -1])
+                cube([psu_mount_w - 2 * psu_wall, psu_mount_h - 2 * psu_wall, 1]);
+            }
+            
+            for (i = [-1, 0, 1])
+            translate([i * psu_cable_hole_off, 0, 0])
+            translate([0, -psu_mount_h / 2 + 5, psu_mount_len + power_box_depth / 4])
+            rotate([90, 0, 0])
+            cylinder(d = psu_cable_hole, h = psu_wall + 10);
+        }
+    }
+}
+
+module psu_holder_assembly() {
+    color("yellow")
+    translate([-psu_width / 2, psu_wall, -psu_height / 2 + psu_assembly_mount_off_z])
+    cube([psu_width, psu_length, psu_height]);
+    
+    for (i = [0, 1])
+    translate([0, i * (psu_length - psu_mount_len + 2 * psu_wall), 0])
+    rotate([-90, 0, 0])
+    psu_holder(i);
 }
 
 module rail_foot() {
     }
 }
 
+/************************************
+ ************* Assembly *************
+ ************************************/
+
+module assembly_y_axis_plate() {
+    translate([0, -y_carriage_y / 2 - y_axis_animation_position, 0])
+    y_axis();
+    
+    %translate([-plate_x / 2, -plate_y / 2, 20 + y_carriage_h + y_carriage_rail_dist + carriage_spacer_height])
+    plate();
+}
+
+module assembly_x_axis() {
+    x_axis();
+    
+    translate([x_axis_animation_position + y_carriage_y / 2, -y_axis_rail_len / 2, 20 + y_carriage_h + y_carriage_rail_dist])
+    translate([10, y_axis_animation_position + y_carriage_y / 2, 20])
+    assembly_y_axis_plate();
+}
+
 module assembly() {
     translate([-x_axis_rail_len / 2, 0, 20]) {
         assembly_x_axis();
                 %color("green")
                 rail_foot();
             }
+            
+            // TODO psu
         } else {
             color("grey")
             translate([x_axis_rail_len / 2, 0, -40])
                 rail_foot();
             }
         }
+        
+        translate([bottom_support_off + psu_mount_w / 2, 10 + psu_assembly_mount_off_y, 10 - 40])
+        psu_holder_assembly();
     }
 }
 
 //rail_2020_x(100);
 //rail_wheel();
 //rail_foot();
+//psu_holder(0);
+//psu_holder(1);
+//psu_holder_assembly();
 
 //motor_mount(1);
 //motor_mount(2);

include/config.h

 // xy steps per mm
 #define XY_BELT_PITCH 2.0
 #define XY_PULLEY_TEETH 40.0
-#define XY_MICRO_STEPS 16.0
+#define XY_MICRO_STEPS 8.0
 #define XY_MOTOR_STEPS_PER_REV (200.0 * XY_MICRO_STEPS)
 #define XY_STEPS_PER_MM (XY_MOTOR_STEPS_PER_REV / XY_PULLEY_TEETH / XY_BELT_PITCH)
 
 // z steps per mm
 #define Z_ROD_PITCH 2.0
-#define Z_MICRO_STEPS 16.0
+#define Z_MICRO_STEPS 8.0
 #define Z_MOTOR_STEPS_PER_REV (200.0 * Z_MICRO_STEPS)
 #define Z_STEPS_PER_MM (Z_MOTOR_STEPS_PER_REV / Z_ROD_PITCH)
 
 // 4800 / 100 = 48 steps for one percent of movement
 #define GEARBOX_MULT 3
 #define OUTPUT_TURN_DIV 2
-#define E_MICRO_STEPS 16.0
+#define E_MICRO_STEPS 8.0
 #define E_MOTOR_STEPS_PER_REV (200.0 * E_MICRO_STEPS)
 #define E_STEPS_PER_PERCENT (E_MOTOR_STEPS_PER_REV * GEARBOX_MULT / OUTPUT_TURN_DIV / 100.0)
 
 #define E_MM_TO_PERCENT(x) ((acos((x * 2.0 / E_AXIS_MAX) - 1.0) - PI) * 100.0 / PI)
 
 // maximum speeds
-#define XY_MAX_SPEED 50.0 // in mm/s --> 50mm/s = 2000steps/s
-#define Z_MAX_SPEED 1.2 // in mm/s --> 20mm/s = 32000steps/s
-#define E_MAX_SPEED 30.0 // in percent/s --> 50%/s = 2400steps/s
+#define XY_MAX_SPEED 50.0 // in mm/s --> 50mm/s = 1000steps/s
+#define Z_MAX_SPEED 1.2 // in mm/s --> 20mm/s = 16000steps/s
+#define E_MAX_SPEED 200.0 // in percent/s --> 50%/s = 1200steps/s
 
 // homing speeds
 #define XY_FAST_HOME_SPEED 25.0 // in mm/s
 #define XY_SLOW_HOME_SPEED 5.0 // in mm/s
 #define Z_FAST_HOME_SPEED 5.0 // in mm/s
 #define Z_SLOW_HOME_SPEED 1.0 // in mm/s
-#define E_FAST_HOME_SPEED 10.0 // in percent/s
-#define E_SLOW_HOME_SPEED 2.0 // in percent/s
+#define E_FAST_HOME_SPEED 50.0 // in percent/s
+#define E_SLOW_HOME_SPEED 20.0 // in percent/s
 
 // accelerations
-#define XY_MAX_ACCEL 100.0 // in mm/s^2
+#define XY_MAX_ACCEL 2000.0 // in mm/s^2
 #define Z_MAX_ACCEL 50.0 // in mm/s^2
-#define E_MAX_ACCEL 1000.0 // in percent/s^2
+#define E_MAX_ACCEL 5000.0 // in percent/s^2
 
 // axis movement directions (1.0 normal, -1.0 inverted)
 #define X_AXIS_MOVEMENT_DIR 1.0
 #define Y_AXIS_MOVEMENT_DIR 1.0
 #define Z_AXIS_MOVEMENT_DIR 1.0
-#define E_AXIS_MOVEMENT_DIR 1.0
+#define E_AXIS_MOVEMENT_DIR -1.0
 
 // homing back-off
 #define XY_BACK_OFF_DISTANCE 5.0 // in mm
 #define Z_BACK_OFF_DISTANCE 2.0 // in mm
-#define E_BACK_OFF_DISTANCE 1.0 // in mm
 
 #define XY_HOME_BACK_OFF_TIME (XY_BACK_OFF_DISTANCE / XY_FAST_HOME_SPEED * 1000)
 #define Z_HOME_BACK_OFF_TIME (Z_BACK_OFF_DISTANCE / Z_FAST_HOME_SPEED * 1000)
-#define E_HOME_BACK_OFF_TIME (E_BACK_OFF_DISTANCE / E_FAST_HOME_SPEED * 1000)
 
 // epsilon around expected endstop position where we dont abort on hits
 // if you need to increase this value, try to reduce play in your axis
-#define X_AXIS_EPSILON 1.0
-#define Y_AXIS_EPSILON 1.0
-#define Z_AXIS_EPSILON 1.0
-#define E_AXIS_EPSILON 1.0
+#define X_AXIS_EPSILON 2.0 // in mm
+#define Y_AXIS_EPSILON 2.0 // in mm
+#define Z_AXIS_EPSILON 1.0 // in mm
+#define E_AXIS_EPSILON 50.0 // TODO
 
-#define ENCODER_RPM_VALUE_FACTOR 2.0
+#define ENCODER_RPM_VALUE_FACTOR 0.5
 #define IDLE_TIMEOUT (5UL * 60UL * 1000UL) // ms, 0 to disable
 
 // TimerOne freq for steppers

include/config_pins.h

 #define Z_STEP_PIN         46
 #define Z_DIR_PIN          48
 #define Z_ENABLE_PIN       62
+
+// Using a Z-MAX endstop, plugged into Z_MIN pin
 #define Z_MIN_PIN          -1 // 18
-#define Z_MAX_PIN          19
+#define Z_MAX_PIN          18 // 19
 
 //extruder 1
 #define E0_STEP_PIN        26
 #define E0_DIR_PIN         28
 #define E0_ENABLE_PIN      24
 
-// use the remaining z endstop pin for e axis
-#define E_MIN_PIN          18
-#define E_MAX_PIN          -1
+// use Z_MAX pin for e axis
+#define E_ENDSTOP_PIN      19
 
 //extruder 2
 #define E1_STEP_PIN        36
 #error define one of Z_MIN_PIN or Z_MAX_PIN
 #endif
 
-#if ((E_MIN_PIN != -1) && (E_MAX_PIN != -1)) || ((E_MIN_PIN == -1) && (E_MAX_PIN == -1))
-#error define one of E_MIN_PIN or E_MAX_PIN
-#endif
-
 #if (X_MIN_PIN == -1)
 #define X_HOMING_DIR 1
 #define X_ENDSTOP_PIN X_MAX_PIN
 #define Z_ENDSTOP_PIN Z_MIN_PIN
 #endif
 
-#if (E_MIN_PIN == -1)
-#define E_HOMING_DIR 1
-#define E_ENDSTOP_PIN E_MAX_PIN
-#else
-#define E_HOMING_DIR -1
-#define E_ENDSTOP_PIN E_MIN_PIN
-#endif
+#define E_HOMING_DIR -1.0
 
 #ifdef KILL_PIN
 #if (KILL_PIN == -1)

include/statemachine.h

     T mins[N], maxs[N];
     const char *texts[N];
     const char *heading;
-    size_t pos;
+    size_t pos, off;
     bool editing;
     UpdateFuncPtr updateFunc, updateLiveFunc;
 };

src/lcd.cpp

 
 #include <U8g2lib.h>
 
-//#define ENABLE_DYNAMIC_SCROLLING
+#define ENABLE_DYNAMIC_SCROLLING
 
 #define LCD_HEADING_LINES 1
 #define LCD_HEADING_WIDTH 15
 }
 
 void lcd_clear(void) {
-    Serial.println();
+    //Serial.println();
 
     text_mode = lcd_mode_none;
 
 }
 
 void lcd_set_menu_text(int line, const char *t) {
-    Serial.print(line);
-    Serial.print(F(": "));
+    if ((line < 0) || (line >= LCD_TEXT_LINES)) {
+        Serial.print(F("Invalid lcd line no: "));
+        Serial.println(line);
+        return;
+    }
+
+    //Serial.print(line);
+    //Serial.print(F(": "));
     Serial.println(t);
 
     text_mode = lcd_mode_menu;

src/main.cpp

 #include "steppers.h"
 #include "states.h"
 
-const static float hz = min(max(max(XY_MAX_HZ, Z_MAX_HZ), E_MAX_HZ), MAX_SAMPLE_FREQ);
+const static float hz = min(max(max(XY_MAX_HZ, Z_MAX_HZ), E_MAX_HZ), MAX_SAMPLE_FREQ) * 2.0;
 const static float us = (1000.0 * 1000.0) / hz;
 
 void print_data(void) {
     Serial.println(F("Init stepper motors"));
     steppers_init();
 
-    //print_data();
+    print_data();
 
     Serial.println(F("ready, showing splash screen"));
     digitalWrite(LED_PIN, LOW);
     // allow rudimentary control over serial
     // with enter and w/s or arrow up/down for encoder
     // and q/k/space keys for kill
+    // arrow left/right do 10-increments of encoder
     static int ser_state = 0;
     while (Serial.available()) {
         int c = Serial.read();
                 change = 1;
             } else if (c == 'B') {
                 change = -1;
+            } else if (c == 'C') {
+                rpm = 9 * ENCODER_RPM_VALUE_FACTOR;
+                change = -1;
+            } else if (c == 'D') {
+                rpm = 9 * ENCODER_RPM_VALUE_FACTOR;
+                change = 1;
             }
             ser_state = 0;
         }

src/sm_value.cpp

     updateFunc = NULL;
     updateLiveFunc = NULL;
     pos = 0;
+    off = 0;
     editing = false;
 }
 
         lcd_set_heading(heading);
     }
 
-    for (size_t i = 0; i < (N + 1); i++) {
+    for (size_t i = off; (i < (N + 1)) && (i < (off + lcd_text_lines())); i++) {
         String s;
 
         if (i == pos) {
         }
 
         if (i < N) {
-            s += texts[i] + String(*(values[i])) + F(" (") + String(mins[i]) + F("/") + String(maxs[i]) + F(")");
+            s += texts[i] + String(F(" ")) + String(*(values[i])) + F(" (") + String(mins[i]) + F("/") + String(maxs[i]) + F(")");
         } else {
             if (getChild() != NULL) {
                 s += F("Continue");
             }
         }
 
-        lcd_set_menu_text(i, s.c_str());
+        lcd_set_menu_text(i - off, s.c_str());
     }
 }
 
                 tmp += N + 1;
             }
 
-            while (tmp >= (N + 1)) {
+            while (tmp >= N + 1) {
                 tmp -= N + 1;
             }
 
-            pos = tmp;
+            while (tmp < off) {
+                off--;
+            }
 
+            while (tmp >= (off + lcd_text_lines())) {
+                off++;
+            }
+
+            pos = tmp;
             display();
         }
         if (smi.click) {
 
 template class StateValues<uint8_t, 2>;
 template class StateValues<float, 2>;
+template class StateValues<float, 12>;

src/states.cpp

 //#define DISABLE_HOMING_STATE
 #define ENABLE_MOVEMENT_TEST_STATE
 #define ENABLE_INPUT_TEST_STATE
+#define ENABLE_MAX_SPEED_ACCEL_STATE
 
 // --------------------------------------
 
 int preset_selection = 0, dispense_off = 0,  dispense_count = 0, dispense_index = 0;
 float move_pos_x = 0.0, move_pos_y = 0.0, move_pos_z = 0.0, move_pos_e = 0.0;
+float mod_count_x, mod_count_y;
+float mod_distance_x, mod_distance_y;
+float mod_offset_x, mod_offset_y;
+float mod_move_z;
+float mod_bottom_z, mod_top_z;
+float mod_extrusion_length;
+float mod_extrusion_bottom_wait;
+float mod_extrusion_top_wait;
 
 State sm_ask_homing = State();
 State sm_do_homing = State(&sm_ask_homing);
 State sm_new_preset_done = State(&sm_wiz_last_pos);
 
 StateDynamicMenu sm_mod_preset = StateDynamicMenu(&sm_auto);
-// TODO modify
+StateValues<float, 12> sm_mod_values = StateValues<float, 12>(&sm_mod_preset);
 
 StateDynamicMenu sm_del_preset = StateDynamicMenu(&sm_auto);
-// TODO delete
+// TODO delete yes/no choice
 
 StateMenu sm_move = StateMenu(&sm_menu);
 StateValue<float> sm_move_x = StateValue<float>(&sm_move, move_pos_x, X_AXIS_MIN, X_AXIS_MAX);
 
 State sm_error = State(NULL);
 
-#if defined(ENABLE_MOVEMENT_TEST_STATE) || defined(ENABLE_INPUT_TEST_STATE)
+#if defined(ENABLE_MOVEMENT_TEST_STATE) || defined(ENABLE_INPUT_TEST_STATE) || defined(ENABLE_MAX_SPEED_ACCEL_STATE)
 StateMenu sm_debug = StateMenu(&sm_menu);
 #endif
 
 State sm_input_test = State(&sm_debug);
 #endif // ENABLE_INPUT_TEST_STATE
 
+#ifdef ENABLE_MAX_SPEED_ACCEL_STATE
+State sm_set_max_speed = State(&sm_debug);
+State sm_set_max_accel = State(&sm_debug);
+#endif // ENABLE_MAX_SPEED_ACCEL_STATE
+
 // --------------------------------------
 
 State *current_state = NULL;
         int y = dispense_index / data_preset(preset_selection)->count_x;
         int x = dispense_index % data_preset(preset_selection)->count_x;
 
+        // keep movements shorter by switching x axis every odd y row
+        if (y % 2) {
+            x = data_preset(preset_selection)->count_x - x - 1;
+        }
+
         Serial.print(F("xy_travel: index="));
         Serial.print(dispense_index);
         Serial.print(F(" x="));
     });
 
     sm_wiz_count.setTitle("Container Count");
-    sm_wiz_count.setData(0, "X: ", &wizard_preset.count_x, 1, 50);
-    sm_wiz_count.setData(1, "Y: ", &wizard_preset.count_y, 1, 100);
+    sm_wiz_count.setData(0, "X:", &wizard_preset.count_x, 1, 50);
+    sm_wiz_count.setData(1, "Y:", &wizard_preset.count_y, 1, 100);
 
     sm_wiz_first_pos.setTitle("First Container Position");
-    sm_wiz_first_pos.setData(0, "X: ", &wizard_first_x, X_AXIS_MIN, X_AXIS_MAX);
-    sm_wiz_first_pos.setData(1, "Y: ", &wizard_first_y, Y_AXIS_MIN, Y_AXIS_MAX);
+    sm_wiz_first_pos.setData(0, "X:", &wizard_first_x, X_AXIS_MIN, X_AXIS_MAX);
+    sm_wiz_first_pos.setData(1, "Y:", &wizard_first_y, Y_AXIS_MIN, Y_AXIS_MAX);
     sm_wiz_first_pos.onEnter([]() {
         wizard_first_x = steppers_current_pos(0);
         wizard_first_y = steppers_current_pos(1);
     });
 
     sm_wiz_last_pos.setTitle("Last Container Position");
-    sm_wiz_last_pos.setData(0, "X: ", &wizard_last_x, X_AXIS_MIN, X_AXIS_MAX);
-    sm_wiz_last_pos.setData(1, "Y: ", &wizard_last_y, Y_AXIS_MIN, Y_AXIS_MAX);
+    sm_wiz_last_pos.setData(0, "X:", &wizard_last_x, X_AXIS_MIN, X_AXIS_MAX);
+    sm_wiz_last_pos.setData(1, "Y:", &wizard_last_y, Y_AXIS_MIN, Y_AXIS_MAX);
     sm_wiz_last_pos.onEnter([]() {
         wizard_last_x = steppers_current_pos(0);
         wizard_last_y = steppers_current_pos(1);
         }
     });
 
-    // TODO
     sm_mod_preset.setTitle("Modify Preset");
     sm_mod_preset.setPrefix("Preset ");
     sm_mod_preset.dataCount([]() {
         return (int)data_preset_count();
     });
     sm_mod_preset.dataGet(preset_name_func);
+    sm_mod_preset.dataCall([](int i) {
+        preset_selection = i;
+        states_go_to(&sm_mod_values);
+    });
+
+    sm_mod_values.setTitle("Modify Preset");
+    sm_mod_values.setData(0, "Count X", &mod_count_x, 1, 50);
+    sm_mod_values.setData(1, "Count Y", &mod_count_y, 1, 100);
+    sm_mod_values.setData(2, "Distance X", &mod_distance_x, X_AXIS_MIN, X_AXIS_MAX);
+    sm_mod_values.setData(3, "Distance Y", &mod_distance_y, Y_AXIS_MIN, Y_AXIS_MAX);
+    sm_mod_values.setData(4, "Offset X", &mod_offset_x, X_AXIS_MIN, X_AXIS_MAX);
+    sm_mod_values.setData(5, "Offset Y", &mod_offset_y, Y_AXIS_MIN, Y_AXIS_MAX);
+    sm_mod_values.setData(6, "Travel Z", &mod_move_z, Z_AXIS_MIN, Z_AXIS_MAX);
+    sm_mod_values.setData(7, "Bottom Z", &mod_bottom_z, Z_AXIS_MIN, Z_AXIS_MAX);
+    sm_mod_values.setData(8, "Top Z", &mod_top_z, Z_AXIS_MIN, Z_AXIS_MAX);
+    sm_mod_values.setData(9, "Extrusion Length", &mod_extrusion_length, E_AXIS_MIN, E_AXIS_MAX);
+    sm_mod_values.setData(10, "Extrusion Bottom", &mod_extrusion_bottom_wait, 0, 10);
+    sm_mod_values.setData(11, "Extrusion Top", &mod_extrusion_top_wait, 0, 10);
+    sm_mod_values.onEnter([]() {
+        mod_count_x = data_preset(preset_selection)->count_x;
+        mod_count_y = data_preset(preset_selection)->count_y;
+        mod_distance_x = data_preset(preset_selection)->distance_x;
+        mod_distance_y = data_preset(preset_selection)->distance_y;
+        mod_offset_x = data_preset(preset_selection)->offset_x;
+        mod_offset_y = data_preset(preset_selection)->offset_y;
+        mod_move_z = data_preset(preset_selection)->move_z;
+        mod_bottom_z = data_preset(preset_selection)->bottom_z;
+        mod_top_z = data_preset(preset_selection)->top_z;
+        mod_extrusion_length = data_preset(preset_selection)->extrusion_length;
+        mod_extrusion_bottom_wait = data_preset(preset_selection)->extrusion_bottom_wait;
+        mod_extrusion_top_wait = data_preset(preset_selection)->extrusion_top_wait;
+    });
+    sm_mod_values.onUpdate([](size_t i, float v) {
+        if (i == 0) {
+            data_preset(preset_selection)->count_x = v;
+        } else if (i == 1) {
+            data_preset(preset_selection)->count_y = v;
+        } else if (i == 2) {
+            data_preset(preset_selection)->distance_x = v;
+        } else if (i == 3) {
+            data_preset(preset_selection)->distance_y = v;
+        } else if (i == 4) {
+            data_preset(preset_selection)->offset_x = v;
+        } else if (i == 5) {
+            data_preset(preset_selection)->offset_y = v;
+        } else if (i == 6) {
+            data_preset(preset_selection)->move_z = v;
+        } else if (i == 7) {
+            data_preset(preset_selection)->bottom_z = v;
+        } else if (i == 8) {
+            data_preset(preset_selection)->top_z = v;
+        } else if (i == 9) {
+            data_preset(preset_selection)->extrusion_length = v;
+        } else if (i == 10) {
+            data_preset(preset_selection)->extrusion_bottom_wait = v;
+        } else if (i == 11) {
+            data_preset(preset_selection)->extrusion_top_wait = v;
+        }
+    });
 
     sm_del_preset.setTitle("Delete Preset");
     sm_del_preset.setPrefix("Preset ");
     sm_error.setHeading("Axis Error");
     sm_error.setText("An unknown error occured!");
 
-#if defined(ENABLE_MOVEMENT_TEST_STATE) || defined(ENABLE_INPUT_TEST_STATE)
+#if defined(ENABLE_MOVEMENT_TEST_STATE) || defined(ENABLE_INPUT_TEST_STATE) || defined(ENABLE_MAX_SPEED_ACCEL_STATE)
     sm_debug.setTitle("Debug Menu");
 #endif
 
         static bool s = false;
         if (smi.motor_done[E_AXIS]) {
             s = !s;
-            steppers_move_e(s ? (E_AXIS_MAX - E_AXIS_EPSILON) : (E_AXIS_MIN + E_AXIS_EPSILON));
+            steppers_move_e(s ? (E_AXIS_MAX /* - E_AXIS_EPSILON */) : (E_AXIS_MIN /* + E_AXIS_EPSILON */));
         }
         if (smi.click) {
             states_go_to(&sm_movement_test);
     });
 #endif // ENABLE_INPUT_TEST_STATE
 
+#ifdef ENABLE_MAX_SPEED_ACCEL_STATE
+    sm_set_max_speed.setTitle("Set Max Speeds");
+    sm_set_max_speed.setText("Maximum speeds have been set for all axes. Don't forget to store to EEPROM if desired!");
+    sm_set_max_speed.onEnter([]() {
+        data_options()->speed_x = XY_MAX_SPEED;
+        data_options()->speed_y = XY_MAX_SPEED;
+        data_options()->speed_z = Z_MAX_SPEED;
+        data_options()->speed_e = E_MAX_SPEED;
+
+        steppers_set_speed_x(data_options()->speed_x);
+        steppers_set_speed_y(data_options()->speed_y);
+        steppers_set_speed_z(data_options()->speed_z);
+        steppers_set_speed_e(data_options()->speed_e);
+    });
+
+    sm_set_max_accel.setTitle("Set Max Accels");
+    sm_set_max_accel.setText("Maximum accelerations have been set for all axes. Don't forget to store to EEPROM if desired!");
+    sm_set_max_accel.onEnter([]() {
+        data_options()->accel_x = XY_MAX_ACCEL;
+        data_options()->accel_y = XY_MAX_ACCEL;
+        data_options()->accel_z = Z_MAX_ACCEL;
+        data_options()->accel_e = E_MAX_ACCEL;
+
+        steppers_set_accel_x(data_options()->accel_x);
+        steppers_set_accel_y(data_options()->accel_y);
+        steppers_set_accel_z(data_options()->accel_z);
+        steppers_set_accel_e(data_options()->accel_e);
+    });
+#endif // ENABLE_MAX_SPEED_ACCEL_STATE
+
     // ----------------------------------
 
     states_go_to(&sm_ask_homing);

src/steppers.cpp

 #include "states.h"
 #include "steppers.h"
 
+#define DEBUG_PRINT_STEPPER_HOME
+#define DISABLE_ENDSTOP_CHECKS_AT_RUNTIME
+
 static AccelStepper stepper_x(AccelStepper::DRIVER, X_STEP_PIN, X_DIR_PIN, 0, 0, false);
 static AccelStepper stepper_y(AccelStepper::DRIVER, Y_STEP_PIN, Y_DIR_PIN, 0, 0, false);
 static AccelStepper stepper_z(AccelStepper::DRIVER, Z_STEP_PIN, Z_DIR_PIN, 0, 0, false);
 static AccelStepper stepper_e(AccelStepper::DRIVER, E0_STEP_PIN, E0_DIR_PIN, 0, 0, false);
 
+// X Y Z
 #define HOME_PHASE_START 0
 #define HOME_PHASE_BACK 1
 #define HOME_PHASE_FINE 2
 
+// E
+#define HOME_PHASE_END 3
+
 enum stepper_states {
     step_disabled,
     step_not_homed,
     step_homing_z_fast,
     step_homing_z_back,
     step_homing_z_slow,
-    step_homing_e_fast,
-    step_homing_e_back,
-    step_homing_e_slow,
+    step_homing_e_start,
+    step_homing_e_left,
+    step_homing_e_right,
+    step_homing_e_end,
     step_homed
 };
 
 }
 
 static void steppers_initiate_home(int axis, int phase) {
-#if 0
+#ifdef DEBUG_PRINT_STEPPER_HOME
     Serial.print(F("steppers_initiate_home("));
-    if (axis == 0) {
+    if (axis == X_AXIS) {
         Serial.print('X');
-    } else if (axis == 1) {
+    } else if (axis == Y_AXIS) {
         Serial.print('Y');
-    } else if (axis == 2) {
+    } else if (axis == Z_AXIS) {
         Serial.print('Z');
-    } else if (axis == 3) {
+    } else if (axis == E_AXIS) {
         Serial.print('E');
     } else {
         Serial.print(axis);
     Serial.print(F(", "));
     Serial.print(phase);
     Serial.println(F(")"));
-#endif
+#endif // DEBUG_PRINT_STEPPER_HOME
 
     CLEAR_STORE_INTERRUPTS();
 
     steppers_home_move_start_time = millis();
 
     if (axis == X_AXIS) {
-        // x
         if (phase == HOME_PHASE_START) {
             if (steppers_home_switch(axis)) {
 #if (X_MIN_PIN == -1)
                 stepper_x.setCurrentPosition(X_AXIS_MIN * XY_STEPS_PER_MM * X_AXIS_MOVEMENT_DIR);
 #endif
 
-                // TODO order of homing
                 steppers_initiate_home(Y_AXIS, HOME_PHASE_START);
             } else {
                 state = step_homing_x_fast;
             stepper_x.setSpeed(X_HOMING_DIR * X_AXIS_MOVEMENT_DIR * XY_SLOW_HOME_SPEED * XY_STEPS_PER_MM);
         }
     } else if (axis == Y_AXIS) {
-        // y
         if (phase == HOME_PHASE_START) {
             if (steppers_home_switch(axis)) {
 
                 stepper_y.setCurrentPosition(Y_AXIS_MIN * XY_STEPS_PER_MM * Y_AXIS_MOVEMENT_DIR);
 #endif
 
-                // TODO order of homing
-                //steppers_initiate_home(Z_AXIS, HOME_PHASE_START);
-                state = step_homed;
+                steppers_initiate_home(E_AXIS, HOME_PHASE_START);
             } else {
                 state = step_homing_y_fast;
                 stepper_y.setSpeed(Y_HOMING_DIR * Y_AXIS_MOVEMENT_DIR * XY_FAST_HOME_SPEED * XY_STEPS_PER_MM);
             stepper_y.setSpeed(Y_HOMING_DIR * Y_AXIS_MOVEMENT_DIR * XY_SLOW_HOME_SPEED * XY_STEPS_PER_MM);
         }
     } else if (axis == Z_AXIS) {
-        // z
         if (phase == HOME_PHASE_START) {
             state = step_homing_z_fast;
             stepper_z.setSpeed(Z_HOMING_DIR * Z_AXIS_MOVEMENT_DIR * Z_FAST_HOME_SPEED * Z_STEPS_PER_MM);
             stepper_z.setSpeed(Z_HOMING_DIR * Z_AXIS_MOVEMENT_DIR * Z_SLOW_HOME_SPEED * Z_STEPS_PER_MM);
         }
     } else if (axis == E_AXIS) {
-        // e
         if (phase == HOME_PHASE_START) {
-            state = step_homing_e_fast;
-            stepper_e.setSpeed(E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_FAST_HOME_SPEED * E_STEPS_PER_PERCENT);
+            if (steppers_home_switch(axis)) {
+                Serial.println(F("already hit, continue"));
+
+                steppers_initiate_home(E_AXIS, HOME_PHASE_BACK);
+            } else {
+                Serial.println(F("moving towards endstop"));
+
+                state = step_homing_e_start;
+                stepper_e.setSpeed(-1.0 * E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_FAST_HOME_SPEED * E_STEPS_PER_PERCENT);
+            }
         } else if (phase == HOME_PHASE_BACK) {
-            state = step_homing_e_back;
-            stepper_e.setSpeed(-1.0 * E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_FAST_HOME_SPEED * E_STEPS_PER_PERCENT);
-        } else if (phase == HOME_PHASE_FINE) {
-            state = step_homing_e_slow;
+            Serial.println(F("moving toward left end"));
+
+            state = step_homing_e_left;
             stepper_e.setSpeed(E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_SLOW_HOME_SPEED * E_STEPS_PER_PERCENT);
+        } else if (phase == HOME_PHASE_FINE) {
+            Serial.print(F("moving toward right end, at "));
+            Serial.println(E_MM_TO_PERCENT(E_AXIS_MAX / 2) * E_STEPS_PER_PERCENT * E_AXIS_MOVEMENT_DIR * E_HOMING_DIR);
+
+            state = step_homing_e_right;
+            stepper_e.setMaxSpeed(E_SLOW_HOME_SPEED * E_STEPS_PER_PERCENT);
+            stepper_e.moveTo(E_MM_TO_PERCENT(E_AXIS_MAX / 2) * E_STEPS_PER_PERCENT * E_AXIS_MOVEMENT_DIR * E_HOMING_DIR);
+        } else if (phase == HOME_PHASE_END) {
+            Serial.print(F("moving toward new zero, at "));
+            Serial.println(stepper_e.currentPosition() / 2);
+
+            state = step_homing_e_end;
+            stepper_e.setMaxSpeed(E_FAST_HOME_SPEED * E_STEPS_PER_PERCENT);
+            stepper_e.moveTo(stepper_e.currentPosition() / 2);
         }
     } else {
         Serial.println(F("home_init error: invalid axis"));
 
 void steppers_run(void) {
     if ((state == step_homed) || (state == step_not_homed)) {
+#ifndef DISABLE_ENDSTOP_CHECKS_AT_RUNTIME
         for (int i = 0; i < AXIS_COUNT; i++) {
 #if 0
             Serial.print(i);
     #endif
                 } else if (i == E_AXIS) {
                     epsilon = E_AXIS_EPSILON;
-    #if (E_HOMING_DIR == 1)
-                    compare = E_AXIS_MAX;
-    #else
-                    compare = E_AXIS_MIN;
-    #endif
+                    // TODO compare to 0 and 200%!
                 }
 
                 if (fabs(steppers_current_pos(i) - compare) > epsilon) {
                 }
             }
         }
+#endif // DISABLE_ENDSTOP_CHECKS_AT_RUNTIME
 
         x_finished = !stepper_x.run();
         y_finished = !stepper_y.run();
             stepper_y.setCurrentPosition(Y_AXIS_MIN * XY_STEPS_PER_MM * Y_AXIS_MOVEMENT_DIR);
 #endif
 
-            //steppers_initiate_home(E_AXIS, HOME_PHASE_START);
-            // TODO
-            state = step_homed;
+            steppers_initiate_home(E_AXIS, HOME_PHASE_START);
         } else {
             stepper_y.runSpeed();
         }
         } else {
             stepper_z.runSpeed();
         }
-    } else if (state == step_homing_e_fast) {
+    } else if (state == step_homing_e_start) {
         if (steppers_home_switch(E_AXIS)) {
             steppers_initiate_home(E_AXIS, HOME_PHASE_BACK);
         } else {
             stepper_e.runSpeed();
         }
-    } else if (state == step_homing_e_back) {
-        unsigned long end_time = steppers_home_move_start_time + E_HOME_BACK_OFF_TIME;
-        if ((!steppers_home_switch(E_AXIS)) && (millis() >= end_time)) {
+    } else if (state == step_homing_e_left) {
+        if (!steppers_home_switch(E_AXIS)) {
+            stepper_e.setSpeed(0);
+            stepper_e.setCurrentPosition(0);
             steppers_initiate_home(E_AXIS, HOME_PHASE_FINE);
         } else {
             stepper_e.runSpeed();
         }
-    } else if (state == step_homing_e_slow) {
-        if (steppers_home_switch(E_AXIS)) {
-            stepper_e.setSpeed(0);
-
-#if (E_MIN_PIN == -1)
-            stepper_e.setCurrentPosition(E_MM_TO_PERCENT(E_AXIS_MAX) * E_STEPS_PER_PERCENT * E_AXIS_MOVEMENT_DIR);
-#else
+    } else if (state == step_homing_e_right) {
+        if ((!steppers_home_switch(E_AXIS)) && ((stepper_e.currentPosition() > 200) || (stepper_e.currentPosition() < -200))) {
+            // TODO only if we've moved a bit (250 is center)
+            steppers_initiate_home(E_AXIS, HOME_PHASE_END);
+        } else {
+            stepper_e.run();
+        }
+    } else if (state == step_homing_e_end) {
+        if (!stepper_e.run()) {
+            stepper_e.setMaxSpeed(data_options()->speed_e * E_STEPS_PER_PERCENT);
             stepper_e.setCurrentPosition(E_MM_TO_PERCENT(E_AXIS_MIN) * E_STEPS_PER_PERCENT * E_AXIS_MOVEMENT_DIR);
-#endif
-
             state = step_homed;
-        } else {
-            stepper_e.runSpeed();
         }
     }
 }
         r = 'Y';
     } else if ((state == step_homing_z_fast) || (state == step_homing_z_back) || (state == step_homing_z_slow)) {
         r = 'Z';
-    } else if ((state == step_homing_e_fast) || (state == step_homing_e_back) || (state == step_homing_e_slow)) {
+    } else if ((state == step_homing_e_start) || (state == step_homing_e_left) || (state == step_homing_e_right) || (state == step_homing_e_end)) {
         r = 'E';
     }
 
     stepper_z.enableOutputs();
     stepper_e.enableOutputs();
 
-    //steppers_initiate_home(Z_AXIS, HOME_PHASE_START);
     // TODO
+    //steppers_initiate_home(Z_AXIS, HOME_PHASE_START);
     steppers_initiate_home(X_AXIS, HOME_PHASE_START);
 
     RESTORE_INTERRUPTS();