134 lines
3.8 KiB
Python
134 lines
3.8 KiB
Python
# (c) 2020 Adam Spontarelli <adam@vector-space.org>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU Lesser General Public License (LGPL)
|
|
# as published by the Free Software Foundation; either version 2 of
|
|
# the License, or (at your option) any later version.
|
|
# for detail see the LICENCE text file.
|
|
#
|
|
# FCGear 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 Library General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Library General Public
|
|
# License along with FCGear; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
|
|
from math import cos, sin, tan, sqrt, radians, atan, asin, degrees
|
|
|
|
|
|
def CreateSprocket(w, P, N, Dr):
|
|
"""
|
|
Create a sprocket
|
|
|
|
w is the wirebuilder object (in which the sprocket will be constructed)
|
|
P is the chain pitch
|
|
N is the number of teeth
|
|
Dr is the roller diameter
|
|
|
|
Remaining variables can be found in Standard Handbook of Chains
|
|
"""
|
|
Ds = 1.005 * Dr + (0.003 * 25.4)
|
|
R = Ds / 2
|
|
M = 0.8 * Dr * cos(radians(35) + radians(60 / N))
|
|
T = 0.8 * Dr * sin(radians(35) + radians(60 / N))
|
|
E = 1.3025 * Dr + (0.0015 * 25.4)
|
|
W = 1.4 * Dr * cos(radians(180 / N))
|
|
V = 1.4 * Dr * sin(radians(180 / N))
|
|
F = Dr * (
|
|
0.8 * cos(radians(18) - radians(56) / N) + 1.4 * cos(radians(17) - radians(64) / N) - 1.3025
|
|
) - (0.0015 * 25.4)
|
|
PD = P / (sin(radians(180) / N))
|
|
# H = sqrt(F**2 - (1.4 * Dr - P/2)**2)
|
|
# OD = P * (0.6 + 1/tan(radians(180/N)))
|
|
|
|
# The sprocket tooth gullet consists of four segments
|
|
x0 = 0
|
|
y0 = PD / 2 - R
|
|
|
|
# ---- Segment 1 -----
|
|
alpha = 35 + 60 / N
|
|
x1 = -R * cos(radians(alpha))
|
|
y1 = PD / 2 - R * sin(radians(alpha))
|
|
|
|
# ---- Segment 2 -----
|
|
alpha = 35 + 60 / N
|
|
beta = 18 - 56 / N
|
|
x2 = M - E * cos(radians(alpha - beta))
|
|
y2 = T - E * sin(radians(alpha - beta)) + PD / 2
|
|
|
|
# # ---- Segment 3 -----
|
|
y2o = y2 - PD / 2
|
|
hyp = sqrt((-W - x2) ** 2 + (-V - y2o) ** 2)
|
|
AP = sqrt(hyp**2 - F**2)
|
|
gamma = atan((y2o + V) / (x2 + W))
|
|
alpha = asin(AP / hyp)
|
|
beta = 180 - (90 - degrees(alpha)) - (90 - degrees(gamma))
|
|
x3o = AP * sin(radians(beta))
|
|
y3o = AP * cos(radians(beta))
|
|
x3 = x2 - x3o
|
|
y3 = y2 + y3o
|
|
|
|
# ---- Segment 4 -----
|
|
alpha = 180 / N
|
|
m = -1 / tan(radians(alpha))
|
|
yf = PD / 2 - V
|
|
A = 1 + m**2
|
|
B = 2 * m * yf - 2 * W
|
|
C = W**2 + yf**2 - F**2
|
|
# x4a = (-B - sqrt(B**2 - 4 * A * C)) / (2*A)
|
|
x4b = (-B + sqrt(B**2 - 4 * A * C)) / (2 * A)
|
|
x4 = -x4b
|
|
y4 = m * x4
|
|
|
|
p0 = [x0, y0]
|
|
p1 = [x1, y1]
|
|
p2 = [x2, y2]
|
|
p3 = [x3, y3]
|
|
p4 = [x4, y4]
|
|
p5 = [-x1, y1]
|
|
p6 = [-x2, y2]
|
|
p7 = [-x3, y3]
|
|
p8 = [-x4, y4]
|
|
|
|
w.move(p4) # vectors are lists [x,y]
|
|
w.arc(p3, F, 0)
|
|
w.line(p2)
|
|
w.arc(p1, E, 1)
|
|
w.arc(p0, R, 1)
|
|
|
|
# ---- Mirror -----
|
|
w.arc(p5, R, 1)
|
|
w.arc(p6, E, 1)
|
|
w.line(p7)
|
|
w.arc(p8, F, 0)
|
|
|
|
# ---- Polar Array ----
|
|
alpha = -radians(360 / N)
|
|
for n in range(1, N):
|
|
# falling gullet slope
|
|
w.arc(rotate(p3, alpha * n), F, 0)
|
|
w.line(rotate(p2, alpha * n))
|
|
w.arc(rotate(p1, alpha * n), E, 1)
|
|
w.arc(rotate(p0, alpha * n), R, 1)
|
|
|
|
# rising gullet slope
|
|
w.arc(rotate(p5, alpha * n), R, 1)
|
|
w.line(rotate(p6, alpha * n))
|
|
w.arc(rotate(p7, alpha * n), E, 0)
|
|
w.arc(rotate(p8, alpha * n), F, 0)
|
|
|
|
w.close()
|
|
|
|
return w
|
|
|
|
|
|
def rotate(pt, rads):
|
|
"""
|
|
rotate pt by rads radians about origin
|
|
"""
|
|
sinA = sin(rads)
|
|
cosA = cos(rads)
|
|
return (pt[0] * cosA - pt[1] * sinA, pt[0] * sinA + pt[1] * cosA)
|