279 lines
8.4 KiB
OpenSCAD
Executable File
279 lines
8.4 KiB
OpenSCAD
Executable File
// dependency: https://github.com/revarbat/BOSL
|
|
use <BOSL/transforms.scad>
|
|
//use <BOSL/metric_screws.scad>
|
|
use <BOSL/masks.scad>
|
|
|
|
use <holodisk_spec.scad>
|
|
use <anim.scad>
|
|
|
|
include <tape.scad>
|
|
|
|
disk_size = get_holodisk_size();
|
|
holodisk_size = get_holodisk_size();
|
|
wall=3;
|
|
plate=3;
|
|
top_rim=2;
|
|
bolt_headtype="hex";
|
|
front_body_depth=12;
|
|
front_body_bolt_offset=8;
|
|
back_bumpers_radius=5;
|
|
back_bumpers_bolt_size=3;
|
|
tape_height=5;
|
|
tape_thickness=0.2;
|
|
spool_tape_tolerance=1;
|
|
spool_inner_height=tape_height+spool_tape_tolerance;
|
|
spool_inner_radius=4;
|
|
spool_outer_radius=18;
|
|
spool_plate_height=2;
|
|
spool_plate_holes=3;
|
|
spool_plate_hole_angle=360/spool_plate_holes * 0.5;
|
|
spool_plate_hole_inner_rim=1;
|
|
spool_plate_hole_outer_rim=4;
|
|
spool_slit_depth=0.8;
|
|
spool1_depth=disk_size.y*0.77;
|
|
spool2_depth=disk_size.y*0.40;
|
|
spool3_depth=(spool1_depth+spool2_depth)/2;
|
|
spool4_depth=disk_size.y*0.16;
|
|
main_spools_x=disk_size.x*0.45;
|
|
aux_spools_right_x=main_spools_x + spool_outer_radius + 1;
|
|
aux_spools_left_x=main_spools_x - 13;
|
|
middle_spool_in_r=2;
|
|
middle_spool_out_r=7;
|
|
aux_spool_plate_hole_inner_rim=2;
|
|
aux_spool_plate_hole_outer_rim=2;
|
|
spindle_diam=2;
|
|
spindle_diam_tolerance=0.2;
|
|
tape_z=plate+spool_plate_height;
|
|
|
|
module frame(size) {
|
|
width=size.x;
|
|
depth=size.y;
|
|
height=size.z;
|
|
|
|
tr=top_rim;
|
|
tc=tr*1.5;
|
|
fbd=front_body_depth;
|
|
bbr=back_bumpers_radius;
|
|
|
|
module back_bumpers() {
|
|
module bumper() { back_half() circle(r=bbr); }
|
|
back(depth) {
|
|
right(bbr) bumper();
|
|
right(width-bbr) bumper();
|
|
}
|
|
}
|
|
|
|
module bolt() { metric_bolt(size=back_bumpers_bolt_size, headtype=bolt_headtype, l=height, pitch=0); }
|
|
module nut() { metric_nut(size=back_bumpers_bolt_size, pitch=0); }
|
|
|
|
module back_bolts() {
|
|
back(depth) {
|
|
right(bbr) {
|
|
up(height) bolt();
|
|
nut();
|
|
}
|
|
right(width-bbr) {
|
|
up(height) bolt();
|
|
nut();
|
|
}
|
|
}
|
|
}
|
|
|
|
module front_bolts() {
|
|
bolt_offset=front_body_bolt_offset;
|
|
back(front_body_depth/2) {
|
|
right(bolt_offset) {
|
|
up(height) bolt();
|
|
nut();
|
|
}
|
|
right(width-bolt_offset) {
|
|
up(height) bolt();
|
|
nut();
|
|
}
|
|
}
|
|
}
|
|
|
|
module top_cover() {
|
|
up(height-plate) linear_extrude(height=plate) {
|
|
back_bumpers();
|
|
polygon(points=[
|
|
// frame
|
|
[0, 0], [0, depth],
|
|
[width, depth], [width, 0],
|
|
// window
|
|
[tr, tr+fbd], [tr, depth-tr-tc], [tr+tc, depth-tr],
|
|
[width-tr-tc, depth-tr], [width-tr, depth-tr-tc], [width-tr, tr+fbd]
|
|
],
|
|
paths=[
|
|
[0,1,2,3], [4,5,6,7,8,9]
|
|
]);
|
|
}
|
|
}
|
|
|
|
module walls() {
|
|
walls_height=height-plate*2;
|
|
up(plate) linear_extrude(height=walls_height) {
|
|
//back_bumpers();
|
|
shell2d(thickness=-wall) {
|
|
square([width, depth]);
|
|
}
|
|
}
|
|
}
|
|
|
|
module slides() {
|
|
slide_size = get_holodisk_slide_size();
|
|
slide_pos = get_holodisk_slide_pos();
|
|
slide_plate_size = [0.1, slide_size.y, slide_size.z];
|
|
sliding_size = get_holodisk_slide_sliding_size();
|
|
sliding_pos = get_holodisk_slide_sliding_pos();
|
|
|
|
module slide() {
|
|
hull() {
|
|
translate(sliding_pos) cube(sliding_size);
|
|
translate(slide_pos) cube(slide_plate_size);
|
|
}
|
|
}
|
|
|
|
module slider() {
|
|
slider_size = get_holodisk_slide_slider_size();
|
|
slider_pos = get_holodisk_slide_slider_pos();
|
|
slider_plate_size = [0.1, slider_size.y, slider_size.z];
|
|
slider_top_size = [slider_size.x, slider_size.y, sliding_size.z];
|
|
hull() {
|
|
up((slider_size.z-sliding_size.z)/2) translate(slider_pos) cube(slider_top_size);
|
|
translate(slider_pos) cube(slider_plate_size);
|
|
}
|
|
}
|
|
|
|
right(get_holodisk_size().x) {
|
|
slide();
|
|
slider();
|
|
}
|
|
scale([-1,1,1]) {
|
|
slide();
|
|
slider();
|
|
}
|
|
}
|
|
|
|
module bottom_cover() {
|
|
difference() {
|
|
linear_extrude(height=plate) {
|
|
back_bumpers();
|
|
square([width, depth]);
|
|
}
|
|
down(0.1) translate(get_holodisk_laser_cutout_pos()) cube(get_holodisk_laser_cutout_size());
|
|
}
|
|
}
|
|
|
|
color("SaddleBrown") top_cover();
|
|
color("grey") walls();
|
|
color("Silver") slides();
|
|
color("SaddleBrown") bottom_cover();
|
|
//color("silver") back_bolts();
|
|
//color("silver") front_bolts();
|
|
}
|
|
|
|
module mechanism(size) {
|
|
width=size.x;
|
|
depth=size.y;
|
|
height=size.z;
|
|
|
|
module spool(r_in, r_out, in_rim, out_rim) {
|
|
module spindle(d, h) {
|
|
color("Sienna") cylinder(h=h, d=d);
|
|
}
|
|
|
|
module spool_plate() {
|
|
difference() {
|
|
cylinder(h=spool_plate_height, r=r_out);
|
|
if (!$preview && r_out - r_in > out_rim) {
|
|
angle=spool_plate_hole_angle;
|
|
difference() {
|
|
for (i = [1:spool_plate_holes]) {
|
|
zrot(360/spool_plate_holes * i) {
|
|
angle_pie_mask(r=r_out - out_rim, l=spool_plate_height, ang=angle, center=false);
|
|
}
|
|
}
|
|
cylinder(h=spool_plate_height, r=r_in + in_rim);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
spindle_h=height-plate;
|
|
difference() {
|
|
color("Azure") {
|
|
spool_plate();
|
|
up(spool_plate_height) cylinder(h=spool_inner_height, r=r_in);
|
|
up(spool_plate_height + spool_inner_height) spool_plate();
|
|
}
|
|
up(spool_plate_height + spool_inner_height/2) cube([r_in*2, spool_slit_depth, spool_inner_height], center=true);
|
|
// TODO: spindle height
|
|
spindle(d=spindle_diam+spindle_diam_tolerance, h=spindle_h);
|
|
}
|
|
spindle(d=spindle_diam, h=spindle_h);
|
|
}
|
|
|
|
module main_spool() {
|
|
spool(r_in=spool_inner_radius,
|
|
r_out=spool_outer_radius,
|
|
in_rim=spool_plate_hole_inner_rim,
|
|
out_rim=spool_plate_hole_outer_rim);
|
|
}
|
|
module aux_spool() {
|
|
spool(r_in=middle_spool_in_r, r_out=middle_spool_out_r,
|
|
in_rim=aux_spool_plate_hole_inner_rim,
|
|
out_rim=aux_spool_plate_hole_outer_rim);
|
|
}
|
|
|
|
module spools() {
|
|
up(plate) {
|
|
right(main_spools_x) {
|
|
back(spool1_depth) main_spool();
|
|
back(spool2_depth) main_spool();
|
|
}
|
|
right(aux_spools_right_x) {
|
|
back(spool3_depth) aux_spool();
|
|
back(spool4_depth) aux_spool();
|
|
}
|
|
right(aux_spools_left_x) {
|
|
back(spool4_depth) aux_spool();
|
|
}
|
|
}
|
|
}
|
|
|
|
module tapes() {
|
|
spool1_tape_r = spool_outer_radius * 0.8;
|
|
spool2_tape_r = spool_outer_radius * 0.5;
|
|
up(plate + spool_plate_height) {
|
|
// main spools
|
|
right(main_spools_x) {
|
|
back(spool1_depth) tape_spool(r_in=spool_inner_radius, r_out=spool1_tape_r);
|
|
back(spool2_depth) tape_spool(r_in=spool_inner_radius, r_out=spool2_tape_r);
|
|
}
|
|
// TODO: convert to path
|
|
// main 1 --> middle
|
|
tape([main_spools_x + spool1_tape_r, spool1_depth, 0], [aux_spools_right_x + middle_spool_in_r, spool3_depth, 0]);
|
|
// --> right corner
|
|
right(aux_spools_right_x + middle_spool_in_r) tape([0, spool3_depth, 0], [0, spool4_depth, 0]);
|
|
// --> left corner
|
|
tape([aux_spools_left_x, spool4_depth - middle_spool_in_r, 0], [aux_spools_right_x, spool4_depth - middle_spool_in_r, 0]);
|
|
// --> main 2
|
|
tape([aux_spools_left_x - middle_spool_in_r, spool4_depth, 0], [main_spools_x - spool2_tape_r, spool2_depth, 0]);
|
|
}
|
|
}
|
|
|
|
spools();
|
|
tapes();
|
|
}
|
|
|
|
module holodisk(size) {
|
|
frame(size);
|
|
mechanism(size);
|
|
}
|
|
|
|
retraction=holodisk_size.y+10;
|
|
back((1-anim(1, 2)) * retraction) // anim insert
|
|
back((anim(len(get_anim_keys())-2, len(get_anim_keys())-1)) * retraction) // anim remove
|
|
holodisk(holodisk_size);
|