box_frame/bushing.scad

   1 // PRUSA iteration3
   2 // Bushing/bearing housings
   3 // GNU GPL v3
   4 // Josef Průša <josefprusa@me.com>
   5 // Václav 'ax' Hůla <axtheb@gmail.com>
   6 // http://www.reprap.org/wiki/Prusa_Mendel
   7 // http://github.com/prusajr/PrusaMendel
   8
   9 include <configuration.scad>
  10
  11 // ensure that the part length is at least the length of bushing barrel plus add
  12 function adjust_bushing_len(conf_b, h, add=layer_height*2) = ((conf_b[2]+add) > h) ? conf_b[2]+add : h;
  13
  14 //distance from the flat side of bushing holder to rod center
  15 function bushing_foot_len(conf_b, h=10.5, add=4*single_wall_width) = ((conf_b[1]+add) > h) ? conf_b[1]+add : h;
  16
  17 function bushing_outer_radius(conf_b) = conf_b[1] + 4*single_wall_width;
  18
  19 // basic building blocks, housings for 1 bushing/bearing
  20 // at [0,0] there is center of the smooth rod, pointing in Z
  21
  22 module linear_bushing_negative_single(conf_b=bushing_xy, h=0){
  23     // barrel with the dimensions of a bushing/bearing
  24     // to be substracted as needed
  25     translate([0, 0, -0.01])  cylinder(r = conf_b[1], h = adjust_bushing_len(conf_b, h) + 0.02);
  26 }
  27
  28 module linear_bearing_negative_single(conf_b=bushing_xy, h=0){
  29     // as above but moved by 3 layers up
  30     translate([0, 0, -0.01+3*layer_height])  cylinder(r = conf_b[1], h = adjust_bushing_len(conf_b, h) + 0.02);
  31 }
  32
  33 module linear_bushing_single(conf_b=bushing_xy, h=0) {
  34     // This is the printed barrel around bushing
  35     // with foot pointing to -x
  36     translate([-bushing_foot_len(conf_b), -7, 0]) cube([bushing_foot_len(conf_b), 14, adjust_bushing_len(conf_b, h)]);
  37     cylinder(r=bushing_outer_radius(conf_b), h=adjust_bushing_len(conf_b, h));
  38 }
  39
  40 module linear_bushing_negative(conf_b=bushing_xy, h=0){
  41     // return simple negative stretched all along and a smooth rod
  42     translate([0,0,-0.1]) cylinder(r = conf_b[0] + single_wall_width, h=adjust_bushing_len(conf_b, h)+0.2);
  43     linear_bushing_negative_single(conf_b, h=adjust_bushing_len(conf_b, h));
  44 }
  45
  46 module linear_bearing_negative(conf_b = bushing_xy, h = 0){
  47     //same as linear_bushing_negative, but with z direction constrained parts
  48     translate([0,0,-0.1]) cylinder(r = conf_b[0] + single_wall_width, h=adjust_bushing_len(conf_b, h, 8*layer_height)+0.2);
  49     //lower bearing
  50     linear_bearing_negative_single(conf_b);
  51     if (h > 2*conf_b[2] + 9*layer_height){
  52         translate([0,0,h]) mirror([0,0,1]) linear_bearing_negative_single(conf_b);
  53     }
  54 }
  55
  56 module linear_negative_preclean(conf_b = bushing_xy) {
  57     // makes sure there is nothing interfering
  58     // to be substracted before linear()
  59     cylinder(r = conf_b[1] + single_wall_width, h=300, center=true);
  60 }
  61
  62 module linear_bushing_sloped(conf_b=bushing_xy, h= 100){
  63     // cut the bushing at angle, so it can be printed upside down
  64     intersection(){
  65         linear_bushing_single(conf_b, h = h);
  66         // hardcoded, may need fixing for different barelled bushings
  67         // atm there is only one and I am too lazy
  68         translate([0, 0, -2]) rotate([0,-50,0]) cube([30, 40, 80], center=true);
  69     }
  70 }
  71
  72 module linear_bushing(conf_b=bushing_xy, h=0){
  73     // this is the function to be used for type 1 linears (barrel holder)
  74     // It has bushing on bottom and for parts longer than 3x the barel length on top too
  75     difference() {
  76         union() {
  77             translate([-bushing_foot_len(conf_b), -7, 0]) cube([2, 14, adjust_bushing_len(conf_b, h)]);
  78             linear_bushing_single(conf_b);
  79             if (h>3*conf_b[2]) {
  80                 translate([0,0,h]) mirror([0,0,1]) linear_bushing_sloped(conf_b);
  81             }
  82         }
  83         linear_bushing_negative(conf_b, h);
  84     }
  85 }
  86
  87 module linear_bearing(conf_b=bushing_xy, h=0){
  88     difference() {
  89         union() {
  90             difference(){
  91                 union(){
  92                     //main block
  93                     //translate([-bushing_foot_len(conf_b), -7, 0]) cube([4, 14, adjust_bushing_len(conf_b, h, 9*layer_height)]);   <- removed for duplicity:)
  94                     translate([0,0,0]) cylinder(h = adjust_bushing_len(conf_b, h, 9*layer_height), r=bushing_outer_radius(conf_b), $fn=60);
  95                 }
  96                 //smooth entry cut
  97                 translate([12,0,-1]) rotate([0,0,45]) cube([20, 20, 200], center=true);
  98             }
  99             intersection(){
 100                 translate([0, -(bushing_outer_radius(conf_b)), 0]) cube([100, 2*bushing_outer_radius(conf_b) , 200]);
 101                 union() {
 102                     // upper clamp for long holders
 103                     if (h > 2*conf_b[2] + 9*layer_height || conf_b[2] > 45){
 104                         translate ([0,0, max(h, conf_b[2]) - 8 ]) bearing_clamp(conf_b, 2*(bushing_outer_radius(conf_b)));
 105                     }
 106                     //lower clamp
 107                     translate ([0, 0, 10]) bearing_clamp(conf_b, 2*(bushing_outer_radius(conf_b)));
 108                 }
 109             }
 110         }
 111         //main axis
 112         translate([0,0,-2]) cylinder(h = adjust_bushing_len(conf_b, h)+10, r=conf_b[1]);
 113         //main cut
 114         translate([0, -conf_b[1]+1, -1]) cube([30, 2*conf_b[1]-2, 200]);
 115     }
 116     difference() {
 117         translate([-bushing_foot_len(conf_b), -7, 0]) cube([4, 14, adjust_bushing_len(conf_b, h, 9*layer_height)]);
 118         linear_negative(conf_b, h);
 119     }
 120 }
 121
 122 // this should be more parametric
 123 module firm_foot(conf_b){
 124     difference(){
 125         union() {
 126             translate([8.5/2,0,0]) cube_fillet([8.5, 42 + xy_delta * 2, 20], top=[11, 0, 11, 0], center=true);
 127         }
 128         translate([9, 14.5 + xy_delta, 0]) rotate([0, -90, 0]) screw(head_drop=1);
 129         translate([9,-14.5 - xy_delta, 0]) rotate([0,-90,0]) screw(head_drop=1);
 130     }
 131 }
 132
 133 module y_bearing(conf_b=bushing_xy){
 134
 135     difference() {
 136         union() {
 137             difference() {
 138                 union() {
 139                     translate([-bushing_foot_len(conf_b), 0, 10]) firm_foot();
 140                     if (bushing_xy[2] > 45) {
 141                         translate([-bushing_foot_len(conf_b), 0, adjust_bushing_len(bushing_xy, 45) - 8]) mirror([0, 0, 1]) firm_foot();
 142                     }
 143                 }
 144                 linear_negative_preclean();
 145             }
 146             linear();
 147         }
 148         //linear_negative(bushing_xy, 20);
 149     }
 150 }
 151
 152 module bearing_clamp_brick(conf_b, h){
 153     translate([-(m4_nut_diameter/2+conf_b[1]), 0, 0])
 154         cube([m4_nut_diameter + 2 * conf_b[1], m4_nut_diameter + 1, h], center = true);
 155 }
 156
 157 module bearing_clamp(conf_b=bushing_xy, h=0){
 158     // inspired by John Ridley and Jonas Kühling
 159     rotate([90, 0, 0]) {
 160         difference(){
 161             union(){
 162                 translate([m3_diameter / 2 + conf_b[1] + 0.3, 0, 0])
 163                     cylinder(h=h, r = m4_nut_diameter / 2 + 0.5, center = true);
 164                 translate([m3_diameter / 2 + conf_b[1] + 0.3, 0, 0]) {
 165                     bearing_clamp_brick(conf_b, h);
 166                     rotate([0,0,35])
 167                         bearing_clamp_brick(conf_b, h);
 168                 }
 169             }
 170             translate([m3_diameter / 2 + conf_b[1] + 0.3, 0, 0]) {
 171                 cylinder(r=m3_diameter / 2, h=h+2, center=true);
 172                 %cylinder(r=m3_diameter / 2, h=h+2, center=true);
 173             }
 174         }
 175     }
 176 }
 177
 178
 179 module linear_negative(conf_b = bushing_xy, h = 0){
 180     //selects right negative based on type
 181     if (conf_b[3] == 0) {
 182         linear_bearing_negative(conf_b, h);
 183     } else {
 184         linear_bushing_negative(conf_b, h);
 185     }
 186 }
 187
 188 module linear(conf_b = bushing_xy, h = 0){
 189     //selects right negative based on type
 190     if (conf_b[3] == 0) {
 191         linear_bearing(conf_b, h);
 192     } else {
 193         linear_bushing(conf_b, h);
 194     }
 195     %linear_negative(conf_b, h);
 196 }
 197
 198 if (i_am_box == 1) {
 199     %cylinder(r=bushing_xy[0], h=90);
 200
 201     y_bearing();
 202     translate([0,52,0]) y_bearing();
 203
 204     if (bushing_xy[2] < 45) {
 205         translate ([-30,23,0]) mirror([1,0,0]) y_bearing();
 206     }
 207 } else {
 208     cube([0.1, 0.1, 0.1]);
 209 }