Índice:1. Introducción

2. Cálculos

2.1. Cálculo de posiciones

2.2. Cálculo de velocidades

2.3. Cálculo de aceleraciones

3. Cálculo de fuerzas y torque

4. Conclusiones

1. Introducción:

El mecanismo que fue asignado para la posterior simulación en MATLAB, es el siguiente:

Figura 1.1.

Como se puede observar, este mecanismo cuenta con los siguientes elementos:

Primero la barra 2, O2A, que es a la cual se le aplican las velocidades y aceleraciones angulares iniciales.

Gracias a que conocemos ambos y los datos geométricos (todos son pedidos al inicio), se puede designar y conocer el punto A y todos sus parámetros cinemáticos con un simple cálculo, que se verá más adelante.

Luego sigue la barra 3, la cual se encuentra conectada directamente con la 2, y por ende, el cálculo de los parámetros cinemáticos dependerá de los parámetros del punto A.

En este punto, también cabe mencionar que el movimiento de la barra 3 se verá claramente limitado por la distancia en “y” del elemento 5, como de la distancia fija en el eje “x” del elemento 6.

Seguimos con la barra 4, la cual está conectada directamente con la 3, y por ende sucede lo mismo que se ha explicado en el punto superior; sus parámetros cinemáticos serán dependientes. Y también cabe resaltar que debe cumplir con que la longitud en “x” del elemento 6 se mantenga constante.

Por último, los elementos que se comportan como deslizaderas (el 5 y el 6). Ambos tienen la característica que restringen el movimiento en un eje; el 5 lo restringe en el eje “y” y el 6 en el eje “x”.

No tomaremos en cuenta los pesos, ya que estos están en el plano z y tomaremos el mecanismo en el ‘xy’.

2. Cálculos:

Primero, se calcularán los grados de libertad, aplicando el criterio Grübler:

G=3∗(N−1 )−2∗P I−P II

Y como era de esperarse, se obtuvo de dos grados de libertad.

2.1. Cálculo de posiciones:

Luego se deben empezar los cálculos, y esto se verá al mismo tiempo que se avance con el programa hecho en MATLAB:

Primero se deben definir las restricciones geométricas de nuestro mecanismo, las cuales son las distancias fijas de las deslizaderas respecto al punto fijo O2:

%Trabajo curso Teoría de Máquinas 2013-II%Ejercicio asignado; Estremadoyro Ruiz, Jorge Augusto%Cálculo de posicionesclcclear allclose all%Como no tenemos datos geométricos, los pediréO2A=input('Ingresar la longitud de la barra O2A:');BD=input('Ingresar la longitud de la barra BD:');AB=input('Ingresar la longitud de la barra AB:');

BC=input('Ingresar la longitud de la barra BC:');AC=AB+BC;disp('Para fijar los puntos yC y xD necesitamos valores iniciales de phi1, phi2 y phi3')phi1=input('Ingresar el valor inicial del ángulo formado por la barra 02A y la horizontal: ');phi2=input('Ingresar el valor inicial del ángulo formado por la barra AC y la horizontal: ');phi3=input('Ingresar el valor inicial del ángulo formado por la barra BD y la horizontal: ');xO2=0;yO2=0;xA=O2A*cos(phi1);yA=O2A*sin(phi1);xB=xA+AB*cos(phi2);yB=yA-AB*sin(phi2);xD=xB+BD*cos(phi3);yD=yB+BD*sin(phi3);xC=xA+(AB+BC)*cos(phi2);yC=yA-(AB+BC)*sin(phi2);

Ahora, y cuando ya se tienen los parámetros geométricos bien definidos, estos se mostrarán en pantalla para luego empezar con el programa para graficar el movimiento:

%Las dimensiones xD y yC serán siempre constantesfprintf('Coordenada y del punto C = %g (m) \n', yC);fprintf('Coordenada x del punto D = %g (m) \n', xD);disp('Las coordenadas "x" del punto D como la "y" del punto C siempre serán constantes')%Ahora comenzamos con los cálculos, conociendo yC y xDpaso=pi/180;xCref=xC;yDref=yD;

Antes de proseguir, cabe resaltar que en este punto, se debe tener dos funciones auxiliares, que son ‘lincir’ y ‘distMinima’. Ambas se encuentran al final de este documento, y fueron las entregadas por el Ingeniero Miguel Castro, pero se intentará dar una explicación rápida de ambas:

La función ‘lincir’ sirve para hallar la intersección de una línea con una circunferencia. Para esta función, se debe tener en cuenta que los dos primeros elementos solicitados por la función son las componentes en ‘x’ y en ‘y’ de un punto de la línea a intersectar con el círculo.

Los dos siguientes son componentes en ‘x’ y en ‘y’ del 2do punto necesario para definir la recta. Los últimos 3 puntos son las coordenadas en ‘x’ y en ‘y’ del centro de la circunferencia a intersectar con el radio.

