ndice:

1. Introduccin

2. Clculos

2.1. Clculo de posiciones

2.2. Clculo de velocidades

2.3. Clculo de aceleraciones


3. Clculo de fuerzas y torque

4. Conclusiones


1. Introduccin:
El mecanismo que fue asignado para la posterior simulacin 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 geomtricos (todos son
pedidos al inicio), se puede designar y conocer el punto A y todos
sus parmetros cinemticos con un simple clculo, que se ver ms
adelante.

- Luego sigue la barra 3, la cual se encuentra conectada directamente
con la 2, y por ende, el clculo de los parmetros cinemticos
depender de los parmetros del punto A.

En este punto, tambin 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 parmetros cinemticos sern dependientes. Y
tambin 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 caracterstica 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 estn en el plano z
y tomaremos el mecanismo en el xy.

2. Clculos:

- Primero, se calcularn los grados de libertad, aplicando el criterio
Grbler:

( )

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

2.1. Clculo de posiciones:

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

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

%Trabajo curso Teora de Mquinas 2013-II
%Ejercicio asignado; Estremadoyro Ruiz, Jorge Augusto
%Clculo de posiciones
clc
clear all
close all
%Como no tenemos datos geomtricos, 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 parmetros geomtricos bien
definidos, estos se mostrarn en pantalla para luego empezar con el
programa para graficar el movimiento:


%Las dimensiones xD y yC sern siempre constantes
fprintf('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 sern constantes')
%Ahora comenzamos con los clculos, conociendo yC y xD
paso=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 explicacin rpida
de ambas:

La funcin lincir sirve para hallar la interseccin de una lnea con
una circunferencia. Para esta funcin, se debe tener en cuenta que los
dos primeros elementos solicitados por la funcin son las componentes
en x y en y de un punto de la lnea a intersectar con el crculo.


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 funcin, sta nos devuelve dos posibles
respuestas, ya que al intersectar una lnea y un crculo tendremos dos
puntos de interseccin.

Ah es donde entra la siguiente funcin mencionada. Entonces, pues,
la funcin distMinima sirve para calcular la distancia mnima 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 lnea
horizontal por la que desliza C (que ha sido hallado geomtricamente
al dar los valores iniciales).

As, y con las funciones antes mencionadas, se tendr el siguiente
cdigo para hallar las posiciones desconocidas:

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

%Para el clculo de la posicin de la barra 5

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


Figura 1.3

Ahora se har el mismo anlisis con la deslizadera 6, la cual se
puede encontrar al intersectar la lnea vertical por la cual desliza y un
crculo con centro en B y radio BD.


