SpHEAR/SpHEAR_common.scad

//
// Spherical Harmonics Ear Project (*SpHEAR)
//
// Common Modules and Variables
//
// Copyright 2015-2016, Fernando Lopez-Lezcano, All Rights Reserved
// nando@ccrma.stanford.edu
//
//  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.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// 3d Models released under the Creative Commons license as follows:
//   Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)
// http://creativecommons.org/licenses/by-nc-sa/4.0/

////
//// default model parameters
////

// microphone capsule array
//
// dimensions of the electret microphone capsule
capsule_radius = 5;
capsule_height = 4.5;

// distance between the face of a capsule and the center of array
mic_radius = 9.6;

// dimensions of the capsule holder connection legs
// a width of 4mm is too thin, 5mm prints better
leg_width = 5;
leg_thick = 1.75;

// wall thickness of the capsule holder
wall = 1;

// width of the ridge that connects to the mount
ridge_width = 2.0;
ridge_slot_width = 2.0;
// depth of the connector mount ridge
ridge_depth = 3.0;
// add to the thickness of ridges
ridge_wfit = 0.1;
ridge_hfit = 3;

// microphone mount
//
mount_radius = 3.5;
mount_wall = 0.75;

// height and eccentricity of top connector
mount_top_height = 10.0;
mount_top_eccentricity = 1.3;

// height of mount
mount_height = 40;

// microphone stand mount
//
// diameter of existing shielded wires (x 4)
mic_wire_diam = 1.5;
mic_wire_hole_radius = 3.0;
mic_wire_hole_offset = 5;

// standard microphone stand
// measured diameter = 13.5, inside diameter of sleeve = 13.79 (
mic_mount_radius = 13.50 / 2;
// add this to inside diameter
mic_mount_fit = 0.2;
mic_mount_slot_height = 11.5;
mic_mount_slot_width = 4.25;
mic_mount_slot_radius = 6.25  / 2;
mic_mount_wall = 1.5;
mic_mount_height = 35.0 + mic_wire_hole_offset + mic_wire_hole_radius + 2 * mic_mount_wall;

//// end of model parameters
////
//// rendering control

// what type of connection to use between capsule holders:
// 0 -> original cylindrical angled legs
// 1 -> interlocking horizontal legs
// 2 -> interlocking vertical legs
connect = 1;

// how many mount ridges to create
// 0 -> no ridges
// 1 -> 1 ridge
// 2 -> 2 ridges
ridges = 1;

//// end of rendering control
////

// adjustment for the inner radius of the capsule holder
//   measured inside diameter of a trial print was around 7.5 to 8.2 
//   instead of 10, capsule diameter was 9.99)
// 0.1 -> 0.08: Ultimaker 2 + Extended plus APL (2016.06.17)
fudge = 0.08;

// adjustment for fit of slots in connection legs and mount
// 0.1: initial setting
// 0.1 ->0.15: Ultimaker 2 + Extended plus APL (2016.06.17)
fit = 0.15;

// number of facets for rendering cylinders
facets = 64;
// render capsule holders with better resolution
cfacets = 128;

////////
// microphone capsule holder

// mounts: vectors containing the angle of the mount and the angle to the adjacent capsule
// twist: rotate the whole capsule to match mounting legs
// ridge: add 0, 1 or 2 ridges for attaching the structure to the mount
// ridge_wfit: tune the fit, used for carving slots in mount
// ridge_hfit: adjust height of ridges when carving out the capsule rests
// solid: make the capsule holder solid, used in the mount code to carve the capsule rests

