En la clase anterior habíamos revisado cómo obtener el control de lazo abierto de un robot tipo Uni
ciclo en esta clase.
Vamos a estar revisando ya el control en lazo cerrado para evitar los problemas que habíamos revisado
en la clase anterior.
Entonces vamos a irnos acá.
Esto ya se repite del mismo código lo que aumenta son las variables ya para los peude en este caso bueno
solo he implementado un controlador Poy que fue más que suficiente para realizar este control.
Entonces acá tenemos las variables que vamos a estar utilizando para este tipo de control.
Entonces tenemos acá tanto para la velocidad lineal y la velocidad angular vamos a estar utilizando
estas variables que vemos acá y acá tenemos las variables que ya habíamos visto anteriormente y aquí
esto habíamos mencionado que ya vamos a tenerlo en la constante así que no es necesario esto ya está
incorporado aquí en esta constante que habíamos visto.
Adicionalmente ya no estamos utilizando esta constante porque en mi caso estoy utilizando los mismos
motores y entonces bueno hay veces que va a ser necesario esta otra constante para ver algunos pequeños
problemitas que van a ver por ejemplo si nosotros mandamos la velocidad digamos lineal el robot debería
irse hacia adelante pero hay veces que difiere un poquito en las lecturas entonces con esas constantes
podríamos nosotros cuadrar a nuestro robot es decir tratar de que siga esa línea recta.
Entonces eso es un pequeño problema que a veces se tiene entonces dependiendo de eso pueden utilizar
otra constante para un motor y otro constante para el otro motor.
Eso es cuestión de ir haciendo pruebas pero el valor real debería ser este porque son hechas con las
fórmulas que habíamos visto anteriormente pero ahí pueden agregarle por ejemplo un valor de decimales
para que mejore el resultado.
Entonces esos valores ya lo habíamos visto tenemos acá también la configuración que también ya lo habíamos
visto.
Otra cosa adicional que vamos a tener son las salidas máximas del controlador pide que va a variar de
27 2:55 a menos 2:55 como habíamos visto en la clase anterior.
Acá tenemos las constantes de estas constantes y ya está sintonizado para este tipo de motores entonces
sí depende si ustedes tengan otros motores puede ir variando estas constantes.
Entonces con esas constantes dio un buen resultado entonces en este caso podemos ver que el Capell y
el KP doble son valores bastante altos.
Esto debido a que estamos realizando el control en valores pequeñitos como habíamos visto.
Teníamos unas velocidades de 0 Punto 3 a lo máximo digamos en la velocidad lineal entonces por eso son
valores bastantes altos porque la salida de doblegue debe ir hacia 2:55 Liste entonces esto es parte
de sintonía nada más tenemos acá el set point que vamos a inicializar en cero todo esto y acá también
ya la habíamos revisado.
Vamos a agregar los valores de entrada del puerto serial como set point podemos ver acá y vamos a imprimir
en el puerto serial para observar cuál es el resultado.
Esto ya lo habíamos visto una cosa que hay que aclarar aquí es que anteriormente estábamos enviando
solamente enteros hacia MATLAB pero hubo un pequeño inconveniente porque estaba realizando peude separados
para la llanta izquierda y la llanta derecha entonces no estaba dando un buen resultado porque se desviaba
el robot por eso prefería hacer un controlador peude global es decir voy a encontrar directamente ya
los voltajes globales para que vaya hacia adelante y para que gire entonces luego se reparte esos dos
voltajes se reparten a la Chianti izquierda y derecha y vamos a ver cómo calcular este este tipo de
algoritmo entonces es un peude hecho específicamente para un robot un ciclo que puede ser utilizado
para otros tipos de robot también es por eso que ahora ya no voy a enviar valores de tipo entero sino
voy a estar enviando valores de tipo flotante que al final no va a cambiar mucho en la parte de codificación
en MATLAB y aquí en Arduino es por eso que vamos a estar enviando datos flotantes hacia MATLAB y también
vamos a recibir datos flotantes entonces como pueden ver aquí simplemente he cambiado esta parte de
aquí se me ha olvidado decirles aquí era tu Hint entonces convertía entero pero acá con este vamos a
convertir a un valor de tipo Lott entonces el otro que estamos haciendo aquí es que estamos enviando
tres decimales como pueden ver acá entonces eso es el único cambio que hemos realizado en la parte de
comunicación serial listo entonces acá tenemos como vamos a realizar el cómputo del peude vamos a estar
llamando esta función cada determinado tiempo de muestreo como lo habíamos visto anteriormente entonces
acá tenemos el cálculo ya lo habíamos revisado todos estos cálculos también acá el filtro y acá viene
ya el algoritmo de control peude entonces cómo ven aquí se calcula el error.
Como pueden ver y se multiplica por las constantes de proporcionales.
Aquí vemos la parte integral y vemos que aquí vamos acumulando el error multiplicado por sus respectivas
constantes y aquí vamos a acotarla la parte integral para eliminar el efecto tipo Wit.
Entonces para ello vamos a saturar a las velocidades máximas que habíamos visto anteriormente que era
62 2:55 y menos 2:55.
Luego acabamos de calcular ya la salida de control.
Como pueden ver aquí es la suma del error más la parte integral entonces esto de aquí son los voltajes
globales del robot.
Luego lo que debemos hacer es encontrar los voltajes para cada uno de los motores entonces acá tenemos
el voltaje de la llanta derecha y de la llanta izquierda.
Como ven acá simplemente se calcula de la siguiente manera.
Así nosotros obtendríamos ya los valores que debemos aplicar de doble B.M. a cada uno de los motores
y acá podemos ver que también vamos a saturar las acciones de control a sus valores máximos que habíamos
revisar y aquí tenemos el valor de la señal de entrada pasada esto para calcularlo en este filtro que
habíamos revisado acá.
Entonces también podría ser utilizado para la parte derivativa entonces podríamos utilizar también este
valor si deseamos incorporar la parte derivativa a este control.
Luego acá tenemos ya la parte de verificación si el voltaje es positivo y negativo y va a invertir el
sentido de giro dependiendo de ese valor.
Entonces tenemos aquí todos estos valores y acá también ya lo habíamos visto bueno entonces vamos a
hacer la prueba en primer lugar vamos a imprimir aquí en el puerto serial para observar cómo realiza
el control entonces esto era simplemente para verificar como cómo estaba reaccionando el controlador
pero ya no lo vamos a necesitar porque ya está sintonizado entonces vamos a imprimir el valor que obtenemos.
Entonces vamos a cargar este código ya en Arduino nos vamos acá y tenemos el Arduino ya elegido entonces
lo programamos y vamos a observar cuál es el resultado.
Vamos a abrir también las cámaras para poder observar y también vamos a abrir el monitor serial listo
ya se ha cargado tenemos aquí el monitor serial y acá tenemos este valor.
Aquí me faltó ponerle un salto de línea famosa acá aquí entonces aquí va un salto de línea vamos a cargarlo
nuevamente y vamos a observar el resultado entonces vamos a abrir el puerto serial listo ya se ha cargado
entonces vamos a abrir el puerto serial listo acá tenemos ya entonces tenemos la salida de velocidad
lineal y velocidad angular.
Entonces vamos a abrir la cámara listo en primer lugar vamos a probar con una velocidad de 0.2 metros
sobre segundos y una velocidad angular de cero entonces como vemos ahí el algoritmo hace su trabajo
podemos ver que ahí llegó a la referencia que le habíamos ingresado ahora vamos a probar con velocidades
negativas mandemos un valor de 0.2 coma cero.
Vamos a ver cuál es el resultado y podemos ver ahí que ahora tenemos velocidades negativas entonces
ahora vamos a probar con velocidad angular vamos a dar una velocidad angular digamos de 1 un radian
sobre el segundo vamos a ver ahí podemos observar cómo obtenemos un radian sobre segundo y listo como
podemos observar ahí el algoritmo de control permite realizar el cálculo de los voltajes que debe aplicar
a cada una de las llantas.
Para conseguir este resultado podemos ver que ahí es sumamente bueno el algoritmo que está diseñado
entonces este algoritmo me dio mejores resultados que aplicar un peude para esta llanta es decir mandarle
referencias de velocidad lineal aquí y velocidad lineal acá para luego hacer el cálculo con esas fórmulas
que habíamos visto en la parte de modelamiento pero mejor opté por la parte de calcular una sola es
decir de todo el robot.
Entonces ahí obtenemos un mejor un mejor resultado vamos a probar con velocidades negativas podemos
ver ahí y podemos ver ahí el resultado.
Vamos a ingresar un poco más mandemos una de dos.
Hoy podemos ver cómo alcanza nuestra referencia de dos y acá tenemos el valor de cero ahora vamos a
intentar una combinación 0.2 y coma cero punto ocho mandemos entonces vamos a ver cuál es el resultado
y podemos observar que ahí alcanza ya la referencia tanto de la velocidad lineal como de la velocidad
angular.
Entonces ya estamos listos para probar nuestro robot está listo ya para funcionar y vamos a hacer las
pruebas experimentales y observar cuál es el resultado es bueno entonces vamos a empezar a quien MATLAB
tenemos el siguiente archivo y esto ya lo habíamos revisado en clases anteriores como cómo programar
ya quién MATLAB entonces lo que vamos a hacer aquí es comparar la parte simulada con la parte real entonces
vamos a ver que efectivamente los modelos que estamos realizando me permiten obtener la posición del
robot en la que se encuentra en el plano x y entonces es bastante útil porque podemos hacer algoritmos
de control y entre otras cosas que va a ser el tema de otro curso que estoy por abrir.
De igual manera habrá pruebas experimentales entonces por ejemplo ahí nosotros podríamos trabajar de
manera simulada y luego ya podríamos implementar en algún hardware como Arduino una Raspberry Pi no
se puede ir variando dependiendo de que deseen utilizar.
Entonces aquí vemos que vamos a comparar tanto la parte real como la parte simulada.
Entonces acá tenemos los valores de referencia en primer lugar vamos a estar trabajando con velocidades
positivas entonces vamos a trabajar con una velocidad de 0.1 tenemos aquí como pueden ver la velocidad
de referencia y también vamos a almacenar los datos también de las velocidades medidas que vamos a obtener
de los coches entonces para ver si también el controlador P.I que implementamos está haciendo su trabajo
entonces tenemos aquí ya lo habíamos visto el puerto serial y todo eso esto va a ir variando dependiendo
del cómo vamos a estar trabajando en el 5 en este caso y acá ya lo habíamos visto anteriormente como
obteníamos de esta parte de aquí y bueno aquí lo que estoy haciendo es redondear este valor de referencia
a dos decimales recuerden que aquí ya no voy a enviar valores enteros y no voy a enviar ya datos flotantes
eso es el cambio que estamos que estamos realizando entonces también lo vamos a enviar separado de una
coma y como les mencionaba solamente vamos a estar enviando dos decimales entonces acá tenemos la parte
de envío de datos y acabamos de leer los datos en este caso les había mencionado que vamos a recibir
datos float entonces aquí cambiamos.
Anteriormente estaba comode pero como vamos a estar trabajando con datos de tipo float cambiamos a f
entonces con eso nos aseguramos de recibir los datos y aquí ya no sería r.p.m si no tendríamos la velocidad
lineal y también acá tendríamos la velocidad angular.
Entonces esas son las variables que vamos a estar midiendo y como vemos acá estamos almacenando ya en
el vector de ceros que habíamos creado arriba luego acá ya tenemos la parte del robot simulado como
pueden ver.
Estamos aplicando las velocidades de referencia y acá tenemos ya la parte real entonces nos vamos a
centrar en la parte real como ven aquí el fin real va a ser igual al fin real más acabamos de aplicar
los valores medidos como pueden observar.
Entonces vamos a ver el resultado tanto del robot real como del robot simulado.
Entonces acá tenemos la parte real como pueden ver.
El cálculo es similar simplemente el cambio de variables nada más y acá lo que vamos a hacer es monitorear
el tiempo que se ejecuta el código para ver si está dentro de los parámetros que es de 100 milisegundos
entonces todo este código debe ejecutarse en menos de ese tiempo para asegurar nuestro tiempo de muestreo.
Luego acá como ven estamos enviando a velocidades de referencia de cero para parar al motor luego acá
tenemos la parte de gráficas como vamos a estar comparando las velocidades medidas con las de referencia
para ver que cuál es el resultado.
Adicionalmente vamos a plantear la trayectoria como ven acá la trayectoria real versus la trayectoria
simulada versus la trayectoria real entonces vamos a estar viendo esas gráficas a partir de aquí ya
lo habíamos revisado ya lo había indicado en videos anteriores entonces esto no me voy a centrar simplemente
aquí lo que ha cambiado en la función del dibujo del robot es que le ha aumentado otro parámetro que
es la escala entonces el robot que estoy utilizando como ven es pequeño entonces como pueden ver aquí
es pequeño entonces la simulación también voy a tratar de que tenga las mismas dimensiones entonces
por eso le he dado esta escala.
Entonces acá como vamos a estar comparando vamos a dibujar puntos para ver en dónde inicia el robot
y dónde termina como pueden ver acá el punto en color verde va a ser donde inicia y luego cuando finaliza
va a ser en el punto rojo entonces aquí podemos observar toda la parte que ya habíamos revisado anteriormente.
Entonces no me voy a centrar en eso simplemente vamos a estar viendo los resultados de Arduino.
Entonces en primer lugar vamos a enviar una velocidad de referencia de 0.1 metros sobre segundos y vamos
a observar el resultado
como podemos observar el resultado es el esperado.
El robot ha avanzado hacia adelante y entonces podemos ver aquí cuál es el resultado tenemos la trayectoria
que realizó el robot.
Como ven acá es la roja entonces podemos observar que es similar a la simulada y acá tenemos la parte
de referencias como pueden ver en este caso aquí tenemos la lectura tanto de la velocidad como de la
velocidad lineal y la velocidad angular acá podemos ver pequeñas variaciones.
Esto podríamos mejorar dependiendo de cómo esté el algoritmo Paik que habíamos implementado entonces
pero sin embargo me da buenos resultados y podemos ver acá el tiempo de muestreo acá podemos ver que
el tiempo ha sobrepasado los 0.1 segundos que era el tiempo de muestreo.
En este caso la lectura me lanza esto ya que estoy trabajando con algunos programas entonces también
afecta la lectura del tiempo como pueden ver aquí en algunos instantes del tiempo es más bajo.
Entonces se ve afectado un poco la medida entonces pero estamos dentro del rango esto no hay ningún
problema entonces estamos trabajando bien.
Ahora vamos a trabajar con velocidades negativas.
Vamos a enviar a una velocidad negativa y vamos a ver que el robot va a ir hacia atrás.
Entonces vamos a ejecutar este código y vamos a observar
como podemos observar este es el resultado.
Tenemos aquí la trayectoria que realizó el robot en la parte roja y la parte azules la simulada y como
ven es similar.
Entonces vamos a ver las otras gráficas el tiempo de muestreo como ven en este caso llega un promedio
de ser punto cero siete segundos que equivaldría a 70 milisegundos.
Entonces está dentro del rango como les mencionaba esto está variando entonces acá podemos observar
el resultado de la velocidad como pueden ver aquí tenemos estas pequeñas variaciones es por ello que
no nos llegamos a exactamente a la parte simulada si estas curvas fueran perfectas llegaríamos exactamente
a las curvas de la parte real.
Ahora vamos a cambiar esto vamos a enviar ya velocidades angulares.
Vamos a mandar simplemente con un valor de cero y vamos a poner una velocidad angular positiva de un
radian sobre segundos entonces vamos a correr este código y vamos a observar el resultado
como podemos observar aquí tenemos la trayectoria que hizo en este caso podemos ver que la trayectoria
que hace simplemente es un punto.
Esto debido a que el robot está girando sobre su propio eje.
Ahora vamos a cambiar la velocidad vamos a mandar una velocidad negativa y vamos a ver el resultado
vamos a correr el código
y como podemos observar obtenemos el mismo punto que habíamos visto anteriormente.
Esto debido a que está girando sobre su propio eje pero ahora en sentido contrario al que habíamos visto
anteriormente acá tenemos el tiempo de muestreo como les habían mencionado varía bastante.
Y acá tenemos el resultado de la velocidad de referencia y las velocidades medidas luego vamos a intentar
hacer otros cambios.
Vamos a ver acá vamos a cambiar esto vamos a ver ya la combinación.
Vamos a enviar una velocidad de 0.2 metros sobre segundos y vamos a enviar una velocidad positiva de
un radian sobre segundo.
Entonces corremos el programa y vamos a ver el resultado.
Como observamos en la emulación del robot y la parte real lo que dibuja es una trayectoria acá podemos
ver el resultado.
Tenemos una trayectoria tipo círculo entonces aquí podemos ver que se asemeja bastante a la parte real
y simulada.
Entonces podemos observar la trayectoria que tiene aquí tenemos el tiempo de muestreo y también las
gráficas que podemos observar acá.
En este caso podemos ver que las gráficas son un poco más suaves por eso es que se aproxima tanto al
a la trayectoria que nosotros le estamos ingresando entonces el resultado Coven es bastante bastante
bueno para el algoritmo que hemos implementado entonces lo que vamos a hacer es probar y darle un poco
más de velocidades y vamos a observar que qué pasa en este caso vamos a cambiar esta velocidad vamos
a aumentarla y vamos a disminuir esta velocidad angular a 0.8 entonces vamos a ejecutar el código y
vamos a observar
como podemos observar el resultado que obtuvimos.
Es un círculo que tiene un mayor diámetro pero acá podemos ver la parte real de color rojo y la parte
simulada de color azul y podemos ver que en este caso no coinciden tanto la simulada como la Real pero
en forma sí pero existe un pequeño desplazamiento.
Esto se debe a muchos factores luego en otro curso vamos a estar revisando algoritmos de control en
el cual nosotros vamos a ingresar una trayectoria deseada por ejemplo digamos un círculo y el robot
lo que va a hacer es tratar de seguir esa trayectoria.
Entonces con el algoritmo de control vamos a ver que ahí sí coinciden las dos señales entonces aquí
simplemente estamos revisando la parte de modelamiento para luego ya en el curso de algoritmos de control
aplicados a la robótica vamos a ver cómo cómo obtener esto.
Entonces vamos a ver las otras gráficas del tiempo de muestreo y acá podemos observar las curvas de
la velocidad lineal y de la velocidad angular entonces podemos ver que el resultado es bastante óptimo.
Como resultado podemos observar que la parte simulada nos ayuda bastante porque podemos hacer un estudio
de nuestro robot y luego podemos ya implementarlo y verificar que exactamente se cumple la parte de
simulación con la parte real.
Entonces como habíamos mencionado nosotros aquí estamos considerando un modelo cinemático más no la
dinámica entonces.
Por eso también no sigue la perfección digámoslo así debido a que no estamos considerando algunos factores.
Sin embargo gracias al controlador Poy es que logramos obtener un mejor resultado.