Holodisk/holodisk.scad

// 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;
    
    walls_height=height-plate*2;
    
    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() {
        difference() {
            up(plate) linear_extrude(height=walls_height) {
                //back_bumpers();
                shell2d(thickness=-wall) {
                    square([width, depth]);
                }
            }
            translate(get_holodisk_laserwindow_pos_center()) cube(get_holodisk_laserwindow_size(), center=true);
        }
    }
    
    module front_plates() {
        th = get_holodisk_front_plate_thickness();
        slide_pos = get_holodisk_slide_pos();
        offset=4.5;
        plate_len_side=slide_pos.y - offset/2;
        plate_len_left=plate_len_side/2;
        plate_len_right=plate_len_side + 5;
        // front
        fwd(th) left(th) up(offset) {
            cube([plate_len_left + th*2, th, height - offset*2]);
        }
        fwd(th) right(width-plate_len_right-th) up(offset) {
            cube([plate_len_right + th*2, th, height - offset*2]);
        }
        // left
        fwd(th) left(th) up(offset) {
            cube([th, plate_len_side, height - offset*2]);
        }
        // right
        fwd(th) right(width) up(offset) {
            cube([th, plate_len_side, height - offset*2]);
        }
    }
    
    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();
        }
        
        right(get_holodisk_laserwindow_pos_center().x) zrot(-90) {
           scale([1, 0.7, 1]) {
              slider();
           }
        }
    }
    
    module laserwindow_door() {
        door_size = [
            get_holodisk_laserwindow_size().x,
            1,
            get_holodisk_laserwindow_size().z
        ];
        door_pos = [
            get_holodisk_laserwindow_pos_center().x,
            get_holodisk_laserwindow_pos_center().y + door_size.y/2,
            get_holodisk_laserwindow_pos_center().z
        ];
        
        translate(door_pos) scale(0.98) down(door_size.z/2) xrot(anim(1,2)*-90) xrot(anim(6,7)*90) up(door_size.z/2) cube(door_size, center=true);
    }
    
    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());
        }
    }
    
    {
        overlap=1;
        rails_size = [
            get_holodisk_laserwindow_size().x * 2 + overlap*2,
            1,
            walls_height
        ];
        rail_size = [rails_size.x, rails_size.y, 2];
        rails_pos = [get_holodisk_laserwindow_pos().x - rails_size.x/2,
            -rails_size.y, plate];
        rail1_pos = [rails_pos.x, rails_pos.y, rails_pos.z];
        rail2_pos = [rails_pos.x, rails_pos.y, rails_pos.z + rails_size.z - rail_size.z];
        
        module laserwindow_slider_rails() {
            translate(rail1_pos) cube(rail_size);
            translate(rail2_pos) cube(rail_size);
        }
    
        module laserwindow_slider_cover() {
            cover_size=[
                get_holodisk_laserwindow_size().x,
                rails_size.y + overlap*2,
                get_holodisk_slide_slider_size().z
            ];
            cover_plate=[cover_size.x, rail_size.y, cover_size.z];
            cover_top=[cover_size.x - overlap, cover_size.y, cover_size.z - overlap];
            /*cover_pos=[rails_pos.x+overlap, rails_pos.y + rails_size.y, rails_pos.z];*/
            cover_pos=[get_holodisk_laserwindow_pos().x, rails_pos.y + rails_size.y, rails_pos.z];
            left(anim(0,1)*get_holodisk_laserwindow_size().x)
            right(anim(len(get_anim_keys())-2,len(get_anim_keys())-1)*get_holodisk_laserwindow_size().x)
            translate(cover_pos)
            hull() {
                fwd(cover_plate.y) cube(cover_plate);
                fwd(cover_top.y) up((cover_plate.z-cover_top.z)/2) cube(cover_top);
            }
        }
        
        color("red") laserwindow_slider_rails();
        color("red") laserwindow_slider_cover();
    }
    
    color("SaddleBrown") top_cover();
    color("grey") walls();
    color("gold") laserwindow_door();
    color("Silver") slides();
    color("SaddleBrown") bottom_cover();
    color("SaddleBrown") front_plates();
    //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);