make it easy to switch between spin and cap object

[ozzloy@gmail.com/3d-printables] / spin-data.scad

/* GNU AGPLv3 (or later at your option)
   see bottom for more license info */

/* spin thing that erin likes */
$fn = 500;

weight = "penny";
// weight = "608zz";
bearing = "608zz";
weight_lip_thickness = 1;
wall_thickness = 2;
penny_thickness = 1.52;
penny_radius = 19.05 / 2;

_608zz_radius = 22 / 2;
_608zz_inner_radius = 8.1 / 2;
_608zz_cover_radius = 19.4 / 2;
_608zz_cap_footprint_radius = 12 / 2;
_608zz_thickness = 7;

weight_radius = (weight == "penny") ? penny_radius : _608zz_radius;
weight_thickness = (weight == "penny") ?
     penny_thickness * 5 : _608zz_thickness;

bearing_radius = (bearing == "608zz") ? _608zz_radius : 1/0;
bearing_inner_radius = (bearing == "608zz") ? _608zz_inner_radius : 1/0;
bearing_cover_radius = (bearing == "608zz")
                       ? _608zz_cover_radius + wall_thickness
                       : 1/0;
bearing_cap_footprint_radius =
     (bearing == "608zz") ? _608zz_cap_footprint_radius : 1/0;
bearing_thickness = (bearing == "608zz") ? _608zz_thickness : 1/0;

spinner_height = penny_thickness * 5 + 2;
arms = 3;

module cap(bearing_inner_radius,
           bearing_cap_footprint_radius,
           bearing_cover_radius,
           bearing_thickness) {
  footprint_height = 1.6;
  footprint_radius_safety = 0.25;
  cap_height = 3;
  bearing_cover_radius_safety = 0.75;
  bearing_thickness_safety = 0.2;

  difference() {
    union() {
      cylinder(r1 = bearing_cover_radius - tan(30) * cap_height,
               r2 = bearing_cover_radius,
               h = cap_height);
      linear_extrude(height = cap_height + footprint_height) {
        circle(bearing_cap_footprint_radius - footprint_radius_safety); }
      linear_extrude(height = cap_height
                              + footprint_height
                              + bearing_thickness / 2
                              - bearing_thickness_safety) {
        circle(bearing_inner_radius); } }
    translate([0, 0, -0.01]) {
      cylinder(r1 = bearing_inner_radius + tan(30) * (cap_height - 1),
               r2 = bearing_inner_radius,
               h = cap_height - 1); } } }

module ring(outer_radius, inner_radius) {
  difference() {
    circle(outer_radius);
    circle(inner_radius); } }

module spin_2d(weight_radius,
               arms,
               wall_thickness,
               bearing_radius) {
  bearing_holder_radius = bearing_radius + wall_thickness;
  weight_holder_radius = weight_radius + wall_thickness;

  ring(bearing_holder_radius, bearing_radius);

  /*
   * imagine a triangle with one point at the origin, at the
   * center of the spinning bearing holder, one point in the middle of
   * the weight holder, and one point at the center of a circle tangent
   * to the first two, called the joiner circle.
   * the radius of the joiner circle is the arithmetic average of the
   * weight holder and bearing holder.
   */
  joiner_radius = (bearing_holder_radius + weight_holder_radius) / 2;
  /* a: goes between the center of the weight holder and the center of
     the joiner circle. */
  a = joiner_radius + weight_holder_radius;
  /* b: length of the base, which goes along the x-axis between
     the origin and the center of the weight holder. */
  b = weight_holder_radius + bearing_holder_radius;
  /* c: goes between origin and joiner circle. */
  c = bearing_holder_radius + joiner_radius;

  /* A: angle at the origin, between the base and segment from origin
     to center of joiner circle.
     it is calculated using law of cosines, given the lengths of
     all 3 sides of the triangle. */
  A = acos((pow(b, 2) + pow(c, 2) - pow(a, 2)) / (2 * b * c));
  /* find the center of the joiner circle */
  joiner_x = cos(A) * c;
  joiner_y = sin(A) * c;

  /* find the points where the circles meet */
  bearing_joiner_point = [cos(A) * bearing_holder_radius,
                          sin(A) * bearing_holder_radius];
  bearing_weight_point = [bearing_holder_radius, 0];
  /* C: angle between x-axis and line-segment between center of weight
     holder and center of joiner.
     it is calculated using law of cosines, given the lengths of
     all 3 sides of the triangle. */
  C = acos((pow(a, 2) + pow(b, 2) - pow(c, 2)) / (2 * a * b));
  weight_joiner_point = [b - cos(C) * weight_holder_radius,
                         sin(C) * weight_holder_radius];
  for(arm = [0 : arms - 1]) {
    rotate(arm * 360.0 / arms) {
      difference() {
        polygon([bearing_weight_point,
                 bearing_joiner_point,
                 weight_joiner_point]);
        translate([joiner_x, joiner_y]) {
          circle(joiner_radius); }
        translate([weight_holder_radius + bearing_holder_radius, 0]) {
          circle(weight_holder_radius); } }
      mirror(v = [0, 1, 0]) {
        difference() {
          polygon([bearing_weight_point,
                   bearing_joiner_point,
                   weight_joiner_point]);
          translate([joiner_x, joiner_y]) {
            circle(joiner_radius); }
        translate([weight_holder_radius + bearing_holder_radius, 0]) {
          circle(weight_holder_radius); } } }
      translate([weight_holder_radius + bearing_holder_radius, 0]) {
        ring(weight_holder_radius, weight_radius); } } } }

module spin(weight_radius,
            weight_thickness,
            weight_lip_thickness,
            arms,
            wall_thickness,
            bearing_radius,
            bearing_thickness) {
  /* TODO: make window size parameter */
  /* TODO: rethink how lips are done */
  /* TODO: right now, weight is assumed to be thicker than bearing*/
  spinner_height = weight_thickness + 2 * weight_lip_thickness;
  bearing_lip_thickness = (spinner_height - bearing_thickness) / 2;
  linear_extrude(height = weight_lip_thickness) {
    spin_2d(weight_radius - 1,
            arms,
            wall_thickness + 1,
            bearing_radius - 1); }
  linear_extrude(height = bearing_lip_thickness) {
    ring(bearing_radius, bearing_radius - 1); }
  linear_extrude(height = spinner_height) {
    spin_2d(weight_radius, arms, wall_thickness, bearing_radius); }
  translate([0, 0, spinner_height - bearing_lip_thickness]) {
    linear_extrude(height = bearing_lip_thickness) {
    ring(bearing_radius, bearing_radius - 1); } }
  translate([0, 0, spinner_height - weight_lip_thickness]) {
    linear_extrude(height = weight_lip_thickness) {
      spin_2d(weight_radius - 1,
              arms,
              wall_thickness + 1,
              bearing_radius - 1); } } }

/*
  This file is part of 3d-printables.

  3d-printables is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  3d-printables 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 Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License
  along with challenge-bot.  If not, see <http://www.gnu.org/licenses/>.
*/