Al entregarle todo esto a la función, ésta nos devuelve dos posibles respuestas, ya que al intersectar una línea y un círculo tendremos dos puntos de intersección.

Ahí es donde entra la siguiente función mencionada. Entonces, pues, la función ‘distMinima’ sirve para calcular la distancia mínima entre dos puntos, y así, ya que se tienen dos posibles respuestas, poder elegir la óptima para nuestro trabajo.

Figura 1.2

Se puede observar que para definir la deslizadera 5, bastará conocer el punto A (que ya ha sido hallado antes), el radio AC, y la línea horizontal por la que desliza C (que ha sido hallado geométricamente al dar los valores iniciales).

Así, y con las funciones antes mencionadas, se tendrá el siguiente código para hallar las posiciones desconocidas:

for I=phi1:paso:phi1+2*pi xA=O2A*cos(I); yA=O2A*sin(I);

%Para el cálculo de la posición de la barra 5

[ xC1,yC1,xC2,yC2 ] = lincir( 0,yC,O2A+AC,yC,xA,yA,AC ); %Ahora tomamos el punto más cercano [ xC,yC ] = distMinima( xCref,yC,xC1,yC1,xC2,yC2);

Figura 1.3

Ahora se hará el mismo análisis con la deslizadera 6, la cual se puede encontrar al intersectar la línea vertical por la cual desliza y un círculo con centro en B y radio BD.

%Para el cálculo de la posición de la barra 6 [ xD1,yD1,xD2,yD2 ] = lincir( xD,yC,xD,yC+BD+BC,xB,yB,BD ); %Ahora tomamos el punto más cercano [ xD,yD ] = distMinima( xD,yDref,xD1,yD1,xD2,yD2);

Luego, el mecanismo se graficará de la siguiente manera:

figure(1); hold off plot([xO2,xA,xB,xC],[yO2,yA,yB,yC],'b-o');hold on plot([xB,xD],[yB,yD],'b-o');hold on title('Simulación de las posiciones') xlabel('x (m)') ylabel('y (m)') axis([-0.1 0.90 -0.4 0.5]); grid

%Se actualiza la refrencia a la última coordenada calculada xCref=xC; yDref=yD; yB=(yA+yC)/2; xB=(xA+xC)/2; pause(0.01) end

Por último, se tendrán las siguientes gráficas como simulación de las posiciones:

Gráfica 1.1. Estado inicial del mecanismo

Gráfica 1.2. Posición intermedia del mecanismo

2.2. Cálculo de velocidades

En este punto, se debe calcular nuevamente los puntos iniciales. Pero como este proceso ya ha sido desarrollado con anterioridad, no se explicará detalladamente.

Solo vale la pena tomar en cuenta que ahora también se pedirá el valor de la velocidad angular de la barra2 y la teoría estudiada en clase tendrá que ser aplicada para poder calcular las velocidades en los diversos puntos requeridos.

Se sabe que:

B A BA

V V w x r

Así, se debe empezar desde el punto O2, el cual tiene velocidad igual a 0, para luego extenderse a todos los puntos solicitados.

El código utilizado para lograrlo es el siguiente:

%Trabajo curso Teoría de Máquinas 2013-II%Ejercicio asignado; Estremadoyro Ruiz, Jorge Augusto%Cálculo de velocidadesclc clear all close all %DATOS INICIALESO2A=input('Ingresar la longitud de la barra O2A:');BD=input('Ingresar la longitud de la barra BD:');AB=input('Ingresar la longitud de la barra AB:');BC=input('Ingresar la longitud de la barra BC:');AC=AB+BC;om2=input('Ingresar el valor de la velocidad angular de la barra 2: ');disp('Para fijar los puntos yC y xD necesitamos valores iniciales de phi1, phi2 y phi3')phi1=input('Ingresar el valor inicial del ángulo formado por la barra 02A y la horizontal: ');phi2=input('Ingresar el valor inicial del ángulo formado por la barra AC y la horizontal: ');phi3=input('Ingresar el valor inicial del ángulo formado por la barra BD y la horizontal: ');xA=O2A*cos(phi1);yA=O2A*sin(phi1);xB=xA+AB*cos(phi2);yB=yA-AB*sin(phi2);xD=xB+BD*cos(phi3);yD=yB+BD*sin(phi3);xC=xA+(AB+BC)*cos(phi2);yC=yA-(AB+BC)*sin(phi2);omega2=[0, 0, om2];%Las dimensiones xD y yC serán siempre constantesfprintf('Coordenada y del punto C = %g (m) \n', yC);fprintf('Coordenada x del punto D = %g (m) \n', xD);disp('Las coordenadas "x" del punto D como la "y" del punto C siempre serán constantes')

Luego, se colocarán los puntos iniciales para comenzar con el proceso de cálculo (el paso, los puntos iniciales de referencia, etc) y la variable “J” será definifa, para poder iniciar el bucle y almacenar los valores de cada iteración desde J=1 hasta el valor predefinido en nuestro ‘for’.