%Para el clculo de la posicin de la barra 6
[ xD1,yD1,xD2,yD2 ] = lincir(
xD,yC,xD,yC+BD+BC,xB,yB,BD );
%Ahora tomamos el punto ms 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('Simulacin 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 tendrn las siguientes grficas como simulacin de las
posiciones:

Grfica 1.1. Estado inicial del mecanismo


Grfica 1.2. Posicin intermedia del mecanismo

2.2. Clculo 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 tambin se pedir el
valor de la velocidad angular de la barra2 y la teora estudiada en
clase tendr que ser aplicada para poder calcular las velocidades
en los diversos puntos requeridos.

Se sabe que:


As, se debe empezar desde el punto O2, el cual tiene velocidad
igual a 0, para luego extenderse a todos los puntos solicitados.
B A
B
A
V V wx r

= +


El cdigo utilizado para lograrlo es el siguiente:
%Trabajo curso Teora de Mquinas 2013-II
%Ejercicio asignado; Estremadoyro Ruiz, Jorge Augusto
%Clculo de velocidades
clc
clear all
close all
%DATOS INICIALES
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;
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 sern siempre constantes
fprintf('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 sern constantes')

Luego, se colocarn los puntos iniciales para comenzar con el
proceso de clculo (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 iteracin desde J=1 hasta el valor predefinido en
nuestro for.

%Ahora comenzamos con los clculos, conociendo yC y xD
paso=pi/180;
xCref=xC;
yDref=yD;
J=1;



Ahora, se debe tener en cuenta que se tendr la necesidad de
nombrar ciertas variables simblicas que utilizaremos en nuestros
bucles antes de iniciarlos, as, se tendr:


%variable simblicas para el eslabn 3
omega3z = sym('omega3z','real');
vCx = sym('vCx','real');
%variable simblicas para el eslabn 4
omega4z = 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 clculo de la posicin de la barra 5
[ xC1,yC1,xC2,yC2 ] = lincir( 0,yC,O2A+AC,yC,xA,yA,AC );
%Ahora tomamos el punto ms cercano
[ xC,yC ] = distMinima( xCref,yC,xC1,yC1,xC2,yC2);
%Para el clculo de la posicin de la barra 6
[ xD1,yD1,xD2,yD2 ] = lincir( xD,yC,xD,yC+BD+BC,xB,yB,BD
);
%Ahora tomamos el punto ms cercano
[ xD,yD ] = distMinima( xD,yDref,xD1,yD1,xD2,yD2);
%Contruccin de los vectores posicin
rA=[xA, yA, 0];
rB=[xB, yB, 0];
rC=[xC, yC, 0];
rD=[xD, yD, 0];
vO2=[0, 0, 0 ]; %en m/s


Luego:

Y esto, en lenguaje MATLAB, ser:

%Clculo 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:

%clculo de la velocidad en C
%Para esto es necesario crear dos variable simblicas
cuya declaracin
%se pone fuera del for porque se hace una sola vez

Omega3 = [ 0 0 omega3z ];
VC = [ vCx 0 0 ];
%Se usa la ecuacin vC = vB + ?2(rC ?rB) que en Matlab
es
eqvC = VC - (vA(J,:) + cross(Omega3,rC-rA));
%como la ecuacin anterior es vectorial la convertimos en
dos
%algebraicas
eqvCx = eqvC(1); % Ecuacin en X
eqvCy = eqvC(2); % Ecuacin 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 clculo de
las aceleraciones angulares y lineales, se har lo mismo con el punto
D:

%Clculo de la velocidad en D
%Para esto es necesario crear dos variable simblicas
cuya declaracin
%se pone fuera del for porque se hace una sola vez
Omega4 = [ 0 0 omega4z ];
VD = [ 0 vDy 0 ];
%Se usa la ecuacin vC = vB + ?2(rC ?rB) que en Matlab
es
eqvD = VD - (vB(J,:) + cross(Omega4,rD-rB));
%como la ecuacin anterior es vectorial la convertimos en
dos
%algebraicas
eqvDx = eqvD(1); % Ecuacin en X
eqvDy = eqvD(2); % Ecuacin 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 grficas de velocidades en varios puntos del
mecanismo estudiado, mostradas en la siguiente hoja.








2.3. Clculo de aceleraciones:

Para este apartado se debe recordar la teora tratada en las
clases tericas. As, para una aceleracin, se encontrar como
frmula general la siguiente (si el mecanismo no experimenta una
aceleracin de Coriolis, como es el caso con el mecanismo tratado):



Nuevamente, esta parte es repetida. As que no se tocar a
detalle y solo ser colocado el cdigo.
%Trabajo curso Teora de Mquinas 2013-II
%Ejercicio asignado; Estremadoyro Ruiz, Jorge Augusto
%Clculo de aceleraciones
clear all
clc
close all
%DATOS INICIALES
O2A=input('Ingresar la longitud de la barra O2A:');
B A
B B
A A
A A x r wx wx r o

= + +

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 aceleracin 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 sern siempre constantes
fprintf('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 sern constantes')

Paso=pi/180;
xCref=xC;
yDref=yD;
J=1;
%variable simblicas para el eslabn 3: Velocidad
omega3z = sym('omega3z','real');
vCx = sym('vCx','real');
%variable simblicas para el eslabn 3: Aceleracin
alpha3z=sym('alpha3z','real');
aCx=sym('aCx','real');
%variable simblicas para el eslabn 4: Velocidad
omega4z = sym('omega4z','real');
vDy = sym('vDy','real');
%variable simblicas para el eslabn 4: Aceleracin
alpha4z=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 clculo de la posicin de la barra 5
[ xC1,yC1,xC2,yC2 ] = lincir( 0,yC,O2A+AC,yC,xA,yA,AC );
%Ahora tomamos el punto ms cercano
[ xC,yC ] = distMinima( xCref,yC,xC1,yC1,xC2,yC2);
%Para el clculo de la posicin de la barra 6
[ xD1,yD1,xD2,yD2 ] = lincir( xD,yC,xD,yC+BD+BC,xB,yB,BD
);
%Ahora tomamos el punto ms cercano
[ xD,yD ] = distMinima( xD,yDref,xD1,yD1,xD2,yD2);
%Contruccin de los vectores posicin
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 frmula puesta anteriormente, hay
la necesidad de tener las velocidades para poder hallar nuestras
aceleraciones. Por ello se repetir el cdigo de las velocidades:


%Clculo de la velocidad en A
vA(J,:) = vO2 + cross(omega2,rA);
vAmod(J)=norm(vA(J,:));
%clculo de la velocidad en C
%Para esto es necesario crear dos variable simblicas
cuya declaracin
%se pone fuera del for porque se hace una sola vez
Omega3 = [ 0 0 omega3z ];
VC = [ vCx 0 0 ];
%Se usa la ecuacin vC = vB + ?2(rC ?rB) que en Matlab
es
eqvC = VC - (vA(J,:) + cross(Omega3,rC-rA));
%como la ecuacin anterior es vectorial la convertimos en
dos
%algebraicas
eqvCx = eqvC(1); % Ecuacin en X
eqvCy = eqvC(2); % Ecuacin 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

lgica que fue utilizada en las velocidades. Esto es, que se
partir del punto O2, cuya aceleracin es 0, y al conocer las
velocidades angulares, y resolver las 2 ecuaciones con 2
incgnitas que se nos presentan en cada barra, se pueden
hallar las aceleraciones lineales y angulares.


%Clculo de la aceleracin en A
aO2 = [0 0 0 ];
aA(J,:) = aO2 + cross(alpha2,rA) - dot(omega2,omega2)*rA;
aAmod(J)=norm(aA(J,:));


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

Como recomendacin, podemos comentar que debemos tener
cuidado al momento de colocar los vectores posicin. Hay que tener
claro cul es el sentido de stos.


%clculo de la velocidad en C
%Para esto es necesario crear dos variable simblicas
cuya declaracin
%se pone fuera del for porque se hace una sola vez
Omega3 = [ 0 0 omega3z ];
VC = [ vCx 0 0 ];
%Se usa la ecuacin vC = vB + ?2(rC ?rB) que en Matlab
es
eqvC = VC - (vA(J,:) + cross(Omega3,rC-rA));
%como la ecuacin anterior es vectorial la convertimos en
dos
%algebraicas
eqvCx = eqvC(1); % Ecuacin en X
eqvCy = eqvC(2); % Ecuacin 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,:));


