Capıtulo 3 Complemento Engranajes UDEP

Capı́tulo 3
Complemento Engranajes UDEP
3.1. Complemento Engranajes UDEP
El objetivo de este capı́tulo es dar una explicación clara y sencilla de cómo crear un
complemento para SolidWorks 2010; de esta manera, los usuarios pueden disponer de una
guı́a básica que les ayude a realizar aplicaciones personalizadas para este software. El autor
quiere aclarar que la aplicación desarrollada en este capı́tulo sólo tiene carácter pedagógico,
y la complejidad de una interfaz gráfica queda descartada.
Engranajes UDEP es un complemento para el modelado sólido intuitivo de diversos tipos
de engranajes, y en esta primera versión sólo se ha implementado el algoritmo que permite
dibujar engranajes rectos con corrección de altura (ver Sección 1.6). A través de una interfaz
gráfica, el usuario podrá ingresar 6 parámetros: número de dientes, módulo, ángulo de
presión, coeficiente de corrección, factor de altura de cabeza del diente y factor de holgura
radial; que permitirán modelar un engranaje recto no estándar.
La forma en que se crea un proyecto ha sido descrita en la Sección 2.6, y es éste el proyecto
sobre el cual se han realizado las siguientes modificaciones; pero antes de ser mencionadas,
es importante conocer que el archivo principal del proyecto es SwAddin.cs (creado por
defecto), el cual presenta varias regiones (ver Figura 3.1) donde el código es agrupado, y
servirá como referencia para su ubicación en el desarrollo del complemento:
• Local Variables. Región que contiene la definición de los objetos de SolidWorks.
• SolidWorks Registration. Región donde se comprueba si el complemento es
compatible con la versión de SolidWorks instalada.
• ISwAddin Implementation.
Es la región en la cual las funciones miembro
ISwAddin::ConnectToSW e ISwAddin::DisconnectFromSW son implementadas. Estas
funciones son los puntos de acceso y salida al complemento.
78
• UI Methods. Región donde se agregan todas las funciones que tienen una tarea
especı́fica en el complemento.
• UI Callbacks. Región donde se implementan las funciones que realizarán tareas
especı́ficas encargadas por el usuario al complemento.
• Event Methods. Región que prepara el manejo de los eventos (intercambio de
información) entre SolidWorks y el complemento.
• Event Handlers. Región que contiene las devoluciones de llamada de eventos para los
objetos SolidWorks.
Figura 3.1: Regiones del archivo SwAddin.cs.
Las modificaciones se harán sobre el código fuente del archivo SwAddin.cs (sin
modificaciones) que se encuentra en el Anexo A.
1. Para cambiar el tı́tulo del menú se debe editar el archivo SwAddin.cs, buscando en la
región UI Methods la siguiente lı́nea:
157
string Title = "C# Addin", ToolTip = "C# Addin";
Cambiando “C# Addin” por “Engranajes UDEP”, la lı́nea 157 queda como se
muestra a continuación:
79
157
string Title = "Engranajes UDEP", ToolTip = "Engranajes UDEP";
Cuando se compila el resultado será el que se muestra en la Figura 3.2.
Figura 3.2: Menú Engranajes UDEP.
2. Para cambiar el nombre de los comandos (acciones) del menú Engranajes UDEP (ver
Figura 3.3) se debe modificar las lı́neas 172-173 dentro de la región UI Methods.
Figura 3.3: Comandos del menú Engranajes UDEP.
En las lı́neas 172-173 están definidos los 2 comandos que pertenecen al menú
Engranajes UDEP, declarados con las variables cmdIndex0 y cmdIndex1
respectivamente; para este caso, es de interés tener un solo comando cuya acción
sea abrir una ventana donde se puedan ingresar los datos necesarios para dibujar un
engranaje recto; para tal efecto, se modifica la lı́nea 172 estableciendo los parámetros
requeridos para la aplicación, y la lı́nea 173 simplemente se elimina ası́ como la
declaración de la variable cmdIndex1 dentro del proyecto.
172
173
cmdIndex0 = cmdGroup.AddCommandItem("CreateCube", -1, "Create a cube", "Create cube",
0, "CreateCube", "", 0);
cmdIndex1 = cmdGroup.AddCommandItem("Show PMP", -1, "Display sample property manager"
, "Show PMP", 2, "ShowPMP", "EnablePMP", 2);
El primer parámetro de la función miembro AddCommandItem, “CreateCube”,
asigna el tı́tulo al comando contenido dentro del menú Engranajes UDEP, el cual
es cambiado por “Engranajes rectos”. El sexto parámetro definido también
como “CreateCube” corresponde al nombre de la función que es ejecutada
cuando se da click sobre este comando, en este caso la función que se encargará
de activar la interfaz gráfica del complemento ha sido definida con el nombre
“CrearEngranajeRecto”. A continuación se muestra la lı́nea 172 modificada.
172
cmdIndex0 = cmdGroup.AddCommandItem("Engranajes rectos", 0, "Engranajes rectos", "
Engranajes rectos", 0, "CrearEngranajeRecto", "", 0);
Para el resto de parámetros de la función simplemente se les atribuye el mismo nombre
del comando.
80
3. Debido a que se ha eliminado la variable cmdIndex1 es necesario también hacerlo
con las funciones ShowPMP y EnablePMP, las cuales se encuentran implementadas
dentro de la región UI Callbacks, ası́ como la función CreateCube la cual era invocada
desde el comando cmdIndex0.
#region UI Callbacks
public void CreateCube()
{
//make sure we have a part open
string partTemplate = iSwApp.GetUserPreferenceStringValue((int)
swUserPreferenceStringValue_e.swDefaultTemplatePart);
IModelDoc2 modDoc = (IModelDoc2)iSwApp.NewDocument(partTemplate, (int)
swDwgPaperSizes_e.swDwgPaperA2size, 0.0, 0.0);
modDoc.InsertSketch2(true);
modDoc.SketchRectangle(0, 0, 0, .1, .1, .1, false);
//Extrude the sketch
IFeatureManager featMan = modDoc.FeatureManager;
featMan.FeatureExtrusion(true,
false, false,
(int)swEndConditions_e.swEndCondBlind, (int)swEndConditions_e.swEndCondBlind,
0.1, 0.0,
false, false,
false, false,
0.0, 0.0,
false, false,
false, false,
true,
false, false);
}
public void ShowPMP()
{
if (ppage != null)
ppage.Show();
}
public int EnablePMP()
{
if (iSwApp.ActiveDoc != null)
return 1;
else
return 0;
}
#endregion
Después de editar la región UI Callbacks quedará como se muestra a continuación.
#region UI Callbacks
public void CrearEngranajeRecto()
{
}
public void DibujarEngranajeCorreccionAltura(int dato1, double dato2, double dato3,
double dato4, double dato5, double dato6)
{
}
#endregion
La región UI Callbacks ahora contiene ahora 2 funciones: CrearEngranajeRecto y
81
DibujarEngranajeCorreccionAltura; la primera función tiene como finalidad mostrar
la interfaz gráfica del complemento y la segunda se encargará de realizar el modelado
sólido del engranaje recto no estándar cuando el usuario ası́ lo requiera. Como se
aprecia la segunda función posee 6 parámetros de entrada, los cuales corresponden
al número de dientes, módulo, ángulo de presión, coeficiente de corrección, factor
de altura de cabeza del diente y factor de holgura radial respectivamente; parámetros
necesarios para modelar un engranaje recto con corrección de altura. Al compilar y
ejecutar se tendrá lo que se muestra en la Figura 3.4.
Figura 3.4: Comando del menú Engranajes UDEP.
4. Para cambiar el icono del comando Engranajes rectos se ha editado el archivo de
imagen ToolbarSmall.bmp, el cual contiene ahora una imagen de un engranaje recto
de 16 x 16 pı́xeles. En la lı́nea 168, dentro de la región UI Methods está incluido
el archivo de imagen, que además se encuentra en la carpeta donde se ha creado el
proyecto. El resultado se muestra en la Figura 3.5.
168
cmdGroup.SmallIconList = iBmp.CreateFileFromResourceBitmap("Engranajes_UDEP.
ToolbarSmall.bmp", thisAssembly);
Figura 3.5: Icono modificado del comando Engranajes rectos.
Ahora las modificaciones que se describirán se aprecian en el archivo SwAddin.cs
(modificado), ubicado en la Sección A.2 del Anexo A.
5. Retornando a la región UI Callbacks, se muestra a continuación como se implementó
la función CrearEngranajeRecto. Esta función tiene como finalidad mostrar la interfaz
gráfica donde el usuario pueda realizar tareas como: dibujar un engranaje no estándar
y/o calcular y guardar sus parámetros geométricos. En la lı́nea 247 se declara el objeto
formularioPrincipal perteneciente a la clase Form1, esta clase se ha creado
cuando al proyecto se insertó un formulario.
245
246
247
248
249
public void CrearEngranajeRecto()
{
formularioPrincipal = new Form1();
formularioPrincipal.ShowDialog();
82
250
251
252
253
254
if (formularioPrincipal.button1_Click_Flag == true)
{
DibujarEngranajeRectoCorreccionAltura(formularioPrincipal.parametro1,
formularioPrincipal.parametro2, formularioPrincipal.parametro3,
formularioPrincipal.parametro4, formularioPrincipal.parametro5,
formularioPrincipal.parametro6);
}
}
Un formulario es una ventana que puede considerarse como un contenedor para los
controles; los controles son todos aquellos elementos gráficos que pueden formar parte
de una aplicación gráfica de Microsoft Windows como son: botones, cajas de diálogo
y de texto, cajas de selección desplegables, botones de opción y de selección, barras
de desplazamiento horizontales y verticales, gráficos, menús, etc. Para insertar un
formulario se ingresa al menú Project, luego a Add New Item. . . o gráficamente
como se muestra en la Figura 3.6 (dando click derecho sobre el nombre del proyecto).
Figura 3.6: Agregando un formulario al proyecto.
A continuación se muestra la ventana Add New Item (ver Figura 3.7), en ella se
selecciona la plantilla Windows Form para insertar un formulario al proyecto, el cual
es designado por defecto con el nombre Form1 (puede ser modificado pero en este
caso se conserva el nombre por defecto).
83
Figura 3.7: Ventana Add New Item.
Para agregar los controles al formulario es necesario activar el diálogo Toolbox (ir al
menú View y dar click sobre el comando Toolbox).
Figura 3.8: Diálogo Toolbox.
84
En la Figura 3.9 se muestran los tipos de controles empleados en el formulario.
Los controles son arrastrados con el cursor desde el diálogo Toolbox y posicionados
sobre el formulario.
En esta aplicación se han empleado 38 controles, los cuales son listados en la Tabla
3.1.
Tabla 3.1: Lista de controles empleados en el formulario Form1.
N◦
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Nombre
tabControl1
groupBox1
groupBox2
label1
label2
label3
label4
label5
label6
label7
label8
label9
label10
label11
label12
label13
label14
label15
label16
label17
label18
label19
label20
textBox1
textBox2
textBox3
textBox4
textBox5
textBox6
textBox7
textBox8
textBox9
textBox10
textBox11
textBox12
button1
button2
button3
Tipo
Control de tabulación
Caja agrupadora
Caja agrupadora
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Etiqueta
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Caja de texto
Botón de comando
Botón de comando
Botón de comando
Figura 3.9: Tipos de controles empleados en el formulario.
85
86
En la Figura 3.10 se enumeran los diferentes tipos de controles empleados en el
formulario, los cuales son listados en la Tabla 3.1.
Figura 3.10: Ubicación de los controles en el formulario.
Las propiedades de apariencia y funcionales de los controles pueden ser modificadas
en el Diálogo Properties (ir al menú View y dar click sobre el comando Properties
Window).
A continuación se listan las propiedades modificadas de los controles empleados en
este proyecto (ver Tabla 3.3).
Tabla 3.2: Propiedades modificadas de los controles.
Control
tabControl1
groupBox1
groupBox2
label1
label2
label3
label4
label5
Propiedad
Width
Height
Width
Height
Width
Height
Text
Text
Text
Text
Text
Valor
621
358
278
249
278
249
Número de dientes:
Módulo:
Ángulo de presión:
Factor de corrección:
Factor de altura de cabeza del diente:
87
label6
label7
label8
label9
label10
label11
label12
label13
label14
label15
label16
label17
label18
label19
label20
textBox7
textBox8
textBox9
textBox10
textBox11
textBox12
button1
button2
button3
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
ReadOnly
ReadOnly
ReadOnly
ReadOnly
ReadOnly
ReadOnly
Text
Text
Text
Factor de holgura radial:
mm
deg
Diámetro de paso:
Diámetro exterior:
Diámetro interior:
Diámetro de base:
Paso diametral:
Paso circular:
mm
mm
mm
mm
mm-̂1
mm
True
True
True
True
True
True
Dibujar Engranaje
Calcular Parámetros
Guardar Parámetros
Las propiedades modificadas en el formulario Form1 se muestran en la Tabla 3.3.
Tabla 3.3: Propiedades modificadas del formulario Form1.
Formulario
Form1
Propiedad
Maximumsize, Minimumsize (Width)
Maximumsize, Minimumsize (Height)
Text
Icon
Valor
655
420
Engranajes Rectos
archivo: ToolbarSmall.ico
Otra forma de cambiar las propiedades de un control es dar click derecho sobre él
y escoger la opción Properties, lo cual despliega el diálogo Properties. Dentro de
este diálogo se pueden alterar diferentes comportamientos del control, ası́ como su
apariencia.
En la Figura 3.11 se puede ver el diálogo Properties mostrando algunas de las
propiedades del formulario Form1.
88
Figura 3.11: Propiedades del formulario Form1.
Figura 3.12: Agregando una clase al proyecto.
6. Ahora es necesario crear una clase que calcule los parámetros geométricos del
engranaje recto no estándar, los cuales no sólo serán mostrados y se podrán guardar a
través de la interfaz gráfica, sino que además servirán como parámetros constructivos
para la modelación del engranaje.
Para insertar una clase al proyecto se ingresa al menú Project, luego se da
click sobre el comando Add Class..., lo cual mostrará una ventana como la
89
que se muestra en la Figura 3.12, estableciendo como nombre del archivo
EngranajeRectoCorreccionAltura.cs.
El archivo EngranajeRectoCorreccionAltura.cs se encuentra completo en la sección
A.4 del Anexo A. En este archivo se pueden identificar las siguientes partes:
• La definición de 13 datos miembro al inicio de la clase, los cuales representan
los parámetros geométricos fundamentales de un engranaje recto con corrección
de altura.
9
10
11
12
13
14
15
16
17
18
19
20
21
private
private
private
private
private
private
private
private
private
private
private
private
private
int numeroDientes;
double modulo;
double anguloPresion;
double factorCorreccion;
double factorAlturaCabeza;
double factorHolguraRadial;
double diametroPaso;
double diametroExterior;
double diametroInterior;
double diametroBase;
double pasoDiametral;
double pasoCircular;
double phi;
• Entre las lı́neas 23-44 se define e implementa la función miembro
calcularParametros que se encarga de calcular todos los parámetros geométricos
de un engranaje recto, los cuales son asignados a los datos miembro de la clase
definidos entre las lı́neas 9-21. Las fórmulas empleadas fueron definidas en la
Tabla 1.3.
23
24
25
26
27
28
29
30
31
32
33
34
35
public void calcularParametros(int parametro1, double parametro2, double
parametro3, double parametro4, double parametro5, double parametro6)
{
double alpha, gamma;
numeroDientes = parametro1;
modulo = parametro2;
anguloPresion = parametro3;
factorCorreccion = parametro4;
factorAlturaCabeza = parametro5;
factorHolguraRadial = parametro6;
diametroPaso = (modulo * numeroDientes);
diametroExterior = (modulo * (numeroDientes + 2 * factorAlturaCabeza +
2 * factorCorreccion));
diametroInterior = (modulo * (numeroDientes - 2 * (factorAlturaCabeza +
factorHolguraRadial - factorCorreccion)));
diametroBase = (modulo * numeroDientes * Math.Cos(anguloPresion * Math.
PI / 180));
pasoDiametral = 1 / modulo;
pasoCircular = Math.PI * modulo;
36
37
38
39
40
41
42
43
44
alpha = Math.Sqrt((Math.Pow(0.5 * diametroPaso, 2) - Math.Pow(0.5 *
diametroBase, 2)) / (Math.Pow(0.5 * diametroBase, 2))) - Math.Atan(
Math.Sqrt((Math.Pow(0.5 * diametroPaso, 2) - Math.Pow(0.5 *
diametroBase, 2)) / (Math.Pow(0.5 * diametroBase, 2))));
gamma = (Math.PI * modulo) / (diametroPaso);
phi = (Math.PI / numeroDientes) - (alpha + 0.5 * gamma);
}
90
Es importante mencionar lo que significa la variable phi. Esta variable tiene
como propósito situar a la evolvente en la posición correcta para que la sección de
corte se ubique sobre el eje y (la demostración de la ecuación se puede encontrar
en [5]).
• Entre las lı́neas 46-89 se definen e implementan funciones miembro que se
encargan de retornar los valores de los diferentes parámetros geométricos.
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
public int obtenerNumeroDientes()
{
return numeroDientes;
}
public double obtenerModulo()
{
return modulo;
}
public double obtenerDiametroPaso()
{
return diametroPaso;
}
public double obtenerDiametroExterior()
{
return diametroExterior;
}
public double obtenerDiametroInterior()
{
return diametroInterior;
}
public double obtenerDiametroBase()
{
return diametroBase;
}
public double obtenerPasoCircular()
{
return pasoCircular;
}
public double obtenerPasoDiametral()
{
return pasoDiametral;
}
public double obtenerPhi()
{
return phi;
}
7. El archivo Form1.cs contiene la definición e implementación de la clase Form1.
• Las acciones realizadas desde el formulario (dibujar, calcular y guardar) recaen
sobre los botones: button1, button2 y button3. Estas acciones son
programadas como funciones miembro de la clase Form1, para esto se da doble
click sobre el primer botón de la izquierda del formulario (Dibujar Engranaje),
91
esto abre el archivo Form1.cs que contiene la implementación de la clase e
inmediatamente se ubica sobre la función miembro button1 Click (el archivo
completo Form1.cs se encuentra en la Sección A.3 del Anexo A).
La función miembro button1 Click contendrá la acción que se ejecuta cuando se
presiona el botón button1 (Dibujar Engranaje).
private void button1_Click(object sender, EventArgs e)
{
}
• Entre las lı́neas 14-20 se definen 7 datos miembro, el primero es una variable
booleana llamada button1 Click Flag, esta variable cumplirá la tarea de un
interruptor; se inicializa con el valor false y se torna true cuando el usuario
ha presionado el botón button1 que indica que desea dibujar el engranaje.
Las otras 6 variables representan los parámetros que son requeridos en la caja
agrupadora groupBox1 del formulario Form1.
14
15
16
17
18
19
20
public
public
public
public
public
public
public
bool button1_Click_Flag = false;
int parametro1;
double parametro2;
double parametro3;
double parametro4;
double parametro5;
double parametro6;
• La función miembro Form1 es el constructor de la clase; se encarga de inicializar
el formulario, tornándolo a su estado inicial cuando se vuelve a requerir.
22
23
24
25
public Form1()
{
InitializeComponent();
}
• La función miembro button1 Click se ejecuta cuando el usuario presiona el botón
Dibujar Engranaje, en esta parte la variable booleana button1 Click Flag
toma el valor true, lo que indica que se debe ejecutar el modelado del sólido
a través de la función DibujarEngranajeRectoCorreccionAltura. Los parámetros
del 1 al 6 toman los valores que se encuentran contenidos en las cajas de texto de
la caja agrupadora groupBox1.
27
28
29
30
31
32
33
34
35
36
37
private void button1_Click(object sender, EventArgs e)
{
button1_Click_Flag = true;
parametro1 = Int32.Parse(textBox1.Text);
parametro2 = Double.Parse(textBox2.Text);
parametro3 = Double.Parse(textBox3.Text);
parametro4 = Double.Parse(textBox4.Text);
parametro5 = Double.Parse(textBox5.Text);
parametro6 = Double.Parse(textBox6.Text);
Form1.ActiveForm.Hide();
}
92
• Cuando el usuario desea ver los valores calculados de los parámetros geométricos
del engranaje recto no estándar, sólo tiene que presionar el control button2
que corresponde al botón Calcular Parámetros, esta acción invocará a la función
miembro Mostrar Resultados, la cual recibe los 6 parámetros necesarios para
calcular los restantes y mostrarlos inmediatamente en las respectivas cajas de
texto contenidas en la caja agrupadora groupBox1 (Parámetros calculados).
39
40
41
42
43
44
45
private void Mostrar_Resultados(int dato1, double dato2, double dato3,
double dato4, double dato5, double dato6)
{
EngranajeRectoCorreccionAltura datos = new
EngranajeRectoCorreccionAltura();
datos.calcularParametros(dato1, dato2, dato3, dato4, dato5, dato6);
textBox7.Text = Math.Round(datos.obtenerDiametroPaso(), 2).ToString();
textBox8.Text = Math.Round(datos.obtenerDiametroExterior(), 2).ToString
();
textBox9.Text = Math.Round(datos.obtenerDiametroInterior(), 2).ToString
();
textBox10.Text = Math.Round(datos.obtenerDiametroBase(), 2).ToString();
textBox11.Text = Math.Round(datos.obtenerPasoDiametral(), 2).ToString()
;
textBox12.Text = Math.Round(datos.obtenerPasoCircular(), 2).ToString();
46
47
48
49
50
52
53
54
55
}
private void button2_Click(object sender, EventArgs e)
{
Mostrar_Resultados(Int32.Parse(textBox1.Text), Double.Parse(textBox2.
Text), Double.Parse(textBox3.Text), Double.Parse(textBox4.Text),
Double.Parse(textBox5.Text), Double.Parse(textBox6.Text));
}
Dentro de la función Mostrar Resultados se crea el objeto datos (lı́nea 41),
perteneciente a la clase EngranajeRectoCorreccionAltura, el cual
tiene la finalidad de calcular los parámetros que se requieren para ser mostrados
en las cajas del texto.
• Finalmente la función miembro button3 Click se ejecuta cuando el usuario
presiona el botón Guardar Parámetros, el contenido de esta función se puede
apreciar en la Sección A.3 del Anexo A. Esta función se encarga de abrir una
hoja de cálculo Excel y escribir en ella los parámetros geométricos contenidos
en las cajas de texto de la caja agrupadora groupBox2. No se hará explı́cito
cómo programar este tipo de aplicación, por ser otro tipo de complemento para un
software diferente, y no se busca generar confusiones. Después de comprender la
esencia de la programación de complementos para SolidWorks, se puede explorar
lo mismo en otros softwares.
8. Retomando el archivo SwAddin.cs:
• En la función miembro CrearEngranajeRecto cuando la variable booleana
formularioPrincipal.button1 Click Flag toma el valor true se
ejecuta la función DibujarEngranajeRectoCorreccionAltura.
93
245
246
247
248
249
250
251
252
253
254
public void CrearEngranajeRecto()
{
Form1 formularioPrincipal = new Form1();
formularioPrincipal.ShowDialog();
if (formularioPrincipal.button1_Click_Flag == true)
{
DibujarEngranajeRectoCorreccionAltura(formularioPrincipal.parametro1
, formularioPrincipal.parametro2, formularioPrincipal.parametro3
, formularioPrincipal.parametro4, formularioPrincipal.parametro5
, formularioPrincipal.parametro6);
}
}
• La función DibujarEngranajeCorreccionAltura permite dibujar un
engranaje recto con corrección de altura y que además pone fin a la
implementación del complemento Engranajes UDEP. Con esta función los
engranajes rectos con corrección de altura son generados primero por la
extrusión-saliente de un cı́rculo, que tiene la medida del cı́rculo exterior, con una
profundidad de extrusión arbitraria, pudiendo ser modificada desde el entorno
SolidWorks. Luego sobre la cara frontal del cilindro generado se dibuja un
croquis que da forma al espaciamiento entre dientes; este croquis se crea a partir
de las envolventes que parten del cı́rculo base y terminan en el cı́rculo exterior, la
forma que tendrá el diente desde el cı́rculo base al cı́rculo interior es en este caso
la de un arco formado a partir de 3 puntos. Posteriormente, el croquis obtenido es
empleado en una extrusión-corte con profundidad pasante. Finalmente, la última
operación consiste en reproducir la extrusión-corte usando un patrón circular un
número de veces igual al número de dientes del engranaje.
En la Figura 3.13 se puede observar la secuencia de la modelación.
Figura 3.13: Modelación del engranaje recto.
94
• Entre las lı́neas 258-259 se define el objeto modDoc de la clase IModelDoc2,
la cual se hace cargo del entorno Pieza. En la lı́nea 260 se define el objeto
swFeatureMgr de la clase IFeatureManager, la cual toma a cargo las
Operaciones, mientras que en la lı́nea 261 se define el objeto swSketchMgr de
la clase ISketchManager, este objeto se encarga de manipular los comandos
de Croquis.
258
259
260
261
string partTemplate = iSwApp.GetUserPreferenceStringValue((int)
swUserPreferenceStringValue_e.swDefaultTemplatePart);
IModelDoc2 modDoc = (IModelDoc2)iSwApp.NewDocument(partTemplate, (int)
swDwgPaperSizes_e.swDwgPaperA2size, 0.0, 0.0);
IFeatureManager swFeatureMgr = modDoc.FeatureManager;
ISketchManager swSketchMgr = modDoc.SketchManager;
• A continuación se declaran 3 arrays de tipo double, los cuales han sido
nombrados como Pt1, Pt2 y Pt3, estas variables almacenarán los valores
que corresponden a las coordenadas de los puntos de las evolventes y de
la curva de se encuentra entre el cı́rculo base y el cı́rculo interior. En
la lı́nea 268 se declara el objeto Engranje perteneciente a las clase
EngranajeRectoCorreccionAltura, este objeto calcula los parámetros
necesarios para la modelación y los asigna a las variables respectivas (ver lı́neas
271-279).
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
int nPuntos = 100;
double[] Pt1 = new double[3 * nPuntos];
double[] Pt2 = new double[3 * nPuntos];
double[] Pt3 = new double[9];
EngranajeRectoCorreccionAltura Engranaje = new
EngranajeRectoCorreccionAltura();
Engranaje.calcularParametros(dato1, dato2, dato3, dato4, dato5, dato6);
int numeroDientes = Engranaje.obtenerNumeroDientes();
double radioPaso = Engranaje.obtenerDiametroPaso() / 2000;
double radioExterior = Engranaje.obtenerDiametroExterior() / 2000;
double radioInterior = Engranaje.obtenerDiametroInterior() / 2000;
double radioBase = Engranaje.obtenerDiametroBase() / 2000;
double phi = Engranaje.obtenerPhi();
double espesor = Engranaje.obtenerPasoCircular() / 2000;
double f = Math.PI / 180;
double theta = 0;
• Ahora se asignan los valores que corresponden a las coordenadas de los puntos
de la curva evolvente.
281
282
283
284
285
286
287
288
289
for (int i = 0; i <= nPuntos * 3 - 3; i = i + 3){
Pt1[i] = radioBase * Math.Sin(theta * f) - radioBase * (theta * f) *
Math.Cos(theta * f);
Pt1[i + 1] = radioBase * Math.Cos(theta * f) + radioBase * (theta *
f) * Math.Sin(theta * f);
Pt1[i + 2] = 0.0;
theta += 1;
}
for (int i = 0; i <= nPuntos * 3 - 3; i = i + 3){
Pt2[i] = Pt1[i] * Math.Cos(phi) + Pt1[i + 1] * Math.Sin(phi);
95
290
291
292
Pt2[i + 1] = -Pt1[i] * Math.Sin(phi) + Pt1[i + 1] * Math.Cos(phi);
Pt2[i + 2] = 0.0;
}
• A continuación se realiza la extrusión del cı́rculo de radio exterior, el cual se ha
dibujado sobre el plano Alzado.
294
295
296
297
modDoc.Extension.SelectByID2("Alzado", "PLANE", 0.0, 0.0, 0.0, false,
0, null, 0);
swSketchMgr.InsertSketch(true);
swSketchMgr.CreateCircle(0.0, 0.0, 0.0, radioExterior, 0.0, 0.0);
swFeatureMgr.FeatureExtrusion2(false, false, false, 0, 0, espesor,
espesor, false, false, false, false, 0.0, 0.0, false, false, false,
false, false, false, false, 0, 0.0, false);
Figura 3.14: Extrusión saliente.
• Entre las lı́neas 299-301 se definen 3 puntos, los cuales definirán la curva que
corresponde a la curva que se encuentra entre el cı́rculo base y el cı́rculo de
fondo.
299
300
301
Pt3[0] = -radioBase * Math.Sin(phi); Pt3[1] = radioBase * Math.Cos(phi)
; Pt3[2] = 0.0;
Pt3[3] = 0.0; Pt3[4] = radioInterior; Pt3[5] = 0.0;
Pt3[6] = radioBase * Math.Sin(phi); Pt3[7] = radioBase * Math.Cos(phi);
Pt3[8] = 0.0;
• Ahora se realiza la extrusión del corte del croquis constituido por 2 splines y 2
arcos (ver Figura 3.15).
303
304
305
306
307
308
309
modDoc.Extension.SelectByID2("Alzado", "PLANE", 0.0, 0.0, 0.0, false,
0, null, 0);
swSketchMgr.InsertSketch(true);
swSketchMgr.CreateCircle(0.0, 0.0, 0.0, radioExterior, 0.0, 0.0);
swSketchMgr.CreateCircle(0.0, 0.0, 0.0, radioBase, 0.0, 0.0);
swSketchMgr.CreateConstructionGeometry();
swSketchMgr.CreateLine(0, 0, 0, 0, radioExterior + 0.01, 0);
swSketchMgr.CreateConstructionGeometry();
96
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
swSketchMgr.CreateCircle(0.0, 0.0, 0.0, radioInterior, 0.0, 0.0);
swSketchMgr.CreateConstructionGeometry();
swSketchMgr.CreateSpline(Pt2);
modDoc.Extension.SelectByID2("Arco1", "SKETCHSEGMENT", 0.0, 0.0, 0.0,
false, 0, null, 0);
modDoc.Extension.SelectByID2("Spline1", "SKETCHSEGMENT", 0.0, 0.0, 0.0,
true, 0, null, 0);
swSketchMgr.SketchTrim((int)swSketchTrimChoice_e.swSketchTrimClosest,
Pt2[(nPuntos * 3 - 1) - 2], Pt2[(nPuntos * 3 - 1) - 1], 0);
modDoc.ClearSelection2(true);
modDoc.Extension.SelectByID2("Spline1", "SKETCHSEGMENT", 0.0, 0.0, 0.0,
false, 0, null, 0);
modDoc.Extension.SelectByID2("Lı́nea1", "SKETCHSEGMENT", 0.0, 0.0, 0.0,
true, 2, null, 0);
modDoc.SketchMirror();
modDoc.ClearSelection2(true);
modDoc.Extension.SelectByID2("Spline1", "SKETCHSEGMENT", 0.0, 0.0, 0.0,
false, 0, null, 0);
modDoc.Extension.SelectByID2("Spline2", "SKETCHSEGMENT", 0.0, 0.0, 0.0,
true, 0, null, 0);
modDoc.Extension.SelectByID2("Arco1", "SKETCHSEGMENT", 0.0, 0.0, 0.0,
true, 0, null, 0);
swSketchMgr.SketchTrim((int)swSketchTrimChoice_e.swSketchTrimClosest,
radioExterior, 0, 0);
modDoc.ClearSelection2(true);
swSketchMgr.Create3PointArc(Pt3[0], Pt3[1], Pt3[2], Pt3[6], Pt3[7], Pt3
[8], Pt3[3], Pt3[4], Pt3[5]);
swFeatureMgr.FeatureCut3(false, false, false, 0, 0, espesor, espesor,
false, false, false, false, 0.0, 0.0, false, false, false, false,
false, false, false, false, false, false, 0, 0.0, false);
modDoc.ForceRebuild3(true);
Figura 3.15: Extrusión del corte.
97
• Ahora se define un eje con la intersección de los planos Vista lateral y Alzado.
330
331
332
333
modDoc.Extension.SelectByID2("Vista lateral", "PLANE", 0.0, 0.0, 0.0,
false, 0, null, 0);
modDoc.Extension.SelectByID2("Superior", "PLANE", 0.0, 0.0, 0.0, true,
0, null, 0);
modDoc.InsertAxis2(true);
modDoc.ForceRebuild3(true);
• Finalmente se realiza el patrón circular del corte, reproduciéndolo alrededor del
eje tantas veces como la variable numeroDientes lo indique.
335
336
337
338
modDoc.Extension.SelectByID2("Cortar-Extruir1", "BODYFEATURE", 0.0,
0.0, 0.0, false, 4, null, (int)swSelectOption_e.
swSelectOptionDefault);
modDoc.Extension.SelectByID2("Eje1", "AXIS", 0.0, 0.0, 0.0, true, 1,
null, (int)swSelectOption_e.swSelectOptionDefault);
swFeatureMgr.FeatureCircularPattern2(numeroDientes, 360 * f /
numeroDientes, false, "NULL", false);
modDoc.ForceRebuild3(true);
Figura 3.16: Patrón circular del corte.
98