Bart/OpenScad_Designs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

more designs

Browse Source
This commit is contained in:
Bart Moyaers
2020-05-09 23:49:18 +02:00
parent cdf3c3138a
commit 7640be3fad
5 changed files with 755 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
0.5cup_soap_cup.scad Normal file
View File

@@ -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);
}

287
creality_big_spool_rod_assembly/spool_holder_axle.scad Normal file
View File

@@ -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 <threads.scad>
// 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();
}
}

407
creality_big_spool_rod_assembly/threads.scad Normal file
View File

@@ -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 <http://www.gnu.org/licenses/>.
*
* 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 <a2intl@gmail.com>.)
* 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
]
);
}
}
}
}

14
seedling_box.scad Normal file
View File

@@ -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);
}

23
seedling_pot.scad Normal file
View File

@@ -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);
}