solidruby 0.1.0

data/lib/solidruby/assemblies/gear.rb

@@ -0,0 +1,131 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby 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.
+#
+#    SolidRuby 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 SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+
+module SolidRuby::Assemblies
+  class Gear < Assembly
+    # this library is to be used to easily work with gears and their distances to each other
+
+    attr_reader :module, :teeth, :height, :hub_dia, :hub_height
+
+    def initialize(args = {})
+      @module = args[:module] || 1.0
+      @teeth = args[:teeth] || 1.0
+      @bore = args[:bore] || 0.0
+      @height = args[:height] || 3.0
+      @hub_dia = args[:hub_dia] || 0.0
+      @hub_height = args[:hub_height] || 0.0
+      @output_margin_dia = args[:output_margin_dia] || 2
+      @output_margin_height = args[:output_margin_height] || 1
+      super(args)
+    end
+
+    def show
+      res = cylinder(d: @module * @teeth, h: @height)
+
+      if @hub_height.to_f > 0 && @hub_dia.to_f > 0
+        res += cylinder(d: @hub_dia, h: @hub_height).translate(z: @height)
+      end
+
+      if @bore.to_f > 0.0
+        res -= cylinder(d: @bore, h: @height + @hub_height + 0.2).translate(z: -0.1)
+      end
+      res.color('darkgray')
+    end
+
+    def output
+      res = cylinder(d: @module * @teeth + @output_margin_dia, h: @height + @output_margin_height)
+      if @hub_height.to_f > 0 && @hub_dia.to_f > 0
+        res += cylinder(d: @hub_dia + @output_margin_dia, h: @hub_height + @output_margin_height).translate(z: @height)
+      end
+
+      res
+    end
+
+    def distance_to(other_gear)
+      if @module != other_gear.module
+        raise 'You cannot use two gears with different gear modules.'
+        return
+      end
+      (@module.to_f * (@teeth.to_f + other_gear.teeth.to_f)) / 2.0
+    end
+
+    def ratio(other_gear)
+      @teeth.to_f / other_gear.teeth.to_f
+    end
+  end
+
+  # Acts the same as Gear, but does produce printable output
+  class PrintedGear < Gear
+    def initialize(args = {})
+      super
+      @pressure_angle = args[:pressure_angle] || 20
+      @clearance = args[:clearance] || 0.0
+      @backlash = args[:backlash] || 0.0
+      @twist = args[:twist] || 0.0
+      @teeth_to_hide = args[:teeth_to_hide] || 0.0
+
+      @rotation = args[:rotation] || 0.0 # rotation in teeth
+    end
+
+    def show
+      output
+    end
+
+    # ported from publicDomainGearV1.1.scad
+    def output
+      p = @module * @teeth / 2.0
+      c = p + @module - @clearance # radius of pitch circle
+      b  = p * Math.cos(radians(@pressure_angle)) # radius of base circle
+      r  = p - (c - p) - @clearance # radius of root circle
+      t  = (@module * Math::PI) / 2.0 - @backlash / 2.0 # tooth thickness at pitch circle
+      k  = -iang(b, p) - t / 2.0 / p / Math::PI * 180 # angle to where involute meets base circle on each side of tooth
+
+      points = [
+        [0, -@hub_dia / 10.0],
+        polar(r, -181 / @teeth.to_f),
+        polar(r, r < b ? k : -180 / @teeth.to_f),
+        q7(0 / 5, r, b, c, k, 1), q7(1 / 5, r, b, c, k, 1), q7(2 / 5, r, b, c, k, 1), q7(3 / 5, r, b, c, k, 1), q7(4 / 5, r, b, c, k, 1), q7(5 / 5, r, b, c, k, 1),
+        q7(5 / 5, r, b, c, k, -1), q7(4 / 5, r, b, c, k, -1), q7(3 / 5, r, b, c, k, -1), q7(2 / 5, r, b, c, k, -1), q7(1 / 5, r, b, c, k, -1), q7(0 / 5, r, b, c, k, -1),
+        polar(r, r < b ? -k : 180 / @teeth.to_f),
+        polar(r, 181 / @teeth.to_f)
+      ]
+      paths = [(0..16).to_a]
+
+      res = SolidRubyObject.new
+      (0..@teeth - @teeth_to_hide - 1).each do |i|
+        res += polygon(points: points, paths: paths).linear_extrude(h: @height, convexity: 10, center: false, twist: @twist).rotate(z: i * 360 / @teeth.to_f)
+      end
+
+      res -= cylinder(h: @height + 0.2, d: @bore).translate(z: -0.1)
+      res.rotate(z: @rotation * 360.0 / @teeth)
+    end
+
+    def polar(r, theta)
+      [r * Math.sin(radians(theta)), r * Math.cos(radians(theta))] # convert polar to cartesian coordinates
+    end
+
+    def iang(r1, r2)
+      Math.sqrt((r2 / r1) * (r2 / r1) - 1) / Math::PI * 180 - degrees(Math.acos(r1 / r2)) # //unwind a string this many degrees to go from radius r1 to radius r2
+    end
+
+    def q7(f, r, b, r2, t, s)
+      q6(b, s, t, (1 - f) * [b, r].max + f * r2) # radius a fraction f up the curved side of the tooth
+    end
+
+    def q6(b, s, t, d)
+      polar(d, s * (iang(b, d) + t)) # point at radius d on the involute curve
+    end
+  end
+end