%Ahora comenzamos con los cálculos, conociendo yC y xDpaso=pi/180;xCref=xC;yDref=yD;J=1;

Ahora, se debe tener en cuenta que se tendrá la necesidad de “nombrar” ciertas variables simbólicas que utilizaremos en nuestros bucles antes de iniciarlos, así, se tendrá:

%variable simbólicas para el eslabón 3omega3z = sym('omega3z','real');vCx = sym('vCx','real');%variable simbólicas para el eslabón 4omega4z = sym('omega4z','real');vDy = sym('vDy','real'); for I=phi1:paso:phi1+2*pi %Almacenar los ángulos ang(J)=I; xA=O2A*cos(I); yA=O2A*sin(I); %Para el cálculo de la posición de la barra 5 [ xC1,yC1,xC2,yC2 ] = lincir( 0,yC,O2A+AC,yC,xA,yA,AC ); %Ahora tomamos el punto más cercano [ xC,yC ] = distMinima( xCref,yC,xC1,yC1,xC2,yC2); %Para el cálculo de la posición de la barra 6 [ xD1,yD1,xD2,yD2 ] = lincir( xD,yC,xD,yC+BD+BC,xB,yB,BD ); %Ahora tomamos el punto más cercano [ xD,yD ] = distMinima( xD,yDref,xD1,yD1,xD2,yD2); %Contrucción de los vectores posición rA=[xA, yA, 0]; rB=[xB, yB, 0]; rC=[xC, yC, 0]; rD=[xD, yD, 0]; vO2=[0, 0, 0 ]; %en m/s

Luego:vA=vO2+w2∗rA /O2

Y esto, en lenguaje MATLAB, será: %Cálculo de la velocidad en A vA(J,:) = vO2 + cross(omega2,rA); vAmod(J)=norm(vA(J,:));

De la misma manera, se hallará la velocidad en el punto C:

vc=v A+w3∗rC /A

%cálculo de la velocidad en C %Para esto es necesario crear dos variable simbólicas cuya declaración %se pone fuera del for porque se hace una sola vez Omega3 = [ 0 0 omega3z ];

VC = [ vCx 0 0 ]; %Se usa la ecuación vC = vB + ?2×(rC ?rB) que en Matlab es eqvC = VC - (vA(J,:) + cross(Omega3,rC-rA)); %como la ecuación anterior es vectorial la convertimos en dos %algebraicas eqvCx = eqvC(1); % Ecuación en X eqvCy = eqvC(2); % Ecuación en Y solvC = solve(eqvCx,eqvCy); omega3zs = eval(solvC.omega3z); vCxs = eval(solvC.vCx); omega3(J,:) = [0, 0, omega3zs]; omega3mod(J)=norm(omega3(J,:)); vC(J,:) = [vCxs, 0, 0]; vCmod(J)=norm(vC(J,:)); vB(J,:) = vA(J,:) + cross(omega3(J,:),rB-rA); vBmod(J) = norm(vB(J,:));

Continuando con los puntos requeridos para un posterior cálculo de las aceleraciones angulares y lineales, se hará lo mismo con el punto D:

vD=v B+w4∗rD /B

%Cálculo de la velocidad en D %Para esto es necesario crear dos variable simbólicas cuya declaración %se pone fuera del for porque se hace una sola vez Omega4 = [ 0 0 omega4z ]; VD = [ 0 vDy 0 ]; %Se usa la ecuación vC = vB + ?2×(rC ?rB) que en Matlab es eqvD = VD - (vB(J,:) + cross(Omega4,rD-rB)); %como la ecuación anterior es vectorial la convertimos en dos %algebraicas eqvDx = eqvD(1); % Ecuación en X eqvDy = eqvD(2); % Ecuación en Y solvD = solve(eqvDx,eqvDy); omega4zs = eval(solvD.omega4z); vDys = eval(solvD.vDy); omega4(J,:) = [0, 0, omega4zs]; omega4mod(J)=norm(omega4(J,:)); vD(J,:) = [vDys, 0, 0]; vDmod(J)=norm(vD(J,:)); J=J+1;End

Y posteriormente se procede a graficar las respuestas:

figure(1); plot(ang*180/pi,vAmod); title('Modulo de la velocidad en A') xlabel('Angulo \phi (Grados)') ylabel('Velocidad (m/s)') grid figure(2); plot(ang*180/pi,vCmod); title('Modulo de la velocidad en C') xlabel('Angulo \phi (Grados)') ylabel('Velocidad (m/s)') grid figure(3); plot(ang*180/pi,omega3mod); title('Modulo de la velocidad angular en la barra3') xlabel('Angulo \phi (Grados)') ylabel('Velocidad angular (rad/s)') grid figure(4); plot(ang*180/pi,vDmod); title('Modulo de la velocidad en D') xlabel('Angulo \phi (Grados)') ylabel('Velocidad (m/s)') grid figure(5); plot(ang*180/pi,omega4mod); title('Modulo de la velocidad angular en la barra4') xlabel('Angulo \phi (Grados)') ylabel('Velocidad angular (rad/s)') grid