%Clculo de la aceleracin 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); % Ecuacin en X
eqaCy = eqaC(2); % Ecuacin 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,:));


%Clculo de la velocidad en B
vB(J,:) = vA(J,:) + cross(omega3(J,:),rB-rA);
vBmod(J) = norm(vB(J,:));


%Clculo de la aceleracin en B
aB(J,:) = aA(J,:) + cross(alpha3(J,:),rB-rA) -
dot(omega3(J,:),omega3(J,:))*(rB-rA);
aBmod(J)=norm(aB(J,:));


%Clculo de la velocidad en D
%Para esto es necesario crear dos variable simblicas
cuya declaracin
%se pone fuera del for porque se hace una sola vez
Omega4 = [ 0 0 omega4z ];
VD = [ 0 vDy 0 ];
%Se usa la ecuacin vC = vB + ?2(rC ?rB) que en Matlab
es
eqvD = VD - (vB(J,:) + cross(Omega4,rD-rB));
%como la ecuacin anterior es vectorial la convertimos en
dos
%algebraicas
eqvDx = eqvD(1); % Ecuacin en X
eqvDy = eqvD(2); % Ecuacin 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,:));


%Clculo de la aceleracin 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); % Ecuacin en X
eqaDy = eqaD(2); % Ecuacin 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('Mdulo de la aceleracin en A')
xlabel('Angulo \phi (Grados)')
ylabel('Aceleracin (m/s2)')
grid
figure(2);
plot(ang*180/pi,aCmod);
title('Modulo de la aceleracin en C')
xlabel('Angulo \phi (Grados)')
ylabel('Aceleracin (m/s2)')
grid
figure(3);
plot(ang*180/pi,aDmod);
title('Modulo de la aceleracin en D')
xlabel('Angulo \phi (Grados)')
ylabel('Aceleracin (m/s2)')
grid
figure(4);
plot(ang*180/pi,alpha3mod);
title('Modulo de la aceleracin angular en la barra3')
xlabel('Angulo \phi (Grados)')
ylabel('Aceleracin angular (rad/s2)')
grid
figure(5);
plot(ang*180/pi,alpha4mod);
title('Modulo de la aceleracin angular en la barra4')
xlabel('Angulo \phi (Grados)')
ylabel('Aceleracin angular (rad/s2)')
grid