data/lib/solidruby/assemblies/linear_bearing.rb

@@ -0,0 +1,84 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby 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.
+#
+#    SolidRuby 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 SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+
+module SolidRuby::Assemblies
+  class Lm_uu < Assembly
+    def initialize(args = { inner_diameter: 10 })
+      @args = args
+      @lm_uu = {
+        3  => { diameter: 7, length: 10 },
+        4  => { diameter: 8, length: 12 },
+        5  => { diameter: 10, length: 15 },
+        6  => { diameter: 12, length: 19 },
+        8  => { diameter: 15, length: 24 },
+        10 => { diameter: 19, length: 29 },
+        12 => { diameter: 21, length: 30 },
+        13 => { diameter: 23, length: 32 },
+        16 => { diameter: 28, length: 37 },
+        20 => { diameter: 32, length: 42 },
+        25 => { diameter: 40, length: 59 },
+        30 => { diameter: 45, length: 64 },
+        35 => { diameter: 52, length: 70 },
+        40 => { diameter: 60, length: 80 },
+        50 => { diameter: 80, length: 100 },
+        60 => { diameter: 90, length: 110 }
+      }
+      @shell_thickness = 1.1
+      BillOfMaterial.bom.add(description) unless args[:no_bom] == true
+    end
+
+    def description
+      "LM#{@args[:inner_diameter]}UU Linear bearing"
+    end
+
+    def output
+      show
+    end
+
+    def dimensions
+      diameter = @lm_uu[@args[:inner_diameter]][:diameter]
+      length = @lm_uu[@args[:inner_diameter]][:length]
+      [diameter, length]
+    end
+
+    def show
+      diameter, length = dimensions
+      shell = cylinder(d: diameter, h: length)
+      shell -= cylinder(d: diameter - @shell_thickness * 2, h: length + 0.2).translate(z: -0.1)
+      shell = shell.color('LightGrey')
+
+      inner = cylinder(d: diameter - @shell_thickness * 2, h: length)
+      inner -= cylinder(d: @args[:inner_diameter], h: length + 0.2).translate(z: -0.1)
+      inner = inner.color('DimGray')
+
+      shell + inner
+    end
+  end
+
+  class Lm_luu < Lm_uu
+    def initialize(args = { inner_diameter: 10 })
+      @args = args
+      @lm_uu = {
+        12 => { diameter: 21, length: 57 }
+      }
+      @shell_thickness = 1.1
+      BillOfMaterial.bom.add(description) unless args[:no_bom] == true
+    end
+
+    def description
+      "LM#{@args[:inner_diameter]}LUU (long) Linear bearing"
+    end
+  end
+end

data/lib/solidruby/assemblies/nut.rb

@@ -0,0 +1,153 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby 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.
+#
+#    SolidRuby 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 SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+#
+module SolidRuby::Assemblies
+  class Nut < Assembly
+    attr_accessor :height
+    def initialize(size, args = {})
+      @size = size
+      @type = args[:type] ||= '934'
+      @material = args[:material] ||= '8.8'
+      @surface = args[:surface] ||= 'zinc plated'
+      @support = args[:support] ||= false
+      @support_layer_height = args[:support_layer_height] ||= 0.2
+      @margin = args[:margin] ||= 0.3 # default output margin
+
+      @slot = args[:slot] || nil
+      @slot_margin = args[:slot_margin] || 0.5
+      @slot_direction = args[:slot_direction] || 'z'
+      @cylinder_length = args[:cylinder_length] || 0	# for slot only
+
+      @transformations ||= []
+      @args = args
+      prepare_data
+      @height = args[:height] || @height
+
+      @direction = args[:direction] || @slot_direction
+
+      @bolt = nil
+      super(args)
+    end
+
+    def description
+      "M#{@size} Nut, DIN #{@type}, #{@material} #{@surface}"
+    end
+
+    def bolt(length = nil, args = {})
+      return @bolt if @bolt
+      @bolt = Bolt.new(@size, length, args)
+      case @direction
+      when 'z'
+        bolt.transformations << Rotate.new(x: 180)
+        bolt.transformations << Translate.new(z: length)
+      when '-z'
+        bolt.transformations << Translate.new(z: -length + @height)
+      when '-x'
+        bolt.transformations << Rotate.new(x: 180)
+        bolt.transformations << Translate.new(z: length)
+      when 'x'
+        bolt.transformations << Translate.new(z: -length + @height)
+      when '-y'
+        bolt.transformations << Rotate.new(x: 180)
+        bolt.transformations << Translate.new(z: length)
+      when 'y'
+        bolt.transformations << Translate.new(z: -length + @height)
+      end
+      @bolt.transformations += transformations.dup
+
+      @bolt
+    end
+
+    def prepare_data
+      chart_934 = {
+        2.5 => { side_to_side: 5, height: 2, support_diameter: 2.8 },
+        3 => { side_to_side: 5.5, height: 2.4, support_diameter: 3.5 },
+        4 => { side_to_side: 7, height: 3.2, support_diameter: 4.4 },
+        5 => { side_to_side: 8, height: 4, support_diameter: 5.3 },
+        6 => { side_to_side: 10, height: 5, support_diameter: 6.3 },
+        8 => { side_to_side: 13, height: 6.5, support_diameter: 8.3 },
+        10 => { side_to_side: 17, height: 8, support_diameter: 10.3 },
+        12 => { side_to_side: 19, height: 10, support_diameter: 12.3 }
+      }
+      # for securing nuts
+      chart_985 = {
+        3 => { height: 4 },
+        4 => { height: 5 },
+        5 => { height: 5 },
+        6 => { height: 6 }
+      }
+
+      @s = chart_934[@size][:side_to_side]
+      @height = chart_934[@size][:height]
+      @support_diameter = chart_934[@size][:support_diameter]
+      @height = chart_985[@size][:height] if @type == "985"
+    end
+
+    def add_support(layer_height = @support_layer_height)
+      res = cylinder(d: @support_diameter, h: @height - layer_height)
+      # on very small nuts, add a support base of one layer height, so the support won't fall over
+      res += cylinder(d:@s-1,h:layer_height) if @size < 6
+      res
+    end
+
+    def slot
+      case @slot_direction
+      when 'x'
+        pos = { x: @slot }
+      when 'y'
+        pos = { y: @slot }
+      when 'z'
+        pos = { z: @slot }
+      when '-x'
+        pos = { x: -@slot }
+      when '-y'
+        pos = { y: -@slot }
+      when '-z'
+        pos = { z: -@slot }
+      else
+        raise "Invalid slot direction #{@slot_direction}"
+      end
+      res = hull(
+        nut_934(false, @margin, @slot_margin),
+        nut_934(false, @margin, @slot_margin).translate(pos)
+      )
+      res += cylinder(d:@size+@margin,h:@cylinder_length) if @cylinder_length > 0
+      res
+    end
+
+    def output
+      add_to_bom
+      if @slot.nil?
+        return transform(nut_934(false, @margin))
+      else
+        return transform(slot)
+      end
+    end
+
+    def show
+      add_to_bom
+      transform(nut_934)
+    end
+
+    def nut_934(show = true, margin = 0, height_margin = 0)
+      @s += margin
+
+      res = cylinder(d: (@s / Math.sqrt(3)) * 2, h: @height + height_margin, fn: 6)
+      res -= cylinder(d: @size, h: @height) if show == true
+      res -= add_support if @support
+      res.color('Gainsboro')
+    end
+  end
+end

data/lib/solidruby/assemblies/pipe.rb

