An involute gear is a gear which has a curved tooth-surface. The basic outline of such gear is:
The gear has following parameters that need to be input or calculated:
| • | Pitch circle | The circle of tooth contact with another gear |
| • | Outer circle | The outer size of the gear |
| • | Work circle | The depth of mating gear's tooth |
| • | Root circle | Actual depth of the teeth |
| • | Base circle | The origin of the involute curve |
| • | Fillet | Recessed rounding at bottom of tooth for clearance |
| • | Involute curve | Smooth tooth surface for teeth-rollover |
| • | Base connect | Connection from the fillet to the involute curve |
| Additional parameters: | ||
| • | Number of teeth | |
| • | Size of the gear, either by a diameter or by teeth-per-mm (or teeth-per-inch) | |
| • | Pressure angle at which the teeth have contact | |
A gear has a set of parameters and associated names as listed below.
| • | N | Number of Teeth | ||
| • | Pa | Pressure Angle | ||
| • | D | Pitch Diameter | D = N/P = Do - 2/P | Gear radius at center of the teeth |
| • | P | Diametral Pitch | P = N/D | |
| • | p | Circular Pitch | p = pi() / P | |
| • | Db | Base Diameter | Db = D * cos(Pa) | Bottom of teeth insertion |
| • | Dr | Root Diameter | Dr = D - 2b | Bottom of tooth cutout |
| • | Do | Outside Diameter | Do = D + 2a | |
| • | a | Addendum | a = 1/P | |
| • | b | Dedendum | b = ht - a | |
| • | ht | Whole Depth | 2.157/P | |
| • | hk | Working Depth | 2*a |
It is important to see shortcuts in the design when creating a program. For example, a gear has many symmetries which can be used to reduce the amount of work. Once a small part of the gear is created, it can be duplicated in rotated and mirrored forms quite easily.
The smallest part of the gear that must be calculated is one single side of a tooth. The side of a tooth starts with the fillet and connects to the involute curve. Once this small part is created, it can be duplicated to create a full tooth, which in turn can be duplicated to create the entire gear.
Calculating the basic parameters
The input of the gear-making function will be:
All other parameters can be calculated from the above input arguments. The output is a vectorlist containing all points to describe the gear in a 2D path.
The first part of the function consists of calculating the necessary parameters to define the gear from the input arguments. The calculations are as given in above table. The work diameter is given by the working depth, which is twice the addendum.
| • | N | Number of Teeth |
| • | Pa | Pressure Angle |
| • | P | Diametral Pitch |
All other parameters can be calculated from the above input arguments. The output is a vectorlist containing all points to describe the gear in a 2D path.
function gear_P(nteeth, pressure_angle, diametral_pitch) { local gear = {}; ... return gear; }There are two new concepts in above function outline. Firstly, the keyword local is used to signal gcmc that the named variable is local to the function being declared. Secondly, the return statements allows the function to return a value back to the caller. The variable "gear" will be containing a list of vectors which are returned to the caller of the function.
The first part of the function consists of calculating the necessary parameters to define the gear from the input arguments. The calculations are as given in above table. The work diameter is given by the working depth, which is twice the addendum.
function gear_P(nteeth, pressure_angle, diametral_pitch) { local pitch_diameter = nteeth / diametral_pitch; local base_diameter = pitch_diameter * cos(pressure_angle); local addendum = 1.0/diametral_pitch; local ht = 2.157 / diametral_pitch; local dedendum = ht - addendum; local outside_diameter = pitch_diameter + 2.0*addendum; local root_diameter = base_diameter - 2.0*dedendum; local work_diameter = outside_diameter - 4.0*addendum; ... }The calculation part of the tooth can start after the parameters are setup. As mentioned above, there are many symmetries and only one side of the tooth needs to be calculated. That part looks like:
Calculating the fillet arc
The first calculation is the radius of the fillet arc. The fillet arc connects to the involute arc through a straight line. The
fillet arc should go from the root circle up to the work circle. The known point in the curve is the point on the work
circle.
Instead of doing extensive math here, it is enough to estimate the radius of the fillet arc. It turns out that the radius may be approximated by 1/8 of the distance from base to root circles. This measure will create an arc that does not drop onto the root circle exactly. The local variable "filletrad" is set to the appropriate value. Making an exact calculation is left to the reader.
The fillet arc has an angled connection to the straight line at the work circle. That angle is set at 240 degrees (seen CW). The center of the arc is known to be on a line bisecting that angle and has a length of "filletrad" from the intersection at the work circle.
The vector [-filletrad, 0.0mm] points left and must be rotated 60 degrees CCW to have the same direction as the bisecting line that is sought after. Rotating a vector is performed by:
The center of the fillet arc can now be calculated by adding the distance from the origin to the work circle. The result is a point denoting the center of the fillet arc:
The fillet arc could be created with an arc command, but that would not be useful. There is no method to embed non-linear segments in a vector list. A vector-list is a set of points, which will be connected with straight lines. Therefore, the arc must be synthesized with small linear segments. Calculating linear segments is not hard. Points are calculated on the arc at regular angular intervals from start to end. Each calculated point is then added to the result.
It is known that the arc starts at 180 degrees, the vertical tangent, and ends at 60 degrees (i.e. covers 120 degree span). Also, the center point and radius are known. A simple loop can be constructed to calculate points on the arc in following way:
The second part has an if() construct to test if the end-point of the arc was exactly reached. If the last angle calculation of "i" was not at 60 degrees, then the next segment, connecting to the involute curve, would be off. Therefore a test is performed and a finalizing point added if necessary.
The calculation of the points on the arc consists of a simple vector geometry, where a unity-circle vector is calculated with sin/cos, scaled to the fillet radius and spatially moved to the correct location. The calculated vector is encapsulated into a new vector list (using '{' ... '}') in order to concatenate vector-lists easily with the '+=' operator.
The end result of the fillet arc calculation as part of the function:
Instead of doing extensive math here, it is enough to estimate the radius of the fillet arc. It turns out that the radius may be approximated by 1/8 of the distance from base to root circles. This measure will create an arc that does not drop onto the root circle exactly. The local variable "filletrad" is set to the appropriate value. Making an exact calculation is left to the reader.
local filletrad = (base_diameter - root_diameter)/8.0;
The fillet arc has an angled connection to the straight line at the work circle. That angle is set at 240 degrees (seen CW). The center of the arc is known to be on a line bisecting that angle and has a length of "filletrad" from the intersection at the work circle.
The vector [-filletrad, 0.0mm] points left and must be rotated 60 degrees CCW to have the same direction as the bisecting line that is sought after. Rotating a vector is performed by:
rotate_xy([-filletrad, 0.0mm], 60.0deg);The built-in function rotate_xy() rotates any vector or vectorlist by the angle given. It should be noted that rotate_xy([filletrad, 0.0mm], 240.0deg) would have performed the same function as the minus sign on the X-coordinate equals 180 degree rotation for a vector with zero Y-coordinate.
The center of the fillet arc can now be calculated by adding the distance from the origin to the work circle. The result is a point denoting the center of the fillet arc:
local center = rotate_xy([-filletrad, 0.0mm], 60.0deg) + [work_diameter/2.0, 0];
The fillet arc could be created with an arc command, but that would not be useful. There is no method to embed non-linear segments in a vector list. A vector-list is a set of points, which will be connected with straight lines. Therefore, the arc must be synthesized with small linear segments. Calculating linear segments is not hard. Points are calculated on the arc at regular angular intervals from start to end. Each calculated point is then added to the result.
It is known that the arc starts at 180 degrees, the vertical tangent, and ends at 60 degrees (i.e. covers 120 degree span). Also, the center point and radius are known. A simple loop can be constructed to calculate points on the arc in following way:
local i; local tooth = {}; for(i = 180.0deg; i > 60.0deg; i -= __ang_step*2.5) { tooth += { [cos(i), sin(i)] * filletrad + center }; } if(i != 60.0deg) { // Add the last point if we did not reach the working depth tooth += { [cos(60.0deg), sin(60.0deg)] * filletrad + center }; }The first part loops the variable "i" from 180 degrees down to 60 degrees in discrete steps using a for() construct. The decrement for "i" is set at a constant ("__ang_step"), defined somewhere else in the program and default set to 2.0 degrees. The angular step is increased by a factor of 2.5 because small arcs have little movement at small angular intervals. There is no need to be nanometer precise.
The second part has an if() construct to test if the end-point of the arc was exactly reached. If the last angle calculation of "i" was not at 60 degrees, then the next segment, connecting to the involute curve, would be off. Therefore a test is performed and a finalizing point added if necessary.
The calculation of the points on the arc consists of a simple vector geometry, where a unity-circle vector is calculated with sin/cos, scaled to the fillet radius and spatially moved to the correct location. The calculated vector is encapsulated into a new vector list (using '{' ... '}') in order to concatenate vector-lists easily with the '+=' operator.
The end result of the fillet arc calculation as part of the function:
... local i; local tooth = {}; // Fillet radius is approx. Will not reach root exactly, but close enough // Otherwise need to calculate intersection with root-circle local filletrad = (base_diameter - root_diameter)/8.0; // Center of the fillet arc, involute makes a ~240deg angle with fillet arc // The fillet arc runs from the root to the working depth of the gear local center = rotate_xy([-filletrad, 0.0mm], 60.0deg) + [work_diameter/2.0, 0]; // Trace the fillet arc from ~root-circle to working depth at involute arc starting Y-level for(i = 180.0deg; i > 60.0deg; i -= __ang_step*2.5) { tooth += { [cos(i), sin(i)] * filletrad + center }; } if(i != 60.0deg) { // Add the last point if we did not reach the working depth tooth += { [cos(60.0deg), sin(60.0deg)] * filletrad + center }; } ...
Calculating the involute arc
Next up is the involute arc. The connection between the fillet arc and the involute arc is inherent to the concatenation of points
of the tooth's side. The first point of the involute arc is automatically connected with a straight segment to the last point of the
fillet arc.
An involute arc is calculated using a radius and an angle. See the Wikipedia article on the subject for detailed formula. There are two formula, the Cartesian and the Polar method. The Cartesian form can be used to create line-segments to define the arc. The Polar form, when rewritten, can be used to determine the maximum arc angle to reach the outer circle.
The involute arc's intersection with the outer circle, in radians, is defined by sqrt((O/B)^2-1), with O outer radius and B base radius of appropriate circles. In gcmc terms:
Calculating the points on the involute arc is just as easy. The calculation has both an X- and Y-coordinate, which form a vector, based on the base radius and the angle. Both are combined and return as a point on the arc. The involute_point() function uses to_rad() to ensure that the "angle" argument is in radians, which is required for the formula to function properly.
The to_none() function is used to strip the units within the basic curve calculation. The involute curve describing vector should be dimensionless so it may be scaled to distance units. The conversion to distance units is implied by the multiplication of the "radius" argument, which will be the contributor to the units of the return value.
An involute arc is calculated using a radius and an angle. See the Wikipedia article on the subject for detailed formula. There are two formula, the Cartesian and the Polar method. The Cartesian form can be used to create line-segments to define the arc. The Polar form, when rewritten, can be used to determine the maximum arc angle to reach the outer circle.
The involute arc's intersection with the outer circle, in radians, is defined by sqrt((O/B)^2-1), with O outer radius and B base radius of appropriate circles. In gcmc terms:
function involute_angle(radius, outrad) { return to_rad(sqrt(pow(outrad/radius, 2.0) - 1)); }The extra to_rad() function is to return a value with radians as units. The sqrt() returns a dimension-less value, but the formula is known to result in a value of radians.
Calculating the points on the involute arc is just as easy. The calculation has both an X- and Y-coordinate, which form a vector, based on the base radius and the angle. Both are combined and return as a point on the arc. The involute_point() function uses to_rad() to ensure that the "angle" argument is in radians, which is required for the formula to function properly.
The to_none() function is used to strip the units within the basic curve calculation. The involute curve describing vector should be dimensionless so it may be scaled to distance units. The conversion to distance units is implied by the multiplication of the "radius" argument, which will be the contributor to the units of the return value.
function involute_point(angle, radius) { angle = to_rad(angle); /* Multiplication must be in radians */ return radius * [cos(angle) + to_none(angle) * sin(angle), sin(angle) - to_none(angle) * cos(angle)]; }The involute arc is calculated by repeatedly calling the involute_point() function from angles 0 degrees to the maximum angle as returned by function involute_angle() at the outer circle radius. The points are added to the tooth-side under construction just like the fillet arc above.
... // Calculate the maximum involute angle to intersect at the outside radius local max_a = involute_angle(base_diameter/2.0, outside_diameter/2.0); // Trace the involute arc from the base up to outside radius for(i = 0.0deg; i < max_a; i += __ang_step) { tooth += { involute_point(i, base_diameter/2.0)}; } if(i != max_a) { // Add the last point if we did not reach the outside radius tooth += { involute_point(max_a, base_diameter/2.0)}; } ...The for() loop makes use of gcmc's units and automatic conversions. The loop-variable "i" is specified in degrees, while the "max_a" variable is in radians. The for()-loop condition compares degrees with radians. Gcmc is able to perform correct angular comparison because units are specified on both "i" and "a_max".
Making a tooth, teeth and gear
The program up to now has created a single side of one tooth. The next step is to combine two sides into one whole tooth. The
"tooth" variable, used to collect the points of the tooth-side, is oriented in positive X direction and is along the X-axis. If the
first complete tooth is considered to be symmetrical at the positive X-axis, then the side must be rotated by "360 divided by four
times the number of teeth" degrees. The "four times" stems from a complete tooth comprising of both a high- and low-side, resulting
in two half-tooth-pitch sizes of two side each.
To complete one tooth, the current side must be mirrored over the X-axis. A mirror over X is the same as a scaling factor of -1 in Y and +1 in X direction. Combining the original and mirrored points requires the mirrored version to have all points reversed because the points need to flow in one direction.
The last part to make the gear outline complete is to copy the tooth as many times as there are teeth while rotating it as we go. The result is accumulated in the gear variable and returned from the function.
... // We now have one side of the tooth. Rotate to be at tooth-symmetry on X-axis tooth = rotate_xy(tooth, -90.0deg / nteeth); ...The above snippet will rotate the tooth-side CW by the correct angle.
To complete one tooth, the current side must be mirrored over the X-axis. A mirror over X is the same as a scaling factor of -1 in Y and +1 in X direction. Combining the original and mirrored points requires the mirrored version to have all points reversed because the points need to flow in one direction.
... // Add the same curve mirrored to make the other side of the tooth // Coordinates reverse to have them all in one direction only tooth += reverse(scale(tooth, [1, -1])); ...The scale() function scales each vector of "tooth" to produce a mirror-over-X copy and the reverse() functions reverses all points from the scaled/mirrored version. The resulting vector-list is concatenated with the original side to produce exactly one full tooth.
The last part to make the gear outline complete is to copy the tooth as many times as there are teeth while rotating it as we go. The result is accumulated in the gear variable and returned from the function.
... // Create all teeth of the gear by adding each tooth at correct angle local gear = {}; repeat(nteeth; i) { gear += rotate_xy(tooth, 360.0deg * i / nteeth); } return gear;
Finishing touches to make it work
The function gear_P() has now been fully developed and it returns a vector-list with all points of the outline. The outline needs to
be output using a simple trace() routine that will do just that. A second small function hole() is created to make the center-hole
of the gear. Finally calling it all with some parameters will give a nice set of gears.
The source of the gears example is available from the Gitlab gcmc repository as involute-gear.gcmc and involute-gear.inc.gcmc.
/* Trace a path at given offset */ function trace(path, offset) { goto(path[-1] + offset); foreach(path; v) { move(v + offset); } } /* Make a hole at center point with given radius */ function hole(point, radius) { goto(point - [radius]); circle_cw_r([radius, 0]); } /* -------------------- Main Program -------------------- */ HD = 6.0mm; // Gear center-hole diameter N = 9; // Number of teeth PA = 20.0deg; // Pressure angle D = 100.0mm; // Pitch diameter P = N/D; // Diametral pitch // First gear hole([D/2.0, 0.0mm], HD/2.0); trace(gear_P(N, PA, P), [D/2.0, 0.0mm]); // Second gear hole([-D/2.0, 0.0mm], HD/2.0); trace(gear_P(N, PA, P), [-D/2, 0.0mm]);
The source of the gears example is available from the Gitlab gcmc repository as involute-gear.gcmc and involute-gear.inc.gcmc.