diff --git a/0.5cup_soap_cup.scad b/0.5cup_soap_cup.scad new file mode 100644 index 0000000..c295d98 --- /dev/null +++ b/0.5cup_soap_cup.scad @@ -0,0 +1,24 @@ +total_height = 220; +volume = 118; //mL +cup_height = 30; +wall_thickness = 3; + +// Calculate radius +inside_radius = sqrt(volume*1000/(PI*cup_height)); + +$fn=100; +// Generate cup +union(){ + translate([0,0,cup_height/2+wall_thickness/2]) + difference(){ + cylinder(r=inside_radius+wall_thickness, h=cup_height+wall_thickness, center=true); + + translate([0,0,wall_thickness]) + cylinder(r=inside_radius, h=cup_height+wall_thickness, center=true); + } + + translate([0,0,total_height/2]) + rotate_extrude(angle=30) + translate([wall_thickness/2+inside_radius,0,0]) + square(size=[wall_thickness, total_height], center=true); +} diff --git a/creality_big_spool_rod_assembly/spool_holder_axle.scad b/creality_big_spool_rod_assembly/spool_holder_axle.scad new file mode 100644 index 0000000..153a77b --- /dev/null +++ b/creality_big_spool_rod_assembly/spool_holder_axle.scad @@ -0,0 +1,287 @@ +/* Thanks to Dan Kirshner for the threads module: +* https://www.dkprojects.net/openscad-threads/ +* +* The design consists of 4 different parts when using bearings. +* When not using bearings, the only useful part is the main axle. +* The standard settings fit 608 ball bearings. +*/ + +// Choose between using bearings or just the axle + use_bearings = true; + +// Choose the part(s) to generate: + part_type = 6; // Main axle = 1, Bearing support rod = 2, clip = 3, + // washer = 4, all (for printing) = 5, assembly = 6 + +// Main axle sizes + main_cyl_diam = 32; // Diameter of middle part of the axle + thread_length = 10; // Thread length on each side of the axle + axle_main_part_length = 112; // Length of the middle part. + // (where the spool is resting) + main_axle_chamfer = 0.75; // How much chamfer to add to the main axle + + // Bearing sizes + bearing_outside_diam = 22; + bearing_inside_diam = 8; + bearing_width = 7; + bearing_dist = 70; // Distance between the centers of the two bearings + space = 2; // Extra space for the bearing holes + // Needs to be at least 2*washer_thickness for the washers to fit + // However, mounting without washers is also possible. + stick_out_dist = 1; // distance by which the bearing has to + // stick out of the axle + // (so that the filament spool touches the bearing, + // and not the axle) + +// Bearing support rod parameters + groove_width = 2; + groove_depth = 1; + end_stop_thickness = 2; + chamfer = 1; + cut_off_factor = 1/6; // How much to cut off from the rod + // (in order to print easily) + total_length = axle_main_part_length+2*thread_length + +end_stop_thickness + +2*groove_width + +chamfer; + groove_height = total_length-2*groove_width-chamfer; + +// Clip params + clip_inside_radius = bearing_inside_diam/2 - groove_depth; + clip_wall_width = 3; + clip_outside_radius = clip_inside_radius+clip_wall_width; + clip_thickness = groove_width-0.5; + clip_opening_width = clip_inside_radius*2 - 1.5; + +// Washer params + washer_thickness = 0.5; + washer_wall_width = 2; + washer_inside_space = 0.5; + +// ---------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- + +include +// metric_thread (diameter, pitch, length) washer_thickness = 0.5; + +$fn = 100; +small_dist = 0.01; + +// Calculate offset so that bearing stick out the desired distance +hole_center_dist = main_cyl_diam/2 - bearing_outside_diam/2 + stick_out_dist; + +module chamfered_threaded_part( length, + chamfer=1, + bottom_chamfer=false, + top_chamfer=false) +{ + diameter = 30; + difference(){ + metric_thread (diameter, 1.5, length); + if(bottom_chamfer){ + rotate_extrude() + translate([diameter/2,0,0]) + rotate([0,0,45]) + square(chamfer*2, center=true); + } + if(top_chamfer){ + rotate_extrude() + translate([diameter/2,length,0]) + rotate([0,0,45]) + square(chamfer*2, center=true); + } + } +} + +module chamfered_cylinder(length, radius, chamfer){ + difference(){ + cylinder(h=length,r=radius); + + rotate_extrude() + translate([radius,0,0]) + rotate([0,0,45]) + square(chamfer*2, center=true); + + rotate_extrude() + translate([radius,length,0]) + rotate([0,0,45]) + square(chamfer*2, center=true); + } +} + +module bearing_hole(bearing_diam, bearing_width, axle_diam, space){ + union(){ + cylinder(r=bearing_diam/2+space/2, h=bearing_width+space); + linear_extrude(height=bearing_width+space) + translate([-bearing_diam/2-space/2,0,0]) + square([bearing_diam+space, axle_diam]); + } +} + +module cylinder_part(length, diam, chamfer){ + // Chamfer edges + radius = diam/2; + chamfered_cylinder(length, radius, chamfer); +} + +module main_axle_part(){ +difference(){ + union(){ + translate([0,0,thread_length]){ + difference(){ + cylinder_part( axle_main_part_length, + main_cyl_diam, + main_axle_chamfer); + if(use_bearings){ + translate([0,0,axle_main_part_length/2+bearing_dist/2-(bearing_width+space)/2]) + bearing_hole( bearing_outside_diam, + bearing_width, + main_cyl_diam, + space); + translate( + [0,0,axle_main_part_length/2-bearing_dist/2-(bearing_width+space)/2] + ) + bearing_hole( bearing_outside_diam, + bearing_width, + main_cyl_diam, + space); + } + } + } + + chamfered_threaded_part(thread_length, bottom_chamfer=true); + translate([0,0,axle_main_part_length+thread_length]){ + chamfered_threaded_part(thread_length, top_chamfer=true); + } + } + + if(use_bearings){ + // Calculate offset so that bearing stick out the desired distance + hole_center_dist = main_cyl_diam/2 - bearing_outside_diam/2 + stick_out_dist; + translate([0,hole_center_dist,-small_dist]) + cylinder(r = bearing_inside_diam/2, + h=2*thread_length+axle_main_part_length+2*small_dist); + } +} +} + +module bearing_support_rod(){ + difference(){ + union(){ + linear_extrude(2) + circle(r=bearing_inside_diam); + difference(){ + chamfered_cylinder( total_length, + bearing_inside_diam/2, + chamfer); + translate([0,0,groove_height]) + linear_extrude(groove_width) + difference(){ + circle(r=bearing_inside_diam/2+small_dist); + circle(r=bearing_inside_diam/2-groove_depth); + } + } + } + + translate([ 0, + -(1.5*bearing_inside_diam+small_dist) + +cut_off_factor*bearing_inside_diam, + total_length/2]) + cube([ 2*(bearing_inside_diam+small_dist), + 2*(bearing_inside_diam+small_dist), + total_length+2*small_dist], + center=true); + } +} + +module clip(){ + linear_extrude(clip_thickness) + difference(){ + circle(r=clip_outside_radius); + circle(r=clip_inside_radius); + translate([0,clip_outside_radius/2+small_dist,0]) + square([clip_opening_width, clip_outside_radius],center=true); + } +} + +module washer(){ + linear_extrude(washer_thickness) + difference(){ + circle(r=bearing_inside_diam/2+washer_wall_width+washer_inside_space); + circle(r=bearing_inside_diam/2+washer_inside_space); + } +} + +if(part_type==1){ + main_axle_part(); +} +if(part_type==2){ + bearing_support_rod(); +} +if(part_type==3){ + clip(); +} +if(part_type==4){ + washer(); +} + +if(part_type==5){ + part_space = 5; + + main_axle_part(); + if(use_bearings){ + translate([-(main_cyl_diam/2+bearing_inside_diam+part_space), + total_length/2, + bearing_inside_diam/2-cut_off_factor*bearing_inside_diam]) + rotate(90,[1,0,0]) + bearing_support_rod(); + translate([0,-(main_cyl_diam/2+part_space+clip_outside_radius),0]) + clip(); + + y_dist = main_cyl_diam/2+part_space+2*washer_wall_width+bearing_inside_diam; + x_dist = 2*washer_wall_width+bearing_inside_diam + part_space; + translate([0,y_dist,0]) + washer(); + translate([x_dist,y_dist,0]) + washer(); + translate([0,y_dist+x_dist,0]) + washer(); + translate([x_dist,y_dist+x_dist,0]) + washer(); + } +} + +if(part_type==6){ + color("gray") + translate([0,0,end_stop_thickness]) + main_axle_part(); + if(use_bearings){ + translate([0,hole_center_dist,0]) + color("Blue") + bearing_support_rod(); + translate([0,hole_center_dist,groove_height]) + clip(); + + // Calculate washer positions from bottom to top + washer1 = end_stop_thickness+thread_length + +axle_main_part_length/2-bearing_dist/2-bearing_width/2 + -space/2; + washer2 = end_stop_thickness+thread_length + +axle_main_part_length/2-bearing_dist/2+bearing_width/2 + +space/2-washer_thickness; + washer3 = end_stop_thickness+thread_length + +axle_main_part_length/2+bearing_dist/2-bearing_width/2 + -space/2; + washer4 = end_stop_thickness+thread_length + +axle_main_part_length/2+bearing_dist/2+bearing_width/2 + +space/2-washer_thickness; + translate([0,hole_center_dist,washer1]) + washer(); + translate([0,hole_center_dist,washer2]) + washer(); + translate([0,hole_center_dist,washer3]) + washer(); + translate([0,hole_center_dist,washer4]) + washer(); + } +} \ No newline at end of file diff --git a/creality_big_spool_rod_assembly/threads.scad b/creality_big_spool_rod_assembly/threads.scad new file mode 100644 index 0000000..b2eee23 --- /dev/null +++ b/creality_big_spool_rod_assembly/threads.scad @@ -0,0 +1,407 @@ +/* + * ISO-standard metric threads, following this specification: + * http://en.wikipedia.org/wiki/ISO_metric_screw_thread + * + * Copyright 2020 Dan Kirshner - dan_kirshner@yahoo.com + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * See . + * + * Version 2.5. 2020-04-11 Leadin option works for internal threads. + * Version 2.4. 2019-07-14 Add test option - do not render threads. + * Version 2.3. 2017-08-31 Default for leadin: 0 (best for internal threads). + * Version 2.2. 2017-01-01 Correction for angle; leadfac option. (Thanks to + * Andrew Allen .) + * Version 2.1. 2016-12-04 Chamfer bottom end (low-z); leadin option. + * Version 2.0. 2016-11-05 Backwards compatibility (earlier OpenSCAD) fixes. + * Version 1.9. 2016-07-03 Option: tapered. + * Version 1.8. 2016-01-08 Option: (non-standard) angle. + * Version 1.7. 2015-11-28 Larger x-increment - for small-diameters. + * Version 1.6. 2015-09-01 Options: square threads, rectangular threads. + * Version 1.5. 2015-06-12 Options: thread_size, groove. + * Version 1.4. 2014-10-17 Use "faces" instead of "triangles" for polyhedron + * Version 1.3. 2013-12-01 Correct loop over turns -- don't have early cut-off + * Version 1.2. 2012-09-09 Use discrete polyhedra rather than linear_extrude () + * Version 1.1. 2012-09-07 Corrected to right-hand threads! + */ + +// Examples. +// +// Standard M8 x 1. +// metric_thread (diameter=8, pitch=1, length=4); + +// Square thread. +// metric_thread (diameter=8, pitch=1, length=4, square=true); + +// Non-standard: long pitch, same thread size. +//metric_thread (diameter=8, pitch=4, length=4, thread_size=1, groove=true); + +// Non-standard: 20 mm diameter, long pitch, square "trough" width 3 mm, +// depth 1 mm. +//metric_thread (diameter=20, pitch=8, length=16, square=true, thread_size=6, +// groove=true, rectangle=0.333); + +// English: 1/4 x 20. +//english_thread (diameter=1/4, threads_per_inch=20, length=1); + +// Tapered. Example -- pipe size 3/4" -- per: +// http://www.engineeringtoolbox.com/npt-national-pipe-taper-threads-d_750.html +// english_thread (diameter=1.05, threads_per_inch=14, length=3/4, taper=1/16); + +// Thread for mounting on Rohloff hub. +//difference () { +// cylinder (r=20, h=10, $fn=100); +// +// metric_thread (diameter=34, pitch=1, length=10, internal=true, n_starts=6); +//} + + +// ---------------------------------------------------------------------------- +function segments (diameter) = min (50, max (ceil (diameter*6), 25)); + + +// ---------------------------------------------------------------------------- +// diameter - outside diameter of threads in mm. Default: 8. +// pitch - thread axial "travel" per turn in mm. Default: 1. +// length - overall axial length of thread in mm. Default: 1. +// internal - true = clearances for internal thread (e.g., a nut). +// false = clearances for external thread (e.g., a bolt). +// (Internal threads should be "cut out" from a solid using +// difference ()). Default: false. +// n_starts - Number of thread starts (e.g., DNA, a "double helix," has +// n_starts=2). See wikipedia Screw_thread. Default: 1. +// thread_size - (non-standard) axial width of a single thread "V" - independent +// of pitch. Default: same as pitch. +// groove - (non-standard) true = subtract inverted "V" from cylinder +// (rather thanadd protruding "V" to cylinder). Default: false. +// square - true = square threads (per +// https://en.wikipedia.org/wiki/Square_thread_form). Default: +// false. +// rectangle - (non-standard) "Rectangular" thread - ratio depth/(axial) width +// Default: 0 (standard "v" thread). +// angle - (non-standard) angle (deg) of thread side from perpendicular to +// axis (default = standard = 30 degrees). +// taper - diameter change per length (National Pipe Thread/ANSI B1.20.1 +// is 1" diameter per 16" length). Taper decreases from 'diameter' +// as z increases. Default: 0 (no taper). +// leadin - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end; +// 2: chamfer at both ends, 3: chamfer at z=0 end. +// leadfac - scale of leadin chamfer length (default: 1.0 = 1/2 thread). +// test - true = do not render threads (just draw "blank" cylinder). +// Default: false (draw threads). +module metric_thread (diameter=8, pitch=1, length=1, internal=false, n_starts=1, + thread_size=-1, groove=false, square=false, rectangle=0, + angle=30, taper=0, leadin=0, leadfac=1.0, test=false) +{ + // thread_size: size of thread "V" different than travel per turn (pitch). + // Default: same as pitch. + local_thread_size = thread_size == -1 ? pitch : thread_size; + local_rectangle = rectangle ? rectangle : 1; + + n_segments = segments (diameter); + h = (test && ! internal) ? 0 : (square || rectangle) ? local_thread_size*local_rectangle/2 : local_thread_size / (2 * tan(angle)); + + h_fac1 = (square || rectangle) ? 0.90 : 0.625; + + // External thread includes additional relief. + h_fac2 = (square || rectangle) ? 0.95 : 5.3/8; + + tapered_diameter = diameter - length*taper; + + difference () { + union () { + if (! groove) { + if (! test) { + metric_thread_turns (diameter, pitch, length, internal, n_starts, + local_thread_size, groove, square, rectangle, angle, + taper); + } + } + + difference () { + + // Solid center, including Dmin truncation. + if (groove) { + cylinder (r1=diameter/2, r2=tapered_diameter/2, + h=length, $fn=n_segments); + } else if (internal) { + cylinder (r1=diameter/2 - h*h_fac1, r2=tapered_diameter/2 - h*h_fac1, + h=length, $fn=n_segments); + } else { + + // External thread. + cylinder (r1=diameter/2 - h*h_fac2, r2=tapered_diameter/2 - h*h_fac2, + h=length, $fn=n_segments); + } + + if (groove) { + if (! test) { + metric_thread_turns (diameter, pitch, length, internal, n_starts, + local_thread_size, groove, square, rectangle, + angle, taper); + } + } + } + + // Internal thread lead-in: take away from external solid. + if (internal) { + + // "Negative chamfer" z=0 end if leadin is 2 or 3. + if (leadin == 2 || leadin == 3) { + cylinder (r1=diameter/2, r2=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac, + $fn=n_segments); + } + + // "Negative chamfer" z-max end if leadin is 1 or 2. + if (leadin == 1 || leadin == 2) { + translate ([0, 0, length + 0.05 - h*h_fac1*leadfac]) { + cylinder (r1=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac, + r2=tapered_diameter/2, + $fn=n_segments); + } + } + } + } + + if (! internal) { + + // Chamfer z=0 end if leadin is 2 or 3. + if (leadin == 2 || leadin == 3) { + difference () { + cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments); + + cylinder (r2=diameter/2, r1=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac, + $fn=n_segments); + } + } + + // Chamfer z-max end if leadin is 1 or 2. + if (leadin == 1 || leadin == 2) { + translate ([0, 0, length + 0.05 - h*h_fac1*leadfac]) { + difference () { + cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments); + + cylinder (r1=tapered_diameter/2, r2=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac, + $fn=n_segments); + } + } + } + } + } +} + + +// ---------------------------------------------------------------------------- +// Input units in inches. +// Note: units of measure in drawing are mm! +module english_thread (diameter=0.25, threads_per_inch=20, length=1, + internal=false, n_starts=1, thread_size=-1, groove=false, + square=false, rectangle=0, angle=30, taper=0, leadin=0, + leadfac=1.0, test=false) +{ + // Convert to mm. + mm_diameter = diameter*25.4; + mm_pitch = (1.0/threads_per_inch)*25.4; + mm_length = length*25.4; + + echo (str ("mm_diameter: ", mm_diameter)); + echo (str ("mm_pitch: ", mm_pitch)); + echo (str ("mm_length: ", mm_length)); + metric_thread (mm_diameter, mm_pitch, mm_length, internal, n_starts, + thread_size, groove, square, rectangle, angle, taper, leadin, + leadfac, test); +} + +// ---------------------------------------------------------------------------- +module metric_thread_turns (diameter, pitch, length, internal, n_starts, + thread_size, groove, square, rectangle, angle, + taper) +{ + // Number of turns needed. + n_turns = floor (length/pitch); + + intersection () { + + // Start one below z = 0. Gives an extra turn at each end. + for (i=[-1*n_starts : n_turns+1]) { + translate ([0, 0, i*pitch]) { + metric_thread_turn (diameter, pitch, internal, n_starts, + thread_size, groove, square, rectangle, angle, + taper, i*pitch); + } + } + + // Cut to length. + translate ([0, 0, length/2]) { + cube ([diameter*3, diameter*3, length], center=true); + } + } +} + + +// ---------------------------------------------------------------------------- +module metric_thread_turn (diameter, pitch, internal, n_starts, thread_size, + groove, square, rectangle, angle, taper, z) +{ + n_segments = segments (diameter); + fraction_circle = 1.0/n_segments; + for (i=[0 : n_segments-1]) { + rotate ([0, 0, i*360*fraction_circle]) { + translate ([0, 0, i*n_starts*pitch*fraction_circle]) { + //current_diameter = diameter - taper*(z + i*n_starts*pitch*fraction_circle); + thread_polyhedron ((diameter - taper*(z + i*n_starts*pitch*fraction_circle))/2, + pitch, internal, n_starts, thread_size, groove, + square, rectangle, angle); + } + } + } +} + + +// ---------------------------------------------------------------------------- +module thread_polyhedron (radius, pitch, internal, n_starts, thread_size, + groove, square, rectangle, angle) +{ + n_segments = segments (radius*2); + fraction_circle = 1.0/n_segments; + + local_rectangle = rectangle ? rectangle : 1; + + h = (square || rectangle) ? thread_size*local_rectangle/2 : thread_size / (2 * tan(angle)); + outer_r = radius + (internal ? h/20 : 0); // Adds internal relief. + //echo (str ("outer_r: ", outer_r)); + + // A little extra on square thread -- make sure overlaps cylinder. + h_fac1 = (square || rectangle) ? 1.1 : 0.875; + inner_r = radius - h*h_fac1; // Does NOT do Dmin_truncation - do later with + // cylinder. + + translate_y = groove ? outer_r + inner_r : 0; + reflect_x = groove ? 1 : 0; + + // Make these just slightly bigger (keep in proportion) so polyhedra will + // overlap. + x_incr_outer = (! groove ? outer_r : inner_r) * fraction_circle * 2 * PI * 1.02; + x_incr_inner = (! groove ? inner_r : outer_r) * fraction_circle * 2 * PI * 1.02; + z_incr = n_starts * pitch * fraction_circle * 1.005; + + /* + (angles x0 and x3 inner are actually 60 deg) + + /\ (x2_inner, z2_inner) [2] + / \ + (x3_inner, z3_inner) / \ + [3] \ \ + |\ \ (x2_outer, z2_outer) [6] + | \ / + | \ /| + z |[7]\/ / (x1_outer, z1_outer) [5] + | | | / + | x | |/ + | / | / (x0_outer, z0_outer) [4] + | / | / (behind: (x1_inner, z1_inner) [1] + |/ | / + y________| |/ + (r) / (x0_inner, z0_inner) [0] + + */ + + x1_outer = outer_r * fraction_circle * 2 * PI; + + z0_outer = (outer_r - inner_r) * tan(angle); + //echo (str ("z0_outer: ", z0_outer)); + + //polygon ([[inner_r, 0], [outer_r, z0_outer], + // [outer_r, 0.5*pitch], [inner_r, 0.5*pitch]]); + z1_outer = z0_outer + z_incr; + + // Give internal square threads some clearance in the z direction, too. + bottom = internal ? 0.235 : 0.25; + top = internal ? 0.765 : 0.75; + + translate ([0, translate_y, 0]) { + mirror ([reflect_x, 0, 0]) { + + if (square || rectangle) { + + // Rule for face ordering: look at polyhedron from outside: points must + // be in clockwise order. + polyhedron ( + points = [ + [-x_incr_inner/2, -inner_r, bottom*thread_size], // [0] + [x_incr_inner/2, -inner_r, bottom*thread_size + z_incr], // [1] + [x_incr_inner/2, -inner_r, top*thread_size + z_incr], // [2] + [-x_incr_inner/2, -inner_r, top*thread_size], // [3] + + [-x_incr_outer/2, -outer_r, bottom*thread_size], // [4] + [x_incr_outer/2, -outer_r, bottom*thread_size + z_incr], // [5] + [x_incr_outer/2, -outer_r, top*thread_size + z_incr], // [6] + [-x_incr_outer/2, -outer_r, top*thread_size] // [7] + ], + + faces = [ + [0, 3, 7, 4], // This-side trapezoid + + [1, 5, 6, 2], // Back-side trapezoid + + [0, 1, 2, 3], // Inner rectangle + + [4, 7, 6, 5], // Outer rectangle + + // These are not planar, so do with separate triangles. + [7, 2, 6], // Upper rectangle, bottom + [7, 3, 2], // Upper rectangle, top + + [0, 5, 1], // Lower rectangle, bottom + [0, 4, 5] // Lower rectangle, top + ] + ); + } else { + + // Rule for face ordering: look at polyhedron from outside: points must + // be in clockwise order. + polyhedron ( + points = [ + [-x_incr_inner/2, -inner_r, 0], // [0] + [x_incr_inner/2, -inner_r, z_incr], // [1] + [x_incr_inner/2, -inner_r, thread_size + z_incr], // [2] + [-x_incr_inner/2, -inner_r, thread_size], // [3] + + [-x_incr_outer/2, -outer_r, z0_outer], // [4] + [x_incr_outer/2, -outer_r, z0_outer + z_incr], // [5] + [x_incr_outer/2, -outer_r, thread_size - z0_outer + z_incr], // [6] + [-x_incr_outer/2, -outer_r, thread_size - z0_outer] // [7] + ], + + faces = [ + [0, 3, 7, 4], // This-side trapezoid + + [1, 5, 6, 2], // Back-side trapezoid + + [0, 1, 2, 3], // Inner rectangle + + [4, 7, 6, 5], // Outer rectangle + + // These are not planar, so do with separate triangles. + [7, 2, 6], // Upper rectangle, bottom + [7, 3, 2], // Upper rectangle, top + + [0, 5, 1], // Lower rectangle, bottom + [0, 4, 5] // Lower rectangle, top + ] + ); + } + } + } +} + + + diff --git a/seedling_box.scad b/seedling_box.scad new file mode 100644 index 0000000..7f85247 --- /dev/null +++ b/seedling_box.scad @@ -0,0 +1,14 @@ +small_distance = 0.01; +width = 250; +height = 210; +wall_thickness = 0.8 + small_distance; +wall_height = 20; + +linear_extrude(wall_thickness) +square([width,height], center=true); + +linear_extrude(wall_height) +difference(){ + square([width,height], center=true); + square([width-2*wall_thickness,height-2*wall_thickness], center=true); +} \ No newline at end of file diff --git a/seedling_pot.scad b/seedling_pot.scad new file mode 100644 index 0000000..a6cd133 --- /dev/null +++ b/seedling_pot.scad @@ -0,0 +1,23 @@ +pot_diameter = 40; +pot_height = 50; +small_dist = 0.01; +wall_thickness = 0.8+small_dist; +number_of_holes = 6; + +$fn=100; + +linear_extrude(wall_thickness) +difference(){ + circle(r=pot_diameter/2); + for (i=[0:number_of_holes-1]) { + rotate((360/number_of_holes)*i,[0,0,1]) + translate([pot_diameter/4,0,0]) + circle(r=pot_diameter/15); + } + +} +linear_extrude(pot_height) +difference(){ + circle(r=pot_diameter/2); + circle(r=pot_diameter/2-wall_thickness); +} \ No newline at end of file