@@ -0,0 +1,153 @@
+#    This file is part of SolidRuby.
+#
+#    SolidRuby 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.
+#
+#    SolidRuby 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 SolidRuby.  If not, see <http://www.gnu.org/licenses/>.
+
+module SolidRuby::Assemblies
+  class Pipe < Assembly
+    attr_accessor :x, :y, :sum_x, :sum_y, :pipe, :bent_segments
+    # Warning: sum_x and sum_y are both a quick hack at the moment
+    # 				 They will ONLY work on bends if you do same thing in the other direction
+    #					 for example
+    #					 pipe.cw(20,30)
+    #					 pipe.ccw(20,30)
+    #	This might be fixed in the future.
+
+    def initialize(args = {})
+      # parameters
+      @diameter = args[:diameter] || 1
+      @fn = args[:fn] || 64
+      @bent_segments = args[:bent_segments] || 128
+      @line_rotation = args[:line_rotation] || 0 # z rotation in case needed with fn values
+
+      # variable initialization
+      @pipe = nil
+      @sum_x = 0
+      @sum_y = 0
+    end
+
+    def shape
+      circle(d: @diameter, fn: @fn)
+    end
+
+    def inner_shape
+      nil
+    end
+
+    # This will be called on bent, so this library can work with rectangle pipes, if you overwrite this and let it rotate z by 90
+    def apply_rotation(obj)
+      obj
+    end
+
+    # go clockwise
+    def cw(radius, angle, color = nil)
+      return false if angle > 360
+      # since bent can only do up to 90°, splitting it up in chunks in order to grow it
+      return cw(radius, 90, color) + cw(radius, angle - 90, color) if angle > 90
+
+      if @pipe.nil?
+        @pipe = bent_cw(radius, angle)
+        @pipe = @pipe.color(color) unless color.nil?
+      else
+        rotated_pipe = @pipe.rotate(z: -angle)
+        pipe_piece = bent_cw(radius, angle)
+        pipe_piece = pipe_piece.color(color) unless color.nil?
+        @pipe = pipe_piece + rotated_pipe.translate(x: x, y: y - radius)
+      end
+    end
+
+    # go counter clockwise
+    def ccw(radius, angle, color = nil)
+      return false if angle > 360
+      # since bent can only do up to 90°, splitting it up in chunks in order to grow it
+      return ccw(radius, 90, color) + ccw(radius, angle - 90, color) if angle > 90
+
+      if @pipe.nil?
+        @pipe = bent_ccw(radius, angle)
+        @pipe = @pipe.color(color) unless color.nil?
+      else
+        rotated_pipe = @pipe.rotate(z: angle)
+        pipe_piece = bent_ccw(radius, angle)
+        pipe_piece = pipe_piece.color(color) unless color.nil?
+        @pipe = pipe_piece + rotated_pipe.translate(x: x, y: y + radius)
+      end
+    end
+
+    def line(length, color = nil)
+      @pipe = if @pipe.nil?
+                create_line(length, color)
+              else
+                @pipe.translate(x: length) + create_line(length, color)
+              end
+      @sum_x += length
+    end
+
+    private
+
+    def create_line(length, color = nil)
+      res = shape.linear_extrude(h: length)
+      if inner_shape
+        res -= inner_shape.linear_extrude(h: length + 0.2).translate(z: -0.1)
+      end
+      res = res.color(color) if color
+      res.rotate(z: @line_rotation).rotate(y: 90)
+    end
+
+    def bent_cw(radius, angle)
+      res = apply_rotation(shape).translate(x: radius).rotate_extrude(fn: @bent_segments)
+      res -= apply_rotation(inner_shape).translate(x: radius).rotate_extrude(fn: @bent_segments) unless inner_shape.nil?
+
+      len = radius + @diameter / 2.0
+      @x = Math.sin(radians(angle)) * len
+      @y = Math.cos(radians(angle)) * len
+      cut = polygon(points: [[0, 0], [0, len], [@x, @y]]).scale(2)
+
+      # for working with it
+      len = radius #- @diameter / 2.0
+      @x = Math.sin(radians(angle)) * len
+      @y = Math.cos(radians(angle)) * len
+
+      @sum_x += @x
+      @sum_y += @y
+
+      res *= cut.linear_extrude(h: 100).translate(z: -50)
+
+      # Positioning it on 0
+      res.translate(y: -radius)
+    end
+
+    def bent_ccw(radius, angle)
+      res = apply_rotation(shape).translate(x: radius).rotate_extrude(fn: @bent_segments)
+      res -= apply_rotation(inner_shape).translate(x: radius).rotate_extrude(fn: @bent_segments) unless inner_shape.nil?
+
+      len = radius + @diameter / 2.0
+      @x = Math.sin(radians(angle)) * len
+      @y = Math.cos(radians(angle)) * len
+      cut = polygon(points: [[0, 0], [0, len], [@x, @y]]).scale(2)
+
+      # for working with it
+      len = radius #- @diameter / 2.0
+      @x = Math.sin(radians(angle)) * len
+      @y = -1 * Math.cos(radians(angle)) * len
+
+      @sum_x += @x
+      @sum_y += @y
+
+      res *= cut.linear_extrude(h: 100).translate(z: -50)
+      res = res.mirror(y: 1)
+      # Positioning it on 0
+
+      res.translate(y: radius)
+    end
+  end
+end