Para obtener las gráficas de velocidades en varios puntos del mecanismo estudiado, mostradas en la siguiente hoja.

2.3. Cálculo de aceleraciones:

Para este apartado se debe recordar la teoría tratada en las clases teóricas. Así, para una aceleración, se encontrará como fórmula general la siguiente (si el mecanismo no experimenta una aceleración de Coriolis, como es el caso con el mecanismo tratado):

B A B BA A

A A x r w x w x r

Nuevamente, esta parte es repetida. Así que no se tocará a detalle y solo será colocado el código.

%Trabajo curso Teoría de Máquinas 2013-II%Ejercicio asignado; Estremadoyro Ruiz, Jorge Augusto%Cálculo de aceleracionesclear all clc close all %DATOS INICIALESO2A=input('Ingresar la longitud de la barra O2A:');

BD=input('Ingresar la longitud de la barra BD:');AB=input('Ingresar la longitud de la barra AB:');BC=input('Ingresar la longitud de la barra BC:');AC=AB+BC;om2=input('Ingresar el valor de la velocidad angular de la barra 2: ');al2=input('Ingresar el valor de la aceleración angular de la barra 2: ');disp('Para fijar los puntos yC y xD necesitamos valores iniciales de phi1, phi2 y phi3')phi1=input('Ingresar el valor inicial del ángulo formado por la barra 02A y la horizontal: ');phi2=input('Ingresar el valor inicial del ángulo formado por la barra AC y la horizontal: ');phi3=input('Ingresar el valor inicial del ángulo formado por la barra BD y la horizontal: ');xO2=0;yO2=0;xA=O2A*cos(phi1);yA=O2A*sin(phi1);xB=xA+AB*cos(phi2);yB=yA-AB*sin(phi2);xD=xB+BD*cos(phi3);yD=yB+BD*sin(phi3);xC=xA+(AB+BC)*cos(phi2);yC=yA-(AB+BC)*sin(phi2);omega2=[0, 0, om2];alpha2=[0, 0, al2];%Las dimensiones xD y yC serán siempre constantesfprintf('Coordenada y del punto C = %g (m) \n', yC);fprintf('Coordenada x del punto D = %g (m) \n', xD);disp('Las coordenadas "x" del punto D como la "y" del punto C siempre serán constantes') Paso=pi/180;xCref=xC;yDref=yD;J=1;%variable simbólicas para el eslabón 3: Velocidadomega3z = sym('omega3z','real');vCx = sym('vCx','real');%variable simbólicas para el eslabón 3: Aceleraciónalpha3z=sym('alpha3z','real');aCx=sym('aCx','real');%variable simbólicas para el eslabón 4: Velocidadomega4z = sym('omega4z','real');vDy = sym('vDy','real');%variable simbólicas para el eslabón 4: Aceleraciónalpha4z=sym('alpha4z','real');aDy=sym('aDy','real'); for I=phi1:Paso:phi1+2*pi %Almacenar los ángulos ang(J)=I; xA=O2A*cos(I); yA=O2A*sin(I);

%Para el cálculo de la posición de la barra 5 [ xC1,yC1,xC2,yC2 ] = lincir( 0,yC,O2A+AC,yC,xA,yA,AC ); %Ahora tomamos el punto más cercano [ xC,yC ] = distMinima( xCref,yC,xC1,yC1,xC2,yC2); %Para el cálculo de la posición de la barra 6 [ xD1,yD1,xD2,yD2 ] = lincir( xD,yC,xD,yC+BD+BC,xB,yB,BD ); %Ahora tomamos el punto más cercano [ xD,yD ] = distMinima( xD,yDref,xD1,yD1,xD2,yD2); %Contrucción de los vectores posición rA=[xA, yA, 0]; rB=[xB, yB, 0]; rC=[xC, yC, 0]; rD=[xD, yD, 0]; vO2=[0, 0, 0 ]; %en m/s

Como se puede observar de la fórmula puesta anteriormente, hay la necesidad de tener las velocidades para poder hallar nuestras aceleraciones. Por ello se repetirá el código de las velocidades:

%Cálculo de la velocidad en A vA(J,:) = vO2 + cross(omega2,rA); vAmod(J)=norm(vA(J,:)); %cálculo de la velocidad en C %Para esto es necesario crear dos variable simbólicas cuya declaración %se pone fuera del for porque se hace una sola vez Omega3 = [ 0 0 omega3z ]; VC = [ vCx 0 0 ]; %Se usa la ecuación vC = vB + ?2×(rC ?rB) que en Matlab es eqvC = VC - (vA(J,:) + cross(Omega3,rC-rA)); %como la ecuación anterior es vectorial la convertimos en dos %algebraicas eqvCx = eqvC(1); % Ecuación en X eqvCy = eqvC(2); % Ecuación en Y solvC = solve(eqvCx,eqvCy); omega3zs = eval(solvC.omega3z); vCxs = eval(solvC.vCx); omega3(J,:) = [0, 0, omega3zs]; omega3mod(J)=norm(omega3(J,:)); vC(J,:) = [vCxs, 0, 0]; vCmod(J)=norm(vC(J,:));

