Está en la página 1de 5

UNIVERSIDAD POLITECNICA SALESIANA

Nombre: Víctor Lojano


TEMA: Resolución de examen final mediante métodos numéricos en Python.
OBJETIVO:
 Imponerse dos puntos con el cual una maquina debe dar una trayectoria desde un punto
inicial a un punto final en los dos ejes que al final deben llegar a una misma posición sin
importar su trayectoria.
 Realizar la resolución con las restricciones dadas con una velocidad inicial máxima de
[1m/s] y una aceleración de [9.81m/s**2]
PROCEDIMINETO:
RESOLUCION DE EXAMEN FINAL
1. Importar librería necesaria, conocer nuestros dos puntos inicial y final y validar
restricciones.

2. Validar las ecuaciones de espacio-tiempo, velocidad-tiempo y aceleración tiempo.

3. Realizamos nuestras condiciones y consulta para saber en qué eje realiza el mayor
desplazamiento ya sea en X o Y esto se hace para que en la distancia más extensa
alcance la velocidad máxima y se optimice el tiempo de desplazamiento.
ym=(y2-y1)/2
xm=(x2-x1)/2
emax=((1/(2*(1/9.81)))*(ta)**2)*100#espacio en el que alcansa la velocidad maxima y
tiene que dejar de acelerar
#posicionamiento en en el punto de partida
if y1<0:
print('el desplasamiento no puede ser negativo en el eje Y')
if y1>100:
print('el limite maximo es de 100cm')
if x1<0:
print('el desplasamiento no puede ser negativo en el eje X')
if y1>0 and y1<=100:#condicion cuando el desplasamiento sea mayor en el eje y
#mi desplasamiento total es en el eje y sera y2
yi=y1/2
ti=math.sqrt(((2*ta*(yi/100))/vm))#calcular el tiempo que se demora en llegar a el
punto inicial
ei=((1/(2*(1/9.81)))*(ti)**2)*100
tt=2*ti
emaxy=((1/(2*(1/9.81)))*(ti)**2)*100
if y1<=2*emax:
ym1=y1/2
timy=math.sqrt(((2*ta*(ym1/100))/vm))#calcular el tiempo que se demora en
llegar a el punto inicial
emaxy=((1/(2*(1/9.81)))*(timy)**2)*100#espacio en el que alcansa la velocidad
maxima y tiene que empezar a desacelerar
a=(emaxy-((1/(2*(1/9.81)))*((timy-timy)**2)))
print(emaxy,timy,a,ti,ei,tt)
#interpolando nombres
lfc=2*timy
lic=timy
#calculamos la velocidad que devera tener para no superar la velocidad limite
if x1>0 and x1<=100:
vmx=(x1)/(100*timy)
ax=(vmx/timy)
tax=vmx/ax
#se sabe que no alcanzara la velocidad maxima ya que el desplasamiento es menor
y el tiempo sera el mismo que en y
ym1=x1/2
timx=math.sqrt(((2*tax*(ym1))/vmx))#calcular el tiempo que se demora en llegar
a el punto inicial
emaxx=(x1)#espacio en el que alcansa la velocidad maxima y tiene que empezar a
desacelerar
a=(emaxx-((1/(2*(1/9.81)))*((timx-timx)**2)))
print('Integrantes')

#con una velocidad constante


if y1>emax:
yc=y1
lic=(1/9.81)
timy=lic
lfc=((yc/(100*vm))+(ta/2))-lic
tf=lfc+lic
q1=(vm*(tf-(ta/2)))*100
q0=(vm*(lfc-(ta/2)))*100
emaxy=((100*(tf-(ta/2))))
print(lfc,emaxy,lic,q1,q0)
print ('pato')
#if ym<=emax:#con esta condicion podemos saber si alcansamos una velida maxima
#graficas del posicionamiento
get_ipython().magic('matplotlib inline')
#acontinuacion se calcula el movimiento en x para que sea simetrico con el
movimiento en y

4. Se grafica las ecuaciones con los límites que se calcularan que alcance una velocidad
máxima de 1m/s y se mantenga constante un tiempo necesario en el cual se necesitara
un tiempo igual que el de aceleración que para desacelerar.
5. En el cálculo y en las gráficas se observa que el tiempo que requiere para alcanzar esa
velocidad máxima es de 0,1s esto nos permite saber que la desaceleración tardara el
mismo tiempo, por lo tanto el tiempo que se desplazará constante será el tiempo total
menos el tiempo de desaceleración más el tiempo de aceleración.
6. En la programación se valida a la cota más extensa con la letra (a)y la más corta con la
letra (b) esto nos facilita a que cuando X o Y se la mayor cota esto no importara ya que
las letras estarán válidas y graficara sin problemas.
7. Para las gráficas de la cota más corta como se busca una interpolación entre los ejes X y
Y para el eje que tenga la cota más corta se calculara la velocidad ya que conocemos el
desplazamiento y el tiempo, luego con la nueva velocidad y el tiempo se puede calcular
la aceleración, con estos nuevos datos los ponemos con nombres de variables las cuales
remplazaremos en las ecuaciones de espacio, velocidad ,aceleración con respecto al
tiempo y esta nunca superara la velocidad máxima y además tampoco la aceleración no
será mayor.
8. En nuestro caso realizamos derivas de manera numérica por medio de las ecuaciones
centrales y se graficaron con puntos en las mismas graficas de velocidad y aceleración
las cuales cuadraron perfectamente con las gráficas de las ecuaciones previamente
asignadas.
#primera derivada con respecto al tiempo velocidad con acceleracion
if y1<=emax:
for t in np.arange(0.0005,timy+0.005,0.005):
h=0.005
a=t+h
b=t-h
fa=(100/(2*(1/9.81)))*(a)**2
fb=(100/(2*(1/9.81)))*(b)**2
vt=(fa-fb)/(2*h)#velosidad para alcansar el punto maximo
plt.figure(2)
x=np.linspace(t,timy)
plt.plot(t,vt,'.')
print(vt)
#primera derivada con respecto al tiempo velocidad con desaceleracion
for t in np.arange(timy-0.005,(2*timy),0.005):
h=0.005
a=t+h
b=t-h
fa=(2*emaxy-((100/(2*(1/9.81)))*((2*timy)-a)**2))
fb=(2*emaxy-((100/(2*(1/9.81)))*((2*timy)-b)**2))
vt=(fa-fb)/(2*h)#velosidad para alcansar el punto mino o 0
plt.figure(2)
x=np.linspace(timy,2*timy)
plt.plot(t,vt,'.')
#print(vt)
#segunda derivada con respecto al tiempo para la aceleracion
for t in np.arange(0.0005,timy+0.005,0.005):
h=0.005
a=t+h
b=t-h
fa=(100/(2*(1/9.81)))*(a)**2
fb=(100/(2*(1/9.81)))*(b)**2
ft=(100/(2*(1/9.81)))*(t)**2
at=((fa-2*ft+fb)/(h**2))/100#velosidad para alcansar el punto maximo
plt.figure(3)
x=np.linspace(t,timy)
plt.plot(t,at,'.')
#print('pato')
#primera derivada con respecto al tiempo velocidad con desaceleracion
for t in np.arange(timy,(2*timy),0.005):
h=0.005
a=t+h
b=t-h
faa=(2*emaxy-((100/(2*(1/9.81)))*((2*timy)-a)**2))
fba=(2*emaxy-((100/(2*(1/9.81)))*((2*timy)-b)**2))
fta=(2*emaxy-((100/(2*(1/9.81)))*((2*timy)-t)**2))
dsat=((faa-2*fta+fba)/(h**2))/100#velosidad para alcansar el punto mino o 0
plt.figure(3)
x=np.linspace(timy,2*timy)
plt.plot(t,dsat,'.'
9. El primer desplazamiento que realiza es de posicionamiento y en esté comienza en
reposo y termina en reposo.
10. Para el movimiento al punto 2 se realiza la misma programación solo con la diferencia
de que las variables que se asignan serán la resta del punto inicial con el final para que
el desplazamiento realizado sea el correcto y el deseado.