//
// SphEAR, First Order (B-format) Ambisonics Microphone
//
// Copyright 2015, Fernando Lopez-Lezcano, All Rights Reserved
//
// Source code released under the GNU GPL License
// http://www.gnu.org/licenses/gpl-3.0.en.html
//
// 3d models released under Creative Commons Non-Commercial Share-Alike
// CC-NC-SA 3.0
// http://creativecommons.org/licenses/by-nc-sa/3.0/
//
// https://en.wikipedia.org/wiki/Tetrahedron
// angle capsule to vertical = 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.5;

// 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 = 3;

// 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 = 1;
renderset = 0;

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

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

// adjustment for the size of the capsule
//   (measured inside diameter was around 7.5 to 8.2 instead of 10, capsule diameter was 9.99)
fudge = 0.15;

// adjustment for fit of slots
fit = 0.2;

// wall thickness of cylinders
wall = 1;

// number of facets for cylinders
facets = 64;

// the rest of the leg geometry
tetra = atan(sqrt(2));
leg_length = 
	connect == 0 ?
		mic_radius * sin(tetra) - capsule_radius * cos(tetra) :
		connect == 1 ? 
			(mic_radius - capsule_height + leg_thick) * sin(tetra) / sin(90 - tetra) - capsule_radius : 
			mic_radius - (capsule_radius / sqrt(2));
slot_depth = connect == 1 ?
	leg_thick * 1.5 : leg_thick;

// holder geometry
capsule_sep_min = mic_radius * sin(tetra) - capsule_radius * cos(tetra);
capsule_sep_max = capsule_sep_min + capsule_height * sin(tetra);
capsule_bottom = mic_radius * cos(tetra) + capsule_radius * sin(tetra);

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

// azimuth: orientation of the capsule
// elevation: orientation of the capsure
// twist: adjust the angle of the mounts
// mounts: number of mounts to create (2 for the bottom mics, 3 for the top)

module capsule (azimuth, elevation, twist, mounts) {
	rotate([0, 0, azimuth]) {
		rotate([0, (90 - elevation), 0]) {
  			translate([0, 0, rendermic == 0 ? 0 : mic_radius - capsule_height]) {
				// the capsule holder
				difference () {
					union () {
						// main capsule holder
						cylinder(r = capsule_radius + wall, h = capsule_height, $fn = facets);	
						// the attachment point to the other capsules
						for (rot = mounts == 2 ? [-120, 120] : [-120, 0, 120]) {
							rotate(a = rot + twist, v = [0, 0, 1]) {
								// connect with cylindrical beams, very pretty
								if (connect == 0) {
									translate([capsule_radius - wall, 0, capsule_height - wall]) {
										rotate([0, 90 + tetra, 0]) {
											cylinder(d = leg_width, h = leg_length - 0.3, center = false, $fn = facets);
										}
									}
								}
								// connect with horizontal legs
								if (connect == 1) {
									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) {
									translate([capsule_radius + fudge, - leg_width / 3, - leg_length + capsule_height]) {
										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]);
											}
										}
									}
								}
							}
						}
						// add ridges for microphone mount
						if (mounts == 2) {
							rotate([0, 0, twist]) {
								translate([capsule_radius + fudge, - wall , 0]) {
									difference() {
										cube([ridge_length, ridge_width, capsule_height], center = false);
										rotate([0, tetra, 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

module mount (wall, separation) {
	translate([0, 0, -(separation + 1)]) {
		difference() {
			union() {
				// grips for the capsule holder ridge
				for (rot = [0 : 180 : 360]) {
					rotate([0, 0, rot - 45]) {
						translate([-(capsule_sep_max / 2), (ridge_width / 2) + fit, -mount_height]) {
							cube([capsule_sep_max, ridge_width / 2, mount_height]);
						}
					}
				}
				translate([0, 0, -mount_height]) {
					cylinder(r = mount_radius + wall, h = mount_height, $fn = facets);
				}
			}
			// make the hole for the mount
			translate([0, 0, -mount_height]) {
				cylinder(r = mount_radius, h = mount_height, $fn = facets);
			}
			// and cut a slot for the ridges in the wall of the cylinder
			rotate([0, 0, -45]) {
				translate([-(capsule_sep_max / 2), -ridge_width + 4 * fit, -mount_height / 2]) {
					cube([capsule_sep_max, ridge_width + 2 * fit, mount_height]);
				}
			}
		}
	}
}

// elevation angle for capsule holders
elev = asin(1 / sqrt(3));

// render a complete microphone
if (rendermic == 1) {
	capsule(45, elev, 60, 3);
	capsule(-45, -elev, 0, 2);
	capsule(-135, elev, 60, 3);
	capsule(135, -elev, 0, 2);
	// the mount
	mount(1, capsule_bottom);
}

// print all the parts separately
part_sep = capsule_radius * 2 * 3;
if (rendermic == 0) {
	capsule(0, -90, 0, 3);
    if (renderset != 0) {
        translate([0, part_sep, 0]) { capsule(0, -90, 0, 3); }
        translate([part_sep, 0, 0]) { capsule(0, -90, 0, 2); }
        translate([part_sep, part_sep]) { capsule(0, -90, 0, 2); }
        translate([part_sep / 2, -part_sep, 0]) { mount(1, 0); }
    }
}