Posteriormente, y con los valores de las velocidades se procede a calcular las aceleraciones necesarias, siguiendo la misma lógica que fue utilizada en las velocidades. Esto es, que se partirá del punto O2, cuya aceleración es 0, y al conocer las

velocidades angulares, y resolver las 2 ecuaciones con 2 incógnitas que se nos presentan en cada barra, se pueden hallar las aceleraciones lineales y angulares.

%Cálculo de la aceleración en A aO2 = [0 0 0 ]; aA(J,:) = aO2 + cross(alpha2,rA) - dot(omega2,omega2)*rA; aAmod(J)=norm(aA(J,:));

Posteriormente repetimos el método mencionado hasta hallar todas las aceleraciones angulares y lineales requeridas en el programa.

Como recomendación, podemos comentar que debemos tener cuidado al momento de colocar los vectores posición. Hay que tener claro cuál es el sentido de éstos.

%cálculo de la velocidad en C %Para esto es necesario crear dos variable simbólicas cuya declaración %se pone fuera del for porque se hace una sola vez Omega3 = [ 0 0 omega3z ]; VC = [ vCx 0 0 ]; %Se usa la ecuación vC = vB + ?2×(rC ?rB) que en Matlab es eqvC = VC - (vA(J,:) + cross(Omega3,rC-rA)); %como la ecuación anterior es vectorial la convertimos en dos %algebraicas eqvCx = eqvC(1); % Ecuación en X eqvCy = eqvC(2); % Ecuación en Y solvC = solve(eqvCx,eqvCy); omega3zs = eval(solvC.omega3z); vCxs = eval(solvC.vCx); omega3(J,:) = [0, 0, omega3zs]; omega3mod(J)=norm(omega3(J,:)); vC(J,:) = [vCxs, 0, 0]; vCmod(J)=norm(vC(J,:)); %Cálculo de la aceleración en C Alpha3 = [ 0 0 alpha3z ]; % alpha3z no se conoce A_C = [aCx 0 0 ]; % aCx no se conoce eqaC=A_C-(aA(J,:)+cross(Alpha3,rC-rA)-dot(omega3(J,:),omega3(J,:))*(rC-rA)); eqaCx = eqaC(1); % Ecuación en X eqaCy = eqaC(2); % Ecuación en Y solaC = solve(eqaCx,eqaCy); alpha3zs=eval(solaC.alpha3z); aCxs=eval(solaC.aCx); alpha3(J,:) = [0 0 alpha3zs]; alpha3mod(J)=norm(alpha3(J,:));

aC(J,:) = [aCxs 0 0]; aCmod(J)=norm(aC(J,:)); %Cálculo de la velocidad en B vB(J,:) = vA(J,:) + cross(omega3(J,:),rB-rA); vBmod(J) = norm(vB(J,:)); %Cálculo de la aceleración en B aB(J,:) = aA(J,:) + cross(alpha3(J,:),rB-rA) - dot(omega3(J,:),omega3(J,:))*(rB-rA); aBmod(J)=norm(aB(J,:)); %Cálculo de la velocidad en D %Para esto es necesario crear dos variable simbólicas cuya declaración %se pone fuera del for porque se hace una sola vez Omega4 = [ 0 0 omega4z ]; VD = [ 0 vDy 0 ]; %Se usa la ecuación vC = vB + ?2×(rC ?rB) que en Matlab es eqvD = VD - (vB(J,:) + cross(Omega4,rD-rB)); %como la ecuación anterior es vectorial la convertimos en dos %algebraicas eqvDx = eqvD(1); % Ecuación en X eqvDy = eqvD(2); % Ecuación en Y solvD = solve(eqvDx,eqvDy); omega4zs = eval(solvD.omega4z); vDys = eval(solvD.vDy); omega4(J,:) = [0, 0, omega4zs]; omega4mod(J)=norm(omega4(J,:)); vD(J,:) = [vDys, 0, 0]; vDmod(J)=norm(vD(J,:)); %Cálculo de la aceleración en D Alpha4 = [ 0 0 alpha4z ]; % alpha3z no se conoce A_D = [0 aDy 0 ]; % aCx no se conoce eqaD=A_D-(aB(J,:)+cross(Alpha4,rD-rB)-dot(omega4(J,:),omega4(J,:))*(rD-rB)); eqaDx = eqaD(1); % Ecuación en X eqaDy = eqaD(2); % Ecuación en Y solaD = solve(eqaDx,eqaDy); alpha4zs=eval(solaD.alpha4z); aDys=eval(solaD.aDy); alpha4(J,:) = [0 0 alpha4zs]; alpha4mod(J)=norm(alpha4(J,:)); aD(J,:) = [0 aDys 0]; aDmod(J)=norm(aD(J,:)); J=J+1;End