module capsule (mounts, twist, ridge, ridge_wfit = 0.0, ridge_hfit = 0.0, solid = 0) {
    difference () {
        union () {
            // main capsule holder
            cylinder(r = capsule_radius + wall, h = capsule_height, $fn = cfacets);
            // the mounting legs
            for (angles = mounts) {
                rotate([0, 0, angles[0] + twist]) {
                    // connect with cylindrical beams, very pretty
                    if (connect == 0) {
                        leg_length = mic_radius * cos(angles[1]) - capsule_radius * sin(angles[1]);
                        translate([capsule_radius - wall, 0, capsule_height - wall]) {
                            rotate([0, 180 - angles[1], 0]) {
                                cylinder(d = leg_width, h = leg_length - 0.3, center = false, $fn = facets);
                            }
                        }
                    }
                    // connect with horizontal legs
                    if (connect == 1) {
                        leg_length = (mic_radius - capsule_height + leg_thick) * tan(90 - angles[1]);
                        slot_depth = leg_thick / cos(90 - 2 * angles[1]);
                        slot_xtra_depth = (angles[1] < 45) ? (leg_thick * tan(90 - 2 * angles[1])) : 0.0;
                        translate([0, - leg_width / 3, 0]) {
                            difference() {
                                cube([leg_length, leg_width, leg_thick]);
                                // cut slot in connector
                                translate([leg_length - slot_depth - slot_xtra_depth - fit, leg_width / 3 - (fit / 2), 0]) {
                                    cube([slot_depth + slot_xtra_depth + fit, leg_width / 3 + fit, leg_thick]);
                                }
                            }
                        }
                    }
                    // connect with vertical legs
                    if (connect == 2) {
                        // fix this 0.2 == (2 * fudge?)
                        leg_length = (mic_radius * tan(90 - angles[1]) - capsule_radius) * tan(angles[1]) - 0.2;
                        slot_depth = leg_thick * cos (90 - (2 * angles[1]));
                        translate([capsule_radius - leg_thick / 2 + fudge, - leg_width / 3,
                                   - leg_length + capsule_height]) {
                            difference() {
                                // the connection
                                difference() {
                                    cube([leg_thick + leg_thick / 2, leg_width, leg_length]);
                                    translate([-leg_thick + wall - fudge, 0, - capsule_height + fudge]) {
                                        cube([leg_thick, leg_width, leg_length]);
                                    }
                                }
                                // cut slot in connector
                                translate([0, leg_width / 3 - (fit / 2), 0]) {
                                    cube([leg_thick + leg_thick / 2, leg_width / 3 + fit, slot_depth]);
                                }
                            }
                        }
                    }
                }
            }
            // add ridges for microphone mount
            ridge_length = (mic_radius - capsule_height) / tan(elev_angle) - (capsule_radius + wall);
            if (ridge == 2) {
                rotate([0, 0, twist]) {
                    translate([capsule_radius + wall - ridge_length / 2, (ridge_width + ridge_wfit) / 2, 0]) {
                        cube([ridge_length * 3 / 2, ridge_width + ridge_wfit, capsule_height + ridge_hfit], center = false);
                    }
                    translate([capsule_radius + wall - ridge_length / 2, - (ridge_width + ridge_wfit) * 3 / 2, 0]) {
                        cube([ridge_length * 3 / 2, ridge_width + ridge_wfit, capsule_height + ridge_hfit], center = false);
                    }
                }
            }
            if (ridge == 1) {
                rotate([0, 0, twist]) {
                    difference() {
                        translate([capsule_radius + wall / 2, - (ridge_width + ridge_wfit) / 2, 0]) {
                            cube([ridge_depth + wall / 2, ridge_width + ridge_wfit, capsule_height + ridge_hfit], center = false);
                        }
                        translate([capsule_radius + wall + ridge_length, - (ridge_width + ridge_wfit) / 2, 0]) {
                            rotate([0, elev_angle, 0]) {
                                cube([ridge_depth, ridge_width + ridge_wfit, capsule_height * 2], center = false);
                            }
                        }
                    }
                }
            }
        }
        // make the hole for the capsule (also cuts leg overhang for vertical connectors)
        if (solid != 1) {
            translate ([0, 0, -capsule_height]) {
                cylinder(r = capsule_radius + fudge, h = capsule_height * 2, $fn = cfacets);
            }
        }
        // remove any extra connecting beam material from the face of the holder
        if (connect == 0) {
            translate ([0, 0, capsule_height]) {
                cylinder(r = capsule_radius + wall * 2, h = 2, $fn = cfacets);
            }
        }
    }
}

//// shared modules for zapnspark printed circuit board

// one printed circuit board

module pcb(length, width, thick) {
    translate([-width/2, 0, 0]) {
        cube([width, thick, length]);
    }
}

// one printed circuit board with space in the front and back for components

module pcb_clear(length, width, thick, slot_depth, front, back) {
    translate([0, - (thick + front)]) {
        pcb(length, width, thick);
        // clear space in the front
        translate([- (width/2 - slot_depth), thick, 0]) {
            cube([width - 2 * slot_depth, front, length]);
        }
        // clear space in the back
        translate([- (width/2 - slot_depth), - back, 0]) {
            cube([width - 2 * slot_depth, back, length]);
        }
    }
}

//// shared modules for mount

// rectangular block with rounded corners

module rounded_block(height, width, depth, radius) {
    dw = width - radius;
    dd = depth - radius;
    minkowski() {
        translate([-dw, -dd, 0]) {
            cube([dw * 2, dd * 2, height / 2]);
        }
        cylinder(r = radius, h = height / 2, $fn = facets);
    }
}

// rectangular inset block with rounded corners

module rounded_block_relative(height, ref_width, ref_depth, ref_corner, radius_inc) {
    corner = ref_corner * ((ref_width + radius_inc) / ref_width);
    rounded_block(height, ref_width + radius_inc, ref_depth + radius_inc, corner);
}

// box with rounded corners

module rounded_box(height, width, depth, radius, wall) {
    iradius = radius * ((width - wall) / width);
    difference() {
        rounded_block(height, width, depth, radius);
        rounded_block(height, width - wall, depth - wall, iradius);
    }
}

//// shared modules for shock mount

// internal ring of shock mount

module shock_mount_internal_ring(height, xradius, yradius, corner, gap, lip) {
    slot_sep = xradius * 2 / 2.5;
    slot_w = 5;
    slot_o = height / 3;
    difference() {
        union() {
            // base ring
            difference() {
                rounded_block_relative(slot_o, xradius + gap, yradius + gap, corner, 3 * wall);
                rounded_block(slot_o, xradius + gap, yradius + gap, corner);
            }
            // upper ring with slots for rubber bands
            difference() {
                rounded_block_relative(height, xradius + gap + 2 * wall, yradius + gap + 2 * wall, corner, 2 * wall);
                rounded_block_relative(height, xradius + gap + wall, yradius + gap + wall, corner, 1 * wall);
                for (rot = [0, 90, 180, 270]) rotate([0, 0, rot]) {
                    // slots for rubber bands
                    minkr = 1.25;
                    for (m = [0, 1]) mirror([0, m, 0]) {
                        translate([-slot_w / 2 + slot_sep, ((rot % 180) ? xradius : yradius) + gap, slot_o + minkr]) {
                            minkowski() {
                                cube([slot_w - minkr, 10, slot_o - minkr]);
                                rotate([90, 0, 0]) cylinder(r = minkr, h = 1, $fn = facets);
                            }
                            translate([slot_w / 2, -2, 0]) {
                                cube([slot_w / 2, 10, 10]);
                            }
                        }
                    }
                }
            }
            // body for bars that connect both rings together
            for (rot = [0, 90, 180, 270]) rotate([0, 0, rot]) {
                translate([((rot % 180) ? yradius : xradius) + gap + 3 * wall, -(connector_w/2 + wall), 0]) {
                    cube([connector_d + wall, connector_w + 2 * wall, height]);
                }
                for (m = [0, 1]) mirror([0, m, 0]) {
                    translate([((rot % 180) ? yradius : xradius) + gap + 4 * wall, -(connector_w/2 + wall), 0]) {
                        cylinder(r = wall * 2, h = height, $fn = 3);
                    }
                }
            }
        }
        // carve holes for bars that connect both rings
        for (rot = [0, 90, 180, 270]) rotate([0, 0, rot]) {
            translate([((rot % 180) ? yradius : xradius) + gap + 3 * wall, -connector_w/2, 0]) {
                cube([connector_d, connector_w, height - 2.75 * wall]);
                translate([connector_d / 2, 0, height - 3 * wall]) {
                    rotate([-90, 0, 0]) {
                        cylinder(r = connector_d / 2, h = connector_w, $fn = facets);
                    }
                }
            }
        }
    }
    for (rot = [0, 90, 180, 270]) rotate([0, 0, rot]) {
        // lip to support microphone on lower ring only
        if (lip == 1) {
            lip_w = 10;
            translate([((rot % 180) ? yradius : xradius) + gap + 2.5 * wall, -lip_w/2, height]) {
                rotate([90, 90, 180]) {
                    linear_extrude(height = lip_w) {
                        polygon([[0, 0], [0, 4], [1, 4], [height * 2/3, 0]]);
                    }
                }
            }
        }
    }    
}

// external ring of shock mount (connects to stand mount)

module shock_mount_external_ring(height, xradius, yradius, corner, gap, lip) {
    difference() {
        rounded_block_relative(ring_ext_height, xradius, yradius, mount_corner, gap);
        rounded_block_relative(ring_ext_height, xradius, yradius, mount_corner, gap - ring_wall);
    }
    for (rot = [0, 90, 180, 270]) {
        rotate([0, 0, rot]) {
            translate([((rot % 180) ? yradius : xradius) + gap + ring_wall, -7.5, 0]) {
                cube([4, 15, ring_ext_height]);
            }
            translate([((rot % 180) ? yradius : xradius) + gap, -2, 0]) {
                cube([7, 4, ring_ext_height]);
            }
        }
    }
    // connection to stand mount
    ring_arm_gap = 20;
    intersection() {
        translate([ring_arm_gap, 0, 0]) {
            difference() {
                rounded_block_relative(ring_ext_height, xradius, yradius, mount_corner, gap);
                rounded_block_relative(ring_ext_height, xradius, yradius, mount_corner, gap - ring_wall);
            }
        }
        translate([ring_arm_gap / 2, -(yradius + 2 * mount_corner), 0]) {
            cube([(xradius + 2 * mount_corner) + ring_arm_gap, 2 * (yradius + 2 * mount_corner), ring_ext_height]);
        }
    }
    // connection to hub
    translate([xradius + mount_corner + ring_wall + ring_arm_gap, -2, 0]) {
        cube([8, 4, ring_ext_height]);
    }
    // rotating mount
    o_rad = 8;
    i_rad = 3;
    rotate([0, 90, -90]) {
        translate([-o_rad, xradius + mount_corner + ring_wall + ring_arm_gap + o_rad + ring_wall / 2 + 4, -2]) {
            tetra_shock_mount_ring(o_rad, i_rad, ring_wall);
        }
    }
}