As, se obtendrn las grficas mostradas en las siguientes caras,
con la leyenda respectiva para una fcil interpretacin y lectura de las
variables.








3. Clculo de fuerzas y torque

Para que se pueda tener esta velocidad en la barra 1 debe haber una
energa que le otorgue el movimiento. En este caso la energa mencionada es
un torque aplicado por un pequeo motor.

Ahora, como puede ser observado, el problema principal es qu motor se
debe elegir para accionar este elemento, as como a qu esfuerzos estarn
sometidos los pines conectores de las barras. Todo esto es muy importante y
necesario para hacer un ptimo diseo 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 conexin.
Ahora lo primordial es hallar las aceleraciones lineales de los centros de
gravedad, para poder aplicar el principio de DAlembert. 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 aceleracin angular y lineal, stas se pueden reemplazar por un
momento y fuerza respectivamente, de magnitud proporcional pero sentido

contrario. As, al multiplicar la aceleracin lineal del C.G. por la masa de sta
barra y la inercia de la misma con la aceleracin angular, se encontrarn el
momento y la fuerza mencionados.

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

- 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 calcularn de la siguiente manera:


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

Figura 3.1. Barra 2.
( )
2
2 2 2
1
12
O A O A O A
I m xL =
( )
( )
2
2
1
12
1
12
AC AC AC
BD BD BD
I m xL
I m xL
=
=

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 ecuacin
para hallar la velocidad quedar de la siguiente manera:

Y la aceleracin 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 aceleracin angular.
Este procedimiento se repite para todos los centros de gravedad,
agregando el siguiente cdigo al obtenido para hallar las aceleraciones:
%Clculo de aceleraciones en los centros de gravedad
aCGO2A(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 sern, especficamente, las fuerzas y momentos que sern las
variables en un planteamiento inicial. Esto se lograr aadiendo el siguiente
cdigo al inicio (antes de entrar al bucle del for):

%variables simblicas para las reacciones
fO2x=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');

2 2
2 2
2 2
CGbarra O
CGbarra CGbarra
O O
A A xr wx wxr o

= + +

Posteriormente se deben agrupar las variables que sean la
descomposicin en los ejes x e y de la variable principal. Con el siguiente
cdigo 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 clculos, pues al hallar los
momentos generados por las fuerzas de unin se multiplicar con el
producto aspa por el vector direccin directamente. No habr necesidad
alguna de descomponerlo.

Y luego, despus de mucho llegamos al clculo de fuerzas y momentos.
Para esto se consider importante hacer un diagrama de cuerpo libre, como
se ilustrar a continuacin con la barra 2:


Figura 3.2. Anlisis de DAlembert

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.



De la segunda ecuacin es de donde salen las dos de sumatorias de
fuerzas igual a cero. En MATLAB logramos hacerlo con el siguiente
comando:
%Del anlisis esttico, 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 sern las coordenadas en x de la
respuesta a la operacin realizada y fbarra2y las coordenadas en y.
Se procede de la misma manera con las dems barras y ecuaciones.

Figura 3.3. Anlisis de fuerzas en la barra 3.
. . 2 2 2
. . . .
2 . 2
* 2* * 0
2 *
C G A O O A
C G C G
O A C Gbarra
M fA r fO r I
F fA fO masa A
o = + =
= +

En este punto se debe considerar algo muy importante. Esto es el anlisis
esttico en los puntos de unin de barras. Si en un elemento se colocan las
fuerzas internas en un sentido, en el otro elemento que completa la unin
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 anlisis de la barra 4.

Figura 3.4. Anlisis de fuerzas en la barra 4.

. . 3 3 3
. . 3 . . 3
3 . 3
* * * 0
*
C G barra A C
C G barra C G barra
C Gbarra
M fA r fC r I
F fA fC fB masa A
o = + =
= + +

. . 4 4 4
. . 4 . . 4
4 . 4
* * * 0
*
C G barra B D
C G barra C G barra
C Gbarra
M fB r fD r I
F fB fD masa A
o = + =
= +

Nuevamente, para ingresar estas ecuaciones a MATLAB se utilizar el
siguiente cdigo:
%en la barra BD
mombarra4=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. Anlisis de fuerzas en la deslizadera C.



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





.
*
C C GbarraC
F fC N masa A = +

Para terminar con los anlisis y comenzar con la resolucin, se debe
estudiar la deslizadera vertical.


Figura 3.6. Anlisis de fuerzas en la deslizadera D


%en la deslizadera horizontal
fdesCx=fC(1);
masC=masaC*aC(J,:);
masCx=masC(1);
eqCx=fdesCx-masCx; (11)

A continuacin, se puede observar que hay 11 ecuaciones para poder
hallar las 10 reacciones mencionadas y declaradas anteriormente, en
adicin del torque. Esta solucin se obtendr gracias al comando solve de
MATLAB, como se muestra a continuacin:
solucion1=solve(mbarra2, fbarra2x, fbarra2y, mbarra3, fbarra3x,
fbarra3y, mbarra4, fbarra4x, fbarra4y, eqDy, eqCx);

.
*
D C GbarraD
F fD N masa A = +

Con este comando se ingresan las 11 ecuaciones descritas anteriormente
para luego utilizar otro comando, eval, para hallar las once respuestas. A
continuacin se muestra la sintaxis del cdigo 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 mostrarn solamente los ltimos diez elementos del vector
de torques, pues para el planteamiento del problema del motor que le otorgue
la energa al mecanismo, es el dato ms importante. Cabe resaltar de igual
manera que si se llama cualquiera de las matrices evaluadas, se obtendr
cada solucin 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 caractersticas:
>> 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 pequeo error de tipeo se
tenga largas horas frente a la PC, buscando solucin para un problema que
a primera se puede considerar importante.
Por ltimo, se presentan las grficas 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 grfica tiene esa forma porque se ha
tomado el mdulo del torque. Por ello en realidad entre 1750 y 1850, la
grfica debera ir hacia la zona negativa.
Tambin es necesario encontrar las fuerzas en las uniones ya que para el
diseo de los pines de unin, las fuerzas son primordiales.

Se puede observar que la mayor fuerza en el punto O2 ser de 800
Newtons, aproximadamente. Por ello el diseo del pin se har con esta
fuerza mxima.
Para los puntos A, B, C y D se har el mismo razonamiento, tomando en
cuenta el valor mximo de la fuerza para cada pin de unin.
A continuacin se muestran las grficas de cada punto mencionado en el
anterior prrafo, teniendo una fuerza mxima de casi 800 N para la unin A,
de 70 N para la unin 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 prctica 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 algn pequeo detalle, todo
el resto fallar y ser complicado encontrarlo.

- Es importante conocer las aceleraciones, para poder darnos una idea
en lo que haremos despus, que es el clculo de fuerzas para el
posterior diseo de elementos.

- Los conocimientos extra a los enseados 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 unin nos
permite luego poder disear el elemento de unin de sta, de manera
segura y sin la necesidad de hacer un prototipo y gastar dinero en
experimentos de prueba-error.