Cuando se terminan las iteraciones y se hallan las aceleraciones tanto angulares como lineales, se procede a graficarlas de la siguiente manera:

figure(1); plot(ang*180/pi,aAmod); title('Módulo de la aceleración en A') xlabel('Angulo \phi (Grados)') ylabel('Aceleración (m/s2)') grid figure(2); plot(ang*180/pi,aCmod); title('Modulo de la aceleración en C') xlabel('Angulo \phi (Grados)') ylabel('Aceleración (m/s2)') grid figure(3); plot(ang*180/pi,aDmod); title('Modulo de la aceleración en D') xlabel('Angulo \phi (Grados)') ylabel('Aceleración (m/s2)') grid figure(4); plot(ang*180/pi,alpha3mod); title('Modulo de la aceleración angular en la barra3') xlabel('Angulo \phi (Grados)') ylabel('Aceleración angular (rad/s2)') grid figure(5); plot(ang*180/pi,alpha4mod); title('Modulo de la aceleración angular en la barra4') xlabel('Angulo \phi (Grados)') ylabel('Aceleración angular (rad/s2)') grid

Así, se obtendrán las gráficas mostradas en las siguientes caras, con la leyenda respectiva para una fácil interpretación y lectura de las variables.

3. Cálculo de fuerzas y torque Para que se pueda tener esta velocidad en la barra 1 debe haber una energía que le otorgue el movimiento. En este caso la energía mencionada es un torque aplicado por un pequeño motor.

Ahora, como puede ser observado, el problema principal es qué motor se debe elegir para accionar este elemento, así como a qué esfuerzos estarán sometidos los pines conectores de las barras. Todo esto es muy importante y necesario para hacer un óptimo diseño del mecanismo en general.

Para empezar hay que tener claro de qué datos se dispone para resolver el problema planteado. En los apartados anteriores se calcularon las aceleraciones, angulares de las barras y lineales de los pines de conexión. Ahora lo primordial es hallar las aceleraciones lineales de los centros de gravedad, para poder aplicar el principio de D’Alembert. Este principio, aplicado al problema propuesto, se puede resumir en lo siguiente:

Si se posee un elemento cuyo centro de gravedad se encuentra sometido a una aceleración angular y lineal, éstas se pueden reemplazar por un momento y fuerza respectivamente, de magnitud proporcional pero sentido

contrario. Así, al multiplicar la aceleración lineal del C.G. por la masa de ésta barra y la inercia de la misma con la aceleración angular, se encontrarán el momento y la fuerza mencionados.

Para este caso, se han asignado el valor de las masas como sigue a continuación:

Masa barra O2A: 2 kg Masa barra AC: 10 kg Masa barra BD: 8 kg Masa elemento D: 1 kg Masa elemento C: 1 kg

Por lo tanto las inercias se calcularán de la siguiente manera:

22 2 2

1

12O A O A O AI m xL

2

2

1

121

12

AC AC AC

BD BD BD

I m xL

I m xL

El siguiente paso importante a tomar es el de encontrar las aceleraciones en los centros de gravedad. Estas aceleraciones se hallarán de la misma manera que las aceleraciones en las juntas fueron halladas, anteriormente, solo que ahora variará la distancia. A continuación un ejemplo ilustrativo:

Figura 3.1. Barra 2.

En este elemento, y como en todos los del problema planteado, el centro de gravedad se encuentra en el punto central de la barra. Por lo que la ecuación para hallar la velocidad quedará de la siguiente manera:

2 2 2 22 2

CGbarra O CGbarra CGbarraO O

A A x r w x w x r

Y la aceleración en el punto O2 es conocido; al ser un punto fijo a tierra, esta será cero. Luego, la velocidad angular es conocida (fue hallada en un punto anterior) así como la aceleración angular.

Este procedimiento se repite para todos los centros de gravedad, agregando el siguiente código al obtenido para hallar las aceleraciones:

%Cálculo de aceleraciones en los centros de gravedadaCGO2A(J,:) = aO2 + cross(alpha2,rCGO2A) - dot(omega2,omega2)*rCGO2A;aCGO2Amod(J)=norm(aCGO2A(J,:)); aCGBD(J,:) = aB(J,:) + cross(alpha4(J,:),(rCGBD-rB)) - dot(omega4(J,:),omega4(J,:))*(rCGBD-rB);aCGBDmod(J)=norm(aCGBD(J,:)); aCGAC(J,:) = aA(J,:) + cross(alpha3(J,:),(rCGAC-rA)) - dot(omega3(J,:),omega3(J,:))*(rCGAC-rA);aCGACmod(J)=norm(aCGAC(J,:));

No hay que olvidar la necesidad de declarar las nuevas variables a utilizar, las cuales serán, específicamente, las fuerzas y momentos que serán las variables en un planteamiento inicial. Esto se logrará añadiendo el siguiente código al inicio (antes de entrar al bucle del ‘for’):

%variables simbólicas para las reaccionesfO2x=sym('fO2x','real');fO2y=sym('fO2y','real');fAx=sym('fAx','real');fAy=sym('fAy','real');fBx=sym('fBx','real');fBy=sym('fBy','real');fDx=sym('fDx','real');fDy=sym('fDy','real');fCx=sym('fCx','real');fCy=sym('fCy','real');torque=sym('torque','real');

Posteriormente se deben agrupar las variables que sean la descomposición en los ejes ‘x’ e ‘y’ de la variable principal. Con el siguiente código que debe ser colocado dentro del bucle esto quedará mejor explicado:

fO2=[fO2x, fO2y, 0]; fA=[fAx, fAy, 0]; fB=[fBx, fBy, 0]; fD=[fDx, fDy, 0]; fC=[fCx, fCy, 0]; mtorque=[0, 0, torque];

Esto se hace con la finalidad de simplificar los cálculos, pues al hallar los momentos generados por las fuerzas de unión se multiplicará con el producto aspa por el vector dirección directamente. No habrá necesidad alguna de descomponerlo.

Y luego, después de mucho llegamos al cálculo de fuerzas y momentos. Para esto se consideró importante hacer un diagrama de cuerpo libre, como se ilustrará a continuación con la barra 2:

Figura 3.2. Análisis de D’Alembert

A partir de lo cual se pueden sacar tres ecuaciones; una de momentos respecto al centro de gravedad y 2 de sumatorias de fuerzas igual a 0.

. . 2 2 2. . . .

2 . 2

* 2* * 0

2 *

C G A O O AC G C G

O A C Gbarra

M fA r fO r I

F fA fO masa A

De la segunda ecuación es de donde salen las dos de sumatorias de fuerzas igual a cero. En MATLAB logramos hacerlo con el siguiente comando:

%Del análisis estático, tenemos: %en la barra O2A

mombarra2=cross(rA-rCGO2A,fA)+cross(-rCGO2A,fO2)+mtorque;fuerzasbarra2=fA+fO2-masaO2A*aCGO2A(J,:);fbarra2x=fuerzasbarra2(1); …(1)fbarra2y=fuerzasbarra2(2); …(2)mbarra2=mombarra2(3); …(3)

Con lo cual la variable ‘fbarra2x’ serán las coordenadas en ‘x’ de la respuesta a la operación realizada y ‘fbarra2y’ las coordenadas en ‘y’.

Se procede de la misma manera con las demás barras y ecuaciones.

Figura 3.3. Análisis de fuerzas en la barra 3.

. . 3 3 3. . 3 . . 3

3 . 3

* * * 0

*

C G barra A CC G barra C G barra

C Gbarra

M fA r fC r I

F fA fC fB masa A

En este punto se debe considerar algo muy importante. Esto es el análisis estático en los puntos de unión de barras. Si en un elemento se colocan las fuerzas internas en un sentido, en el otro elemento que completa la unión se debe colocar con sentido contrario.

Estas ecuaciones se colocan en MATLAB de la siguiente manera:

mombarra3=cross(rA-rCGAC,-fA)+cross(rB-rCGAC,fB)+cross(rC-rCGAC,fC)-inerciaAC*alpha3(J,:);

fuerzasbarra3=-fA+fB+fC-masaAC*aCGAC(J,:); fbarra3x=fuerzasbarra3(1); …(4) fbarra3y=fuerzasbarra3(2); …(5) mbarra3=mombarra3(3); …(6)

Ahora toca el análisis de la barra 4.

Figura 3.4. Análisis de fuerzas en la barra 4.

. . 4 4 4. . 4 . . 4

4 . 4

* * * 0

*

C G barra B DC G barra C G barra

C Gbarra

M fB r fD r I

F fB fD masa A

Nuevamente, para ingresar estas ecuaciones a MATLAB se utilizará el siguiente código:

%en la barra BDmombarra4=cross(rB-rCGBD,-fB)+cross(rD-rCGBD,fD)-inerciaBD*alpha4(J,:);

fuerzasbarra4=-fB+fD-masaBD*aCGBD(J,:); fbarra4x=fuerzasbarra4(1); …(7) fbarra4y=fuerzasbarra4(2); …(8) mbarra4=mombarra4(3); …(9)

Por último debemos analizar las dos deslizaderas. Empezaremos por la C:

Figura 3.5. Análisis de fuerzas en la deslizadera C.

.*C C GbarraCF fC N masa A

%en la deslizadera vertical fdesDy=fD(2); masD=masaD*aD(J,:); masDy=masD(2); eqDy=fdesDy-masDy; …(10)

Para terminar con los análisis y comenzar con la resolución, se debe estudiar la deslizadera vertical.

Figura 3.6. Análisis de fuerzas en la deslizadera D

.*D C GbarraDF fD N masa A %en la deslizadera horizontal

fdesCx=fC(1); masC=masaC*aC(J,:); masCx=masC(1); eqCx=fdesCx-masCx; …(11)

A continuación, se puede observar que hay 11 ecuaciones para poder hallar las 10 reacciones mencionadas y declaradas anteriormente, en adición del torque. Esta solución se obtendrá gracias al comando solve de MATLAB, como se muestra a continuación:

solucion1=solve(mbarra2, fbarra2x, fbarra2y, mbarra3, fbarra3x, fbarra3y, mbarra4, fbarra4x, fbarra4y, eqDy, eqCx);

Con este comando se ingresan las 11 ecuaciones descritas anteriormente para luego utilizar otro comando, eval, para hallar las once respuestas. A continuación se muestra la sintaxis del código a utilizar.

fO2xs=eval(solucion1.fO2x); fO2ys=eval(solucion1.fO2y); fO2f(J,:)=[fO2xs, fO2ys, 0]; fO2fmod(J)=norm(fO2f(J,:)); fAxs=eval(solucion1.fAx); fAys=eval(solucion1.fAy); fAf(J,:)=[fAxs, fAys, 0]; fAfmod(J)=norm(fAf(J,:)); fBxs=eval(solucion1.fBx); fBys=eval(solucion1.fBy); fBf(J,:)=[fBxs, fBys, 0]; fBfmod(J)=norm(fBf(J,:)); fDxs=eval(solucion1.fDx); fDys=eval(solucion1.fDy); fDf(J,:)=[fDxs, fDys, 0]; fDfmod(J)=norm(fDf(J,:)); fCxs=eval(solucion1.fCx); fCys=eval(solucion1.fCy); fCf(J,:)=[fCxs, fCys, 0]; fCfmod(J)=norm(fCf(J,:)); torques=eval(solucion1.torque); ftorquef(J,:)=[0, 0, torques]; ftorquefmod(J)=norm(ftorquef(J,:));

En este punto se mostrarán solamente los últimos diez elementos del vector de torques, pues para el planteamiento del problema del motor que le otorgue la energía al mecanismo, es el dato más importante. Cabe resaltar de igual manera que si se llama cualquiera de las matrices evaluadas, se obtendrá cada solución de reacciones en particular.

0 0 13.9835 0 0 14.8504 0 0 15.6073 0 0 16.2367 0 0 16.7253 0 0 17.0646 0 0 17.2510 0 0 17.2858 0 0 17.1744 0 0 16.9262

Teniendo las siguientes características:

>> max(ftorquef)

ans =

0 0 17.2858

>> min(ftorquef)

ans =

0 0 -7.7779

Cabe resaltar que se debe tener mucho cuidado al momento de insertar las ecuaciones ya que puede suceder que por un pequeño error de tipeo se tenga largas horas frente a la PC, buscando solución para un problema que a primera se puede considerar importante.

Por último, se presentan las gráficas de las reacciones y torque halladas, para poder ver su comportamiento respecto al giro angular de la barra O2A, la cual será accionada por el motor.

En este punto cabe resaltar que la gráfica tiene esa forma porque se ha tomado el módulo del torque. Por ello en realidad entre 1750 y 1850, la gráfica debería ir hacia la zona negativa.

También es necesario encontrar las fuerzas en las uniones ya que para el diseño de los pines de unión, las fuerzas son primordiales.

Se puede observar que la mayor fuerza en el punto O2 será de 800 Newtons, aproximadamente. Por ello el diseño del pin se hará con esta fuerza máxima.

Para los puntos A, B, C y D se hará el mismo razonamiento, tomando en cuenta el valor máximo de la fuerza para cada pin de unión.

A continuación se muestran las gráficas de cada punto mencionado en el anterior párrafo, teniendo una fuerza máxima de casi 800 N para la unión A, de 70 N para la unión B, casi 700 N en la C y de 14 N en la D.

4. Conclusiones

Debemos aprender a utilizar elementos necesarios para solucionar problemas de la vida diaria, o tal vez ciertos percances que tengamos en la empresa, y debemos hacerlo de manera práctica y relativamente sencilla; esta manera puede ser utilizando MATLAB.

Debemos ser ordenados al momento de resolver las ecuaciones, ya que como es un proceso repetitivo, si hay algún pequeño detalle, todo el resto fallará y será complicado encontrarlo.

Es importante conocer las aceleraciones, para poder darnos una idea en lo que haremos después, que es el cálculo de fuerzas para el posterior diseño de elementos.

Los conocimientos extra a los enseñados en clase son muy importantes, ya que así se tendrá un ‘extra’ sobre quienes no sepan utilizarlo o presentar informes hechos con la calidad mencionada.

El conocer las fuerzas a las cuales estará sometida una unión nos permite luego poder diseñar el elemento de unión de ésta, de manera segura y sin la necesidad de hacer un prototipo y gastar dinero en experimentos de prueba-error.