SpHEAR/first_order.scad

//
// TinySphEAR, Tiny Spherical Ear, First Order (B-format) Ambisonics Microphone
//
// Copyright 2015, 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/


// https://en.wikipedia.org/wiki/Tetrahedron
// angle of capsule to vertical axis = atan(sqrt(2)) = 54.7356103172

////
//// model parameters

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

// distance between face of capsule and center of array
mic_radius = 10;

// dimensions of capsule holder connection legs
leg_width = 4;
leg_thick = 2.5;

// width of the ridge that connects to the mount
ridge_width = 2;
ridge_length = 2.5;

// wall thickness of capsule holder
wall = 1;

// dimensions of microphone holder
mount_radius = 3.5;

// height of mount
mount_height = 4;

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

// what to render:
// 0 -> ready to print
//   set = 0 -> one capsule, set = 1 -> four capsules
// 1 -> the whole microhone with four capsules
rendermic = 0;
renderset = 1;

// what type of connection to use between capsule holders:
// 0 -> original cylinder beams
// 1 -> interlocking beams (out)
// 2 -> interlocking beams (in)
connect = 2;

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

// elevation angle for the capsule holders (fixed for this microphone)
elev_angle = atan(sqrt(1/2));

// angles of the connection legs and adjacent capsule holders
leg_angles_top = 
    [
        [-120, elev_angle], 
        [0, elev_angle],
        [120, elev_angle]
    ];

leg_angles_bot = 
    [
        [-120, elev_angle], 
        [120, elev_angle]
    ];

// adjustment for the radius of the capsule
//   measured inside diameter of a trial print was around 7.5 to 8.2 
//   instead of 10, capsule diameter was 9.99)
fudge = 0.15;

// adjustment for fit of slots in connection legs and mount
fit = 0.2;

// number of facets for rendering cylinders
facets = 64;

// microphone holder geometry
capsule_sep_min = (mic_radius - capsule_height) * cos(elev_angle) - (capsule_radius + wall) * sin(elev_angle);
capsule_sep_max = mic_radius * cos(elev_angle) - (capsule_radius + wall) * sin(elev_angle);
capsule_bottom = mic_radius * sin(elev_angle) + (capsule_radius + wall) * cos(elev_angle);
mount_slot_depth = ridge_length * sin(elev_angle);

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

// azimuth: horizontal orientation of the capsule
// elevation: vertical orientation of the capsure
// 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: 1 -> print ridge for mount

module capsule (azimuth, elevation, mounts, twist, ridge) {
	rotate([0, 0, azimuth]) {
		rotate([0, (90 - elevation), 0]) {
  			translate([0, 0, rendermic == 0 ? 0 : mic_radius - capsule_height]) {
				difference () {
					union () {
						// main capsule holder
						cylinder(r = capsule_radius + wall, h = capsule_height, $fn = facets);	
						// 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]) - capsule_radius;
                                    slot_depth = leg_thick * cos(90 - 2 * angles[1]) + wall + fit;
									translate([capsule_radius + leg_length + fudge, - leg_width / 3, 0]) {
										rotate([0, -90, 0]) {
											difference() {
												// thickness, width
												cube([leg_thick, leg_width, leg_length]);
												// cut slot in connector
												translate([0, leg_width / 3 - (fit / 2), 0]) {
													cube([leg_thick, leg_width / 3 + fit, slot_depth]);
												}
											}
										}
									}
								}
								// 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 + fudge, - leg_width / 3, - leg_length + capsule_height]) {
										difference() {
											// thickness, width
                                            //minkowski() {
                                                cube([leg_thick, leg_width, leg_length]);
                                                //cylinder(r = wall / 2, h = leg_length / 4, center = false, $fn = 32);
                                            //}
											// cut slot in connector
											translate([0, leg_width / 3 - (fit / 2), 0]) {
												cube([leg_thick, leg_width / 3 + fit, slot_depth]);
											}
										}
									}
								}
							}
						}
						// add ridges for microphone mount
						if (ridge == 1) {
							rotate([0, 0, twist]) {
								translate([capsule_radius + fudge, - 1.5 * ridge_width , 0]) {
                                    cube([ridge_length, ridge_width, capsule_height], center = false);
								}
								translate([capsule_radius + fudge, 0.5 * ridge_width , 0]) {
                                    cube([ridge_length, ridge_width, capsule_height], center = false);
								}
							}
						}
					}
					// make the hole for the capsule
					translate ([0, 0, -2]) {
						cylinder(r = capsule_radius + fudge, h = capsule_height + 2, $fn = facets);
					}
					// 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 = facets);
						}
					}
				}
			}
		}
	}
}

// microphone mount
//
// angles: angles for mount slots
// wall: thickness of cylinder wall
// separation: height of mount with respect of the microphone assembly

module mount (angles, wall, separation) {
	translate([0, 0, -(separation + 0.1)]) {
		difference() {
			union() {
				// grips for the capsule holder ridge
//				for (rot = angles) {
//					rotate([0, 0, rot]) {
//						translate([-capsule_sep_max, -(ridge_width - fit / 2), -mount_height]) {
//							cube([capsule_sep_max, ridge_width * 2 - fit, mount_height]);
//                            rotate([0, -elev_angle, 0]) {
//                                cube([capsule_sep_max, ridge_width * 2 - fit, mount_height * cos(elev_angle)]);
//                            }
//						}
//					}
//				}
				translate([0, 0, -mount_height]) {
					cylinder(r = mount_radius + wall, h = mount_height, $fn = facets);
				}
			}
			// make the hole for the mount (* 1.5 to cut the ridge as well)
			translate([0, 0, -mount_height]) {
				cylinder(r = mount_radius, h = mount_height * 1.5, $fn = facets);
			}
            // cut the outside of the sloped ridge
//			translate([0, 0, -mount_height]) {
//                difference() {
//                    cylinder(r = capsule_sep_max + mount_height * 1.5, h = mount_height * 1.5, $fn = facets);
//                    cylinder(r = capsule_sep_max, h = mount_height * 1.5, $fn = facets);
//                }
//			}
			// and cut a slot for the ridges in the wall of the cylinder
            for (rot = angles) {
                rotate([0, -elev_angle, rot]) {
                    translate([-capsule_sep_max * 2, 0.5 * ridge_width - fit, mount_slot_depth - wall / 2]) {
                        cube([capsule_sep_max * 2, ridge_width + 2 * fit, mount_height]);
                    }
                    translate([-capsule_sep_max * 2, - 1.5 * ridge_width - fit, mount_slot_depth - wall / 2]) {
                        cube([capsule_sep_max * 2, ridge_width + 2 * fit, mount_height]);
                    }
                }
			}
		}
	}
}

// render a complete microphone
if (rendermic == 1) {
	capsule(45, elev_angle, leg_angles_top, 60, 0);
	capsule(-135, elev_angle, leg_angles_top, 60, 0);
	capsule(-45, -elev_angle, leg_angles_bot, 0, 1);
	capsule(135, -elev_angle, leg_angles_bot, 0, 1);
	// the mount
	mount([-45, 135], 1, capsule_bottom);
}

// print all the parts separately
// at most print two parts at the same time
part_sep = capsule_radius * 1.6;
if (rendermic == 0) {
    // #3
	translate([part_sep, -part_sep, capsule_height]) { capsule(0, -90, leg_angles_top, 45 + 10, 0); }
    if (renderset != 0) {
        // #4
        translate([part_sep, part_sep, capsule_height]) { capsule(0, -90, leg_angles_top, 45 + 10, 0); }
        // #2
        translate([-part_sep, part_sep, capsule_height]) { capsule(0, -90, leg_angles_bot, -90, 1); }
        // #1
        translate([-part_sep, -part_sep, capsule_height]) { capsule(0, -90, leg_angles_bot, 90, 1); }
        // mount
        translate([part_sep * 2.2, 0, mount_height]) { mount([-45, 135], 1, 0); }
        
        // add connecting ridges to make it all one part
        translate([-wall / 2, -part_sep, 0]) {
            cube([wall, part_sep * 2, wall / 2]);
        }
        translate([-(part_sep - capsule_radius - wall / 2), part_sep - wall / 2, 0]) {
            cube([(part_sep - capsule_radius - wall / 2) * 2, wall, wall / 2]);
        }
        translate([-(part_sep - capsule_radius - wall / 2), - part_sep - wall / 2, 0]) {
            cube([(part_sep - capsule_radius - wall / 2) * 2, wall, wall / 2]);
        }
        // connect the mount
        translate([part_sep * 2 - mount_radius - wall, - mount_radius, 0]) {
            rotate([0, 0, 45]) {
                cube([mount_radius, wall, wall / 2]);
            }
        }
    }
}