TITULACIÓN: Máster en Ingeniería...

DISEÑO, SIMULACIÓN Y CONSTRUCCIÓN DE UN SISTEMA CARRO‐PÉNDULO MEDIANTE LA TECNOLOGÍA LEGO

TITULACIÓN: Máster en Ingeniería Electrónica

AUTOR: Alex Calvó Gallego DIRECTOR: Albert Oller Pujol

FECHA: Septiembre de 2012

Prólogo y agradecimientos

Este proyecto ha sido realizado debido al interés personal acerca de diversos temas

relacionados con la robótica y con mis estudios cursados, de entre los que cabe destacar:

En primer lugar, un interés en los sistemas self-balancing en general, que se ha

acrecentado por el reciente auge de los vehículos personales Segway

(http://www.segway.com/) y muchas de sus variantes que están apareciendo actualmente.

En segundo lugar, la motivación por integrar los nuevos conocimientos adquiridos en la

realización del Máster en Ingeniería Electrónica y enlazarlos con los conocimientos

previamente adquiridos en la carrera Técnica.

En tercer lugar, el interés por realizar un proyecto en el que se trabaje con alguna

técnica de control. El motivo de este interés es una consecuencia del nuevo plan de estudios,

puesto que en el Máster en Ingeniería Electrónica se han extinguido dos asignaturas de control

que estaban presentes en la carrera Superior.

En cuarto y último lugar, el deseo de realizar un proyecto que surgiera de una

propuesta personal por el hecho de realizar una variación respecto al proyecto presentado en

la carrera Técnica, cuya temática estaba predeterminada.

Todos los intereses y motivaciones anteriores han hecho posible la realización de este

proyecto, en el que debo destacar la tutela realizada por el Dr. Albert Olleg Pujol, a quien

agradezco la ayuda prestada y los conocimientos que ha compartido a lo largo de la realización

del proyecto.

http://www.segway.com/

Índice

Índice

1. Introducción ............................................................................................... 6

1.1. ¿Qué es Lego Mindstorms NXT 2.0? ...........................................................................7

1.2. ¿Porqué se ha escogido la plataforma Lego Mindstorms NXT 2.0? .............................8

1.3. Antecedentes del sistema carro-péndulo con LEGO Mindstorms ...............................9

1.3.1. A LEGO-Based Control Experiment.....................................................................9

1.3.2. NXTWay-G, Ryo Watanabe .............................................................................. 10

1.3.3. Otros proyectos................................................................................................ 11

1.4. Factor diferenciador de este proyecto ..................................................................... 12

2. Modelo teórico del sistema carro-péndulo .......................................... 13

2.1. Introducción al sistema carro-péndulo (cart-pole) ................................................... 13

2.2. El péndulo como masa puntual o el péndulo como varilla ........................................ 14

2.3. Tipos de modelos utilizados para la descripción del sistema .................................... 15

2.4. Análisis del sistema carro-péndulo........................................................................... 16

2.4.1. Ecuaciones que describen el sistema carro-péndulo.......................................... 17

3. Simulación del sistema carro-péndulo .................................................. 22

3.1. Matlab como herramienta de simulación................................................................. 22

3.2. Obtención de los parámetros del modelo ................................................................ 26

3.2.1. Obtención de la masa del péndulo.................................................................... 26

3.2.2. Obtención de la masa del carro ........................................................................ 27

3.2.3. Determinación de la longitud del péndulo ........................................................ 28

3.3. Simulaciones ........................................................................................................... 31

3.3.1. Lugar geométrico de las raíces con la planta linealizada ................................ 31

3.3.1.1. Linealización de la planta .......................................................................... 31

3.3.1.2. Simulación con Sisotool ............................................................................ 33

3.3.1.3. Verificación del LGR mediante el análisis de la respuesta .......................... 35

3.3.1.3.1. Modelo en Simulink creado ................................................................... 35

3.3.1.3.2. Simulación de la planta linealizada con control proporcional ................. 37

3.3.2. Simulación en dominio temporal continuo de la planta no linealizada ........... 39

3.3.2.1. Modelo que se va a simular ...................................................................... 39

Índice

3.3.2.2. Sintonizador de PID de Matlab ................................................................. 41

3.3.2.3. Restricciones de nuestro sistema.............................................................. 44

3.3.2.3.1. Restricciones en el ángulo del péndulo .................................................. 44

3.3.2.3.2. Restricciones en el actuador (motor LEGO Minstorms NXT 2.0) .............. 44

3.3.2.4. Sintonizador PID de Matlab con las restricciones de nuestro modelo........ 46

3.3.2.5. Simulación del sintonizador de PID ........................................................... 48

3.3.2.6. Verificación de los valores obtenidos del sintonizador .............................. 50

3.3.2.6.1. Respuesta a un ángulo inicial ................................................................ 50

3.3.2.6.2. Respuesta a una perturbación ............................................................... 54

3.3.2.7. Adición de restricciones en el actuador .................................................... 56

3.3.3. Simulación en dominio temporal continuo de la planta linealizada ................ 59

3.3.3.1. Respuesta de la planta linealizada utilizando el PID anterior ..................... 59

3.3.3.2. Modificación de los parámetros del PID.................................................... 61

3.3.4. Discretización del sistema y simulación ........................................................... 64

3.3.4.1. Discretización de la planta y del controlador............................................. 64

3.3.4.2. Simulaciones con la planta y el controlador discretizados ......................... 66

3.3.4.2.1. Simulación con el PID obtenido de la planta no linealizada .................... 66

3.3.4.2.2. Simulación con el PID obtenido de la planta linealizada ......................... 67

4. Pruebas en el sistema real ..................................................................... 72

4.1. Construcción física del robot.................................................................................... 72

4.2. Entorno de programación ........................................................................................ 74

4.3. Programación del sistema de control del robot ........................................................ 75

4.4. El sensor: el giroscopio ............................................................................................ 76

4.4.1. HiTechnic Gyro Sensor ..................................................................................... 76

4.4.1.1. Pruebas estáticas realizadas con el giroscopio de HiTechnic ..................... 78

4.4.1.2. Pruebas dinámicas realizadas con el giroscopio de HiTechnic ................... 81

4.5. Código final ............................................................................................................. 85

4.6. Pruebas finales del robot ......................................................................................... 89

4.6.1. Comportamiento del robot sin perturbaciones ................................................. 89

4.6.2. Comportamiento del robot frente a perturbaciones.......................................... 93

5. Conclusiones............................................................................................. 95

5.1. Posibles mejoras ...................................................................................................... 96

6. Anexos ...................................................................................................... 98

Índice

6.1. Anexo 1: Información sobre LEGO Mindstorms NXT 2.0 ........................................... 98

6.2. Anexo 2: Códigos de Bricx Command Center.......................................................... 100

6.2.1. Código para la prueba de velocidad del robot................................................. 100

6.2.2. Código para la prueba de velocidad del robot................................................. 100

6.2.3. Código para las pruebas del giroscopio de HiTechnic ...................................... 101

6.2.4. Código final para mantener en equilibrio el robot........................................... 102

6.3. Anexo 3: Instrucciones de montaje del robot ......................................................... 105

6.4. Anexo 4: Documentos de Microsoft Excel .............................................................. 105

6.5. Anexo 5: Simulaciones de Matlab .......................................................................... 105

7. Referencias............................................................................................. 107

Introducción

6

1. Introducción

Este proyecto, titulado Diseño, simulación y construcción de un sistema carro-péndulo

mediante la tecnología Lego, tiene por objetivo el desarrollo del proceso completo de

modelización, simulación e implementación de un sistema de control automático de la

oscilación de un péndulo sobre una base móvil (también conocido como Cart-pole), aplicado

sobre un robot construido con la plataforma Lego Mindstorm.

Los apartados en los que se ha estructurado son los siguientes:

Figura 1: Esquema básico

1. Obtención de un modelo teórico: Es la descripción mediante ecuaciones de la dinámica

del sistema cart-pole que se propone realizar, la modelización del sistema real.

2. Simulación del sistema: A partir de las ecuaciones obtenidas para la descripción del

sistema, se realizará una simulación de su comportamiento y se obtendrá el sistema de

control que permitirá al robot mantener el equilibrio.

3. Implementación en el sistema real: Comprende la construcción física del modelo y la

utilización del control obtenido en la simulación del sistema para actuar sobre el modelo

real.

Los tres apartados se realizarán de forma secuencial, aunque entre la simulación y la

implementación existirá una estrecha relación bidireccional, puesto que ciertos parámetros de

la simulación se obtendrán mediante experimentos con el sistema real, con la finalidad de

aumentar la similitud en cuanto a resultados entre ambos apartados.

Quizá el hecho que más pueda sorprender en un primer momento es la elección de

una plataforma como Lego Mindstorm NXT 2.0, puesto que existe una gran diversidad de

implementaciones físicas para realizar un montaje con el que llevar a cabo el objetivo de

controlar un sistema carro-péndulo. Por ello, el primer paso realizado será conocer esta

plataforma para poder justificación su elección.

Introducción

7

1.1.¿Qué es Lego Mindstorms NXT 2.0?

LEGO Mindstorms es un kit de robótica educativa desarrollado por LEGO en

colaboración con National Instruments. Concretamente, la versión NXT 2.0 es la evolución de

la anterior versión NXT, que a su vez era la evolución de la versión RCX.

Figura 2: Evolución desde LEGO Mindstorm RCX hasta LEGO Mindstorm NXT 2.0

Información acerca de LEGO Mindstorms existe y en grandes cantidades en internet,

por lo que únicamente se ha consultado los aspectos de mayor interés a lo largo de la

realización de este proyecto.

En resumen, se trata de un sistema completo de sensores (algunos básicos de LEGO y

otros desarrollados por fabricantes externos), actuadores (básicamente motores) y CPU, que

junto con la sencillez en la construcción física gracias a los bloques LEGO, permite disponer de

una herramienta de programación y experimentación muy potente y con un coste

relativamente bajo respecto con algunas maquetas de laboratorio actuales. Para más

información acerca de los sensores, actuadores y CPU consultar [1].

Contrariamente a lo que se pueda imaginar en un primer momento, no se trata de un

juguete, y se puede demostrar simplemente con una rápida búsqueda en Internet para

encontrar proyectos de ingeniería de control avanzada [2], tal y como se pretende hacer en

este proyecto.

Por ello esta herramienta está siendo aceptada como una herramienta para la

docencia y se están realizando actualmente competiciones a nivel preuniversitario, como la

FIRST LEGO League [3].

Una vez conocemos qué es LEGO Mindstorms NXT 2.0, la siguiente cuestión será

justificar su elección en la realización de este proyecto, como se muestra a continuación.

Introducción

8

1.2.¿Porqué se ha escogido la plataforma Lego Mindstorms NXT 2.0?

Como se ha comentado anteriormente, una de las principales ventajas de la elección

de Lego Mindstorms NXT 2.0 es que es un “ecosistema”: dispone de todos los elementos

necesarios para la realización de este proyecto, con un coste relativamente asequible.

Figura 3: Ecosistema LEGO Mindstorms NXT 2.0

Si intentáramos montar el sistema carro-péndulo con componentes individuales, de

distintos fabricantes, etc. el trabajo sería realmente muy extenso y de una dificultad muy

elevada, no únicamente por el montaje mecánico, sino por el funcionamiento conjunto de

todos los elementos, por su compatibilidad, etc.

El objetivo de este proyecto no es el montaje del robot que simula el sistema carro-

péndulo, sino su programación. Nos vamos a centrar en el estudio y la programación de este

sistema, por lo que la implementación física debe ser lo más sencilla posible. La estructura

física no va a ser el centro de atención en este proyecto.

Por lo tanto se ha determinado que la elección de la plataforma LEGO Mindstorm NXT

2.0 es la opción más adecuada por los siguientes motivos:

- En primer lugar, por la sencillez de la implementación física del robot.

- En segundo lugar, por la compatibilidad entre sensores, actuadores y CPU.

- En tercer lugar, por la facilidad de programación puesto que existe una gran

variedad de entornos para programar el Brick (CPU).

En el anexo 1 se encuentra disponible la información más importante sobre LEGO

Mindstorms NXT 2.0 para la realización de este proyecto.

Por lo tanto, tras justificar la elección de este sistema para desarrollar este proyecto, a

continuación veremos algunos de los antecedentes que existen relacionados con el desarrollo

del sistema que se propone.

Introducción

9

1.3.Antecedentes del sistema carro-péndulo con LEGO Mindstorms

Desde la aparición de la plataforma LEGO Mindstorms en todas sus versiones (RCX,

NXT y NXT 2.0), se ha desarrollado multitud proyectos, cada uno con su propia metodología,

cuyo objetivo era la construcción y programación de un robot equilibrista.

1.3.1. A LEGO-Based Control Experiment

Sin duda el primer referente que apareció fue el

siguiente artículo: A LEGO-Based Control Experiment [4],

que apareció posteriormente en la revista de automática y

control IEEE Control Systems Magazine, a finales de 2004.

Sus autores eran Peter Gawthrop, miembro y profesor del

Departamento de Ingeniería Mecánica de la Universidad de

Glasgow, y Euan McGookin, tambien profesor y miembro

del Departamento de Ingeniería Eléctrica y Electrónica de la

misma universidad.

El experimento que realizaron era un sistema carro-

péndulo montado sobre la plataforma LEGO Mindstorms

RCX, el modelo más avanzado en ese momento. Sin entrar

en muchos detalles, surgieron problemas muy variados

debido a las limitaciones de los sensores del RCX. Por

ejemplo, el sensor de ángulo tenía una resolución muy baja,

de 22,5°; los motores no disponían de tacómetros para

determinar la velocidad angular y la posición (necesarios

para el caso de querer realizar un control de posición), etc.

Todas las dificultades que surgieron se superaron gracias a la utilización de elementos

externos al entorno RCX, y el modelo resultó ser operativo.

Como se ha comentado, la mayoría de dificultades surgieron debido a las limitaciones

en cuanto a sensores y actuadores de la plataforma existente en ese momento, el RCX. A

medida que salieron al mercado los nuevos modelos, como el NXT, el NXT 2.0 actual, y el

futuro NXT 3.0, estos problemas se fueron solucionando gracias a la compatibilidad de

sensores de fabricantes externos.

Avanzando temporalmente, uno de los experimentos más importantes de un carro-

péndulo con una versión más moderna de Mindstorm NXT es el experimento realizado por Ryo

Watanabe: el NXTWay-G, que se muestra a continuación.

Figura 4: A LEGO-Based Control Experiment

Introducción

10

1.3.2. NXTWay-G, Ryo Watanabe

Este experimento, realizado por el japonés Ryo Watanabe a principios de 2007, fue una de las grandes atracciones de LEGO Mindstorm para un público más interesado en la robótica.

En este experimento, como se puede observar en la imagen ya se utiliza la versión NXT

de Mindstorms. La principal novedad es la utilización de un giroscopio para la obtención de la velocidad angular de caída del robot para realizar el control. También se utiliza una cámara para evitar el choque contra paredes u otros objetos.

Pese a ser una versión más avanzada de Mindstorms NXT, algunos de los sensores

utilizados, como el giroscopio, tuvieron que adecuarse a la plataforma de LEGO de forma casera, puesto que todavía no existía el sensor giroscópico de Hi-Technic (el que se utilizará en este proyecto).

El robot equilibrista presentado por Ryo Watanebe supuso un antes y un después en la

creación experimental con LEGO Mindstorm. Este robot, además de mantener el equilibrio sobre dos ruedas, también tenía un control de posición. Mediante un mando de videoconsola conectado por USB a un ordenador, se le enviaba a través de una conexión Bluetooth las órdenes de movimiento.

Ryo Watanabe también realizó un estudio completo del comportamiento de los

motores de Lego NXT. Los datos obtenidos de estos experimentos se utilizaron en muchos experimentos posteriores para la modelización de los motores.

Lamentablemente la página web de Ryo Watanabe donde exponía todo el estudio realizado, así como el diseño y construcción del NXTWay-G se ha cerrado recientemente debido al fracaso del proyecto de la nube MobileMe, lugar donde se encontraba alojado el proyecto.

Figura 5: NXTWay-G de Ryo Watanabe

Introducción

11

1.3.3. Otros proyectos

Los dos proyectos comentados anteriormente son los más conocidos de todos los que

se han realizado con la plataforma LEGO Mindstorms.

Otros ejemplos de proyectos similares al que se va a realizar son los siguientes:

- NXT Two Wheels balancing robot tricks & keys [5]: se trata de un proyecto muy

similar al que se va a realizar. Utiliza el sensor giroscópico de Hi-Technic y un PID

para realizar el control.

- Get up, NXTway! [6]: en este caso es un proyecto que utiliza el sensor de luz para

mantener el equilibrio, del mismo modo que el famoso NXT Segway with Rider [7].

- NXTway-GS (Self-Balancing Two-Wheeled Robot) Controller Design [8]: este

proyecto es el más completo que podemos encontrar en internet. Se trata de la

simulación del sistema en Matlab, con el añadido que a partir de la simulación, en

Matlab se compila el código y se puede grabar en el brick de LEGO. Además cuenta

con una simulación visual de la dinámica del robot.

- Steve’s Legway [9]: se trata de un segway creado con LEGO Mindstorm RCX.

Además de mantenerse sobre dos ruedas, es capaz de realizar también la función

sigue-lineas (line follower).

Figura 6: de izquierda a derecha: NXT Two Wheels balancing robot tricks & keys [5], Get up, NXTway! [6], NXT Segway with Rider [7], NXTway-GS (Self-Balancing Two-Wheeled Robot) Controller Design [8], Steve’s Legway [9]

http://nxttwowheels.blogspot.com.es/

Introducción

12

1.4.Factor diferenciador de este proyecto

Ahora ya conocemos que es LEGO Mindstorms NXT 2.0, porqué se ha decidido utilizar

esta plataforma y los antecedentes en cuanto a proyectos similares. La pregunta que nos podríamos plantear es la siguiente: ¿Por qué realizar este proyecto si ya se han realizado proyectos muy similares?

La respuesta a esta pregunta es la siguiente: La principal novedad que supone este proyecto respecto a los anteriormente

comentados es el deseo de realizar y cerrar un ciclo completo: En la mayoría de proyectos anteriores, no se ha unido la simulación con la

implementación, es decir, no ha habido un apartado de simulación teórica, y por lo tanto, los valores obtenidos para realizar el control del sistema carro-péndulo se han determinado experimentalmente, mediante un método de prueba-error. No se ha realizado el estudio teórico del sistema para determinar los valores del sistema de control.

Como se ha comentado anteriormente, en la mayoría de proyectos no se ha realizado

este estudio, pero ha habido algunos en los que sí se ha realizado. Pese a ello, cada estudio realizado ha sido diferente, ya sea por diferencias en el modelo teórico realizado o por diferencias en el sistema de control utilizado para mantener el equilibrio del sistema.

Por lo tanto, el objetivo de este proyecto no es únicamente conseguir que el robot se

mantenga en equilibrio, sino conocer el comportamiento del sistema mediante las simulaciones y poder implementar el control obtenido en las simulaciones sobre el sistema real.

Para ello, el primer paso que se realizará en este proyecto será la obtención de un

modelo matemático con el que se describirá la dinámica del sistema cart-pole, para poder llevar a cabo posteriormente una simulación.

Modelo teórico del sistema carro-péndulo

13

2. Modelo teórico del sistema carro-péndulo

2.1.Introducción al sistema carro-péndulo (cart-pole)

El sistema carro-péndulo es una variante del sistema de péndulo invertido.

El péndulo invertido es un problema clásico que se formula en dinámica y en teoría de

control, y que consiste en mantener una cierta masa en equilibrio por encima del eje de

rotación del sistema.

El sistema carro-péndulo es un sistema de péndulo invertido en el cual se utiliza una

base móvil (el carro) para conseguir mantener la masa (el péndulo) en equilibrio.

Figura 7: Sistema carro-péndulo

El análisis teórico que se va a realizar de este sistema ya se ha tratado en muchas

ocasiones. Sobre la modelización de este sistema ya existe mucha información, desde

contenido web hasta la publicación de diversos artículos en revistas especializadas.

Se trata de un sistema complejo sobre el que existen diversas soluciones para

modelarlo. Todas las soluciones son válidas pero presentan ciertas diferencias, ya sea por el

método utilizado para la representación de la dinámica del sistema o por el grado de

aproximación utilizado. Por ello, los resultados son distintos aunque conservan un cierto grado

de similitud.

Pese a la variedad en cuanto a la modelización del sistema se refiere, existe una

primera distinción que debemos realizar con la finalidad de centrarnos en mayor medida en un

tipo de modelización o en otro: la distinción entre un sistema en el que el péndulo se modele

como una masa puntual o un sistema en el cual la masa del péndulo se reparta a lo largo de

una varilla, como se explicará a continuación.


14

2.2.El péndulo como masa puntual o el péndulo como varilla

Es la primera distinción que debemos realizar con la finalidad de obtener el modelo

teórico deseado del sistema.

En primer lugar, se puede considerar el péndulo

como una masa puntual, es decir, toda la masa del péndulo

se encuentra concentrada en un punto, y la unión entre este

punto de masa (el péndulo) y la base del sistema (el carro)

es una barra de masa despreciable.

Como consecuencia, al tratarse de una barra de

masa despreciable el único factor de importancia de esta

barra es la longitud a la que se encuentra el péndulo

respecto del carro. En cuanto a dinámica se refiere, esta

barra no añadiría ningún término a las ecuaciones puesto

que su masa es nula.

En segundo lugar, se puede considerar el péndulo

como una varilla, es decir, la masa del péndulo se reparte

uniformemente a lo largo de una varilla de longitud

determinada pero sin anchura ni profundidad. Esta varilla

está conectada en uno de sus extremos a la base del

sistema, el carro.

Como consecuencia, al realizar la modelización de

este sistema, aparecen términos de inercias relacionados

con la dinámica de la varilla, y por ello las ecuaciones del

sistema se complican respecto a la consideración anterior

del péndulo como masa puntual.

Pese a que las ecuaciones que describen el sistema se compliquen, este último será el

sistema utilizado para llevar a cabo la modelización del sistema por el hecho de que permite

obtener un mayor grado de aproximación al sistema real que se pretende montar y analizar.

Aún así la modelización del sistema no dejará de ser una aproximación al modelo real,

puesto que en el modelo real el péndulo (que corresponde al cuerpo del robot) no será una

varilla, aunque se intentará realizar un montaje con el que se obtenga una mayor similitud a

una varilla.

El siguiente paso a realizar será el análisis del sistema carro-péndulo considerando el

péndulo como una varilla.

Figura 8: Péndulo como masa puntual

Figura 9: Péndulo como varilla


15

2.3.Tipos de modelos utilizados para la descripción del sistema

Como se ha comentado con anterioridad, este sistema ha sido objeto de numerosos

estudios documentados. Pese a que en cada uno de estos estudios se utiliza una metodología

concreta, las soluciones obtenidas presentan dos tendencias.

En primer lugar, tenemos las soluciones que representan la dinámica del sistema

mediante utilizando el Lagrangiano [10], que es una función matemática a partir de la cual

podemos obtener la evolución temporal del sistema.

Como ejemplo de la descripción matemática del modelo utilizando el Lagrangiano

podemos ver el artículo Cart-pole system: Equations of motion [11], de la asignatura Robot

Locomotion de la Universidad de Santa Bárbara, California.

En segundo lugar, existen los modelos en los que las ecuaciones de movimiento del

sistema se describen en variables de estado pero no se representan mediante el Lagrangiano.

La opción que se ha escogido para la representación del modelo carro-péndulo ha sido

la segunda, y los motivos de esta elección son los siguientes:

El primer y principal motivo es el desconocimiento en la representación del sistema

mediante el modelo Lagrangiano, puesto que no la he tratado en ninguna asignatura de los

estudios cursados.

El segundo motivo es el conocimiento sobre la descripción del sistema mediante las

variables de estado del mismo, contenido que he cursado recientemente en la asignatura de

Modelización y simulación de sistemas dinámicos del Máster en Ingeniería Electrónica.

Por lo tanto, el siguiente paso será realizar la descripción del sistema carro-péndulo,

considerando el péndulo como una varilla y obteniendo las ecuaciones en variables de estado.


16

2.4.Análisis del sistema carro-péndulo

Como se ha comentado anteriormente, la obtención de las ecuaciones que nos

permitan simular la evolución temporal del sistema ha sido objeto de numerosos estudios.

Además, se trata de un sistema complejo que requiere unos conocimientos de física

avanzados. Por estos motivos, para la descripción del sistema se recurrirá a uno de los estudios

realizados.

Para analizar el sistema carro-péndulo y obtener las ecuaciones que describen su

dinámica se utilizará el documento realizado por Razvan V.Florian [12], del Center for Cognitive

and Neural Studies (Coneural, Romania).

El análisis de este sistema se realizó debido a que uno de los posibles usos de un

sistema carro-péndulo es el testeo de algoritmos de aprendizaje.

El estudio que se realizó es una reformulación de estudios anteriores debido a que en

éstos se detectaron algunos errores que se propagaron a estudios posteriores.

Concretamente, uno de los estudios de mayor importancia en el que aparecían algunos errores

fue el que realizó Andrew G. Barto [13].

A continuación se describirá el proceso a seguir para la obtención de las ecuaciones

correctas de la dinámica del sistema carro-péndulo.


17

2.4.1. Ecuaciones que describen el sistema carro-péndulo

En primer lugar se muestra el dibujo esquemático del sistema que vamos a analizar:

Figura 10: Esquema del sistema carro-péndulo con fuerzas que intervienen

Las fuerzas y los parámetros que intervienen en el sistema carro-péndulo son:

Variable Descripción

N Fuerza normal de reacción del carro sobre el péndulo en la unión entre ambos.

-N Fuerza normal de reacción del péndulo sobre el carro (debido a la ley de acción-reacción).

Nc Fuerza normal de la superficie sobre el carro.

F Fuerza aplicada para mover el carro.

Ff Fuerza de fricción entre el carro y la superficie sobre la que se desplaza.

Gc Fuerza de la gravedad sobre el carro.

Gp Fuerza de la gravedad sobre el péndulo.

θ Ángulo de desviación del péndulo respecto a la posición de equilibrio.

ω Velocidad angular del péndulo.

Aceleración angular del péndulo.

mc Masa del carro.

mp Masa del péndulo.

ac Aceleración lineal del carro.

ap Aceleración lineal del péndulo.

l Distancia desde la unión entre el carro y el péndulo hasta el centro de masas del péndulo.

g Aceleración gravitatoria.

µc Coeficiente de fricción entre la superficie y el carro.

µp Coeficiente de fricción de la articulación que une el carro con el péndulo.

I Momento de inercia del péndulo relativo a la articulación

M Sumatorio de los pares no inerciales que actúan en el péndulo respecto a la articulación que lo une con el carro.

Tabla 1: Fuerzas y parámetros del sistema carro-péndulo


18

A continuación se describe el proceso para la obtención de las ecuaciones de

movimiento del sistema en variables de estado:

En primer lugar, aplicando la segunda ley de Newton [14] al movimiento lineal del carro

obtenemos la siguiente ecuación:

El siguiente paso consiste en descomponer las fuerzas y la aceleración de la ecuación

(1) en sus términos correspondientes en eje ‘x’ y en eje ‘y’. Teniendo en cuenta que ux y uy son

los vectores unitarios.

De este modo, podemos reescribir la ecuación (1) separándola en dos ecuaciones, una

para cada eje:

De las ecuaciones anteriores debemos encontrar expresiones para los términos Ff, Nx,

Ny y Nc.

Podemos reescribir la fuerza de fricción utilizando el modelo de Coulomb de fricción

[15], teniendo en cuenta que la superficie limita el movimiento del carro hacia arriba y hacia

abajo. La fuerza de fricción será:

En segundo lugar, aplicando la segunda ley de Newton [14] al movimiento lineal del

péndulo obtenemos la siguiente ecuación:

(6)

Del mismo modo que en el caso del carro, procedemos a descomponer las fuerzas y la

aceleración de la ecuación (6) en sus términos correspondientes en eje ‘x’ y en eje ‘y’.

En primer lugar descompondremos la fuerza ejercida por la gravedad sobre el péndulo:

A continuación descompondremos la aceleración del péndulo, ap. Esta aceleración se

sitúa en el centro de masas del péndulo, y es debida a la composición de:

- La aceleración del carro al que está unido el péndulo:


19

- La rotación del péndulo a una velocidad angular, que podemos escribirla como:

- La aceleración angular del péndulo, que podemos escribirla como:

Por lo tanto, podemos reescribir la aceleración del péndulo de la siguiente manera:

Donde:

Es el vector que representa la posición del centro de masa del péndulo respecto a la

articulación sobre la cual rota el péndulo. Sustituyendo todas las equivalencias anteriores en

(7) obtenemos:

A continuación realizamos el producto vectorial de los vectores unitarios para

simplificar la ecuación anterior:

Y obtenemos el siguiente resultado:

El siguiente paso consiste en introducir la ecuación (15) en la ecuación (6) y

descomponer las fuerzas y la aceleración de la ecuación (6) en sus términos correspondientes

en eje ‘x’ y en eje ‘y’:

En tercer lugar, aplicando la segunda ley de Newton [14] al movimiento rotatorio del

péndulo alrededor de la articulación obtenemos la siguiente ecuación:


20

Donde:

Es el sumatorio de los pares no inerciales actuando en el péndulo respecto de la

articulación que lo une con el carro.

Es el momento de inercia del péndulo respecto de la articulación que lo une con el

carro.

Se puede interpretar como el par generado por la fuerza inercial causada por la

aceleración del carro.

Sustituyendo (20), (21) y (22) en (19), obtenemos:

Una vez hemos llegado a este punto del análisis, el siguiente paso será reordenar y

agrupar las ecuaciones obtenidas. En primer lugar, sustituiremos Nx de la ecuación (16) en la

ecuación (3):

Y a continuación sustituimos la expresión obtenida de la aceleración lineal de la

ecuación (24) en la ecuación (23) y obtenemos:

El siguiente paso es aislar Ny de la ecuación (17) y sustituirla en la ecuación (4):

Y a continuación sustituimos Nc de la ecuación (26) en la ecuación (5):


21

Finalmente, el último paso a realizar es introducir la expresión encontrada para la

fuerza de fricción de la ecuación (27) en las ecuaciones (24) y (25):

Las ecuaciones anteriores son las ecuaciones finales a partir de las cuales podremos

simular y representar la dinámica del sistema.

La primera ecuación nos permite obtener y representar el movimiento lineal del

sistema puesto que podemos obtener la aceleración lineal, que se puede integrar para obtener

la velocidad lineal, y si se vuelve a integrar podemos obtener la posición del robot.

La segunda ecuación nos permite obtener y representar el movimiento angular del

péndulo puesto que tenemos la aceleración angular, que se puede integrar para obtener la

velocidad angular, y si se vuelve a integrar podemos obtener el ángulo de desviación respecto

al punto de equilibrio.

Si suponemos nulos los términos de fricción, obtenemos las siguientes ecuaciones:

De estas dos ecuaciones, únicamente se utilizará la que permite obtener el

movimiento angular del péndulo, puesto que el control que se va a realizar en este proyecto

únicamente permite al robot mantener el equilibrio sin tener en cuenta el movimiento lineal

del robot, es decir, sin realizar un control de posición.

Una vez se ha obtenido las ecuaciones que permiten describir el comportamiento

dinámico del sistema carro-péndulo, el siguiente paso que se realizará será la simulación del

sistema carro-péndulo utilizando las ecuaciones obtenidas.

Simulación del sistema carro-péndulo

22

3. Simulación del sistema carro-péndulo

En este capítulo se va a simular el modelo obtenido en las ecuaciones formuladas

anteriormente. Para ello primero en primer lugar se escogerá el entorno en el que se realizará

la simulación. A continuación se llevará a cabo la obtención de los parámetros necesarios para

la simulación, y por último se realizará un conjunto de simulaciones del sistema.

3.1.Matlab como herramienta de simulación

El software más adecuado para llevar a cabo el análisis y la simulación este sistema es

Matlab debido a la facilidad de implementación de funciones matemáticas, de diseño y análisis

de modelos y de representación gráfica de este programa. La versión utilizada es la 7.9.0

(R2009B).

Concretamente, se utilizará Simulink: es un entorno para la simulación multidominio y

el diseño basado en modelos para sistemas dinámicos y embebidos [16].

Simulink incluye un ejemplo de gran interés para este proyecto. Se trata de una

simulación de un péndulo invertido. Para acceder a él, debemos teclear el comando slcp en el

Command Window de Matlab.

A continuación, se abrirá una ventana con el siguiente modelo de Simulink:

Figura 11: Ejemplo en Matlab de la simulación de un sistema carro-péndulo


23

Este modelo cuenta con una animación para el comportamiento del sistema:

Figura 12: Animación del sistema carro-péndulo del modelo sldp de Matlab

En este modelo el control que se utiliza para mantener el sistema en equilibrio es un

Fuzzy. Además, también dispone de un control de posición, y gracias a él, en la animación

podemos mover libremente el péndulo con el ratón del ordenador.

Lo importante de este ejemplo es lo siguiente: si accedemos al bloque Cart & Pole

Dynamics (Clic derecho, Explore), encontramos el siguiente subsistema:

Figura 13: Subsistema Cart & Pole Dynamics

A continuación se analizará este subsistema, y veremos que es la modelización de las

dos ecuaciones que habíamos obtenido anteriormente en el análisis matemático del sistema.

En primer lugar, distinguiremos entre las dos ecuaciones: la ecuación a partir de la cual

obtenemos la aceleración angular es (1) y la ecuación a partir de la cual se obtiene la

aceleración lineal es (2):


24

Figura 14: Ecuaciones del subsistema Cart & Pole Dynamics

La primera ecuación nos permite realizar el control para mantener el sistema en

equilibrio y la segunda ecuación nos permite realizar el control de posición del sistema.

Como se ha explicado con anterioridad, en este proyecto únicamente vamos a realizar

un control para mantener el sistema en equilibrio, por lo que únicamente vamos a analizar la

primera ecuación.

Tenemos el siguiente diagrama de bloques:

Figura 15: Diagrama de bloques para mantener el equilibrio del sistema

En primer lugar, en (1) tenemos un multiplexor que nos agrupará cuatro señales, con la

finalidad de reducir el número de entradas al bloque (2).

Las entradas de este multiplexor serán:

Entrada Variable Descripción

u(1) F Fuerza que aplica el controlador sobre el actuador para mover el carro.

u(2) sin(θ) Seno del ángulo de desviación del péndulo respecto a la posición de equilibrio.

u(3) cos(θ) Coseno del ángulo de desviación del péndulo respecto a la posición de equilibrio.

u(4) Velocidad angular del péndulo.

Tabla 2: Entradas del multiplexor de la Figura 20


25

En segundo lugar (2), tenemos un bloque que es un Function Block. En él, se ha

implementado la siguiente ecuación:

(g*u(2)+u(3)*((-u(1)-m*l*u(4)*u(4)*u(2))/(mc+m)))/(l*(4/3-(m*u(3)*u(3))/(mc+m)))

Si procedemos a reescribir esta ecuación de una forma más visual:

Si ahora sustituimos las entradas por su variable descritas en la tabla 2, obtenemos:

Como podemos ver, es la misma ecuación que habíamos determinado anteriormente,

teniendo en cuenta que la masa del péndulo en este caso es m y en la modelización que

habíamos realizado era mp:

La importancia de esta equivalencia es la siguiente: un software de la trascendencia de

Matlab utiliza el mismo modelo de ecuaciones para la simulación del sistema que el que se va

a utilizar en este proyecto, y que se había definido previamente al conocimiento de este

ejemplo.

Como vemos en la ecuación anterior, la salida del bloque (2) corresponde a la

aceleración angular. Si integramos la aceleración angular mediante el bloque (3) obtenemos la

velocidad angular. Si integramos la velocidad angular mediante el bloque (4) obtenemos la

posición angular, es decir, el ángulo de desviación respecto al punto de equilibrio.

Una vez analizado este subsistema, se ha decidido utilizar el diagrama de bloques de la

Figura 20 como planta del sistema que vamos a simular porque las ecuaciones son las mismas

que se habían planteado.


26

3.2.Obtención de los parámetros del modelo

Una vez escogido el entorno de simulación, el siguiente paso consiste en obtener los

parámetros que aparecen en la ecuación que describe el comportamiento dinámico del

sistema, la ecuación de la planta del sistema. Esta ecuación es la que se ha obtenido

anteriormente:

3.2.1. Obtención de la masa del péndulo

Tenemos la constante mp, que es la masa del péndulo.

Este valor se ha obtenido utilizando una báscula de precisión. En este caso se ha

utilizado una báscula de precisión de cocina, modelo Fagor BC 300 X. Se puede consultar sus

características técnicas en [17].

Para la obtención de este parámetro, en primer lugar debe realizarse el montaje del

robot y excluir el “carro” del robot, que son las ruedas. Este montaje se encuentra disponible

en el anexo 3, y se explicará posteriormente en el capítulo 5.

Se ha obtenido dos valores para mp, distinguiendo entre si la alimentación del robot es

con pilas alcalinas (6) o con batería oficial de LEGO Mindstorms NXT 2.0 [18].

- Valor de mp para alimentación con pilas alcalinas: 557 g.

Figura 16: Masa del péndulo con pilas alcalinas: 557 g.


27

- Valor de mp para alimentación con batería oficial de LEGO: 531 g.

Como se puede observar, existe una pequeña diferencia de peso entre ambos tipos de

alimentación, aproximadamente de 30 gramos.

Para la realización de las simulaciones, se utilizará el parámetro más restrictivo, que en

este caso es cuando se alimenta el sistema mediante pilas alcalinas, puesto que el peso del

péndulo es superior.

3.2.2. Obtención de la masa del carro

Tenemos la constante mc, que es la masa del carro. Su valor se determinará utilizando

el mismo instrumento de medición que en el caso anterior.

En este caso, la masa del carro corresponderá al peso de ambas ruedas.

- Valor de mc obtenido: 68 g.

En último lugar, tenemos la constante l, que es la distancia desde la articulación que

une el carro con el péndulo hasta el centro de masas del péndulo.

Figura 17: Masa del péndulo con batería oficial LEGO: 531 g.

Figura 18: Masa del carro: 68 g.


28

La obtención de este parámetro comporta una mayor dificultad. El problema es el

siguiente: al realizar la modelización del sistema, el péndulo se modela como una varilla cuya

masa está uniformemente distribuida en toda su longitud.

Por lo tanto, lo más lógico sería pensar que el centro de masas se encuentra a la mitad

de la longitud del péndulo.

Pero en el caso real, el péndulo no tiene su masa uniformemente distribuida, y por lo

tanto, se requiere la utilización de un método para obtener este parámetro, tal y como se

explica a continuación.

3.2.3. Determinación de la longitud del péndulo

Para obtener el parámetro l necesitamos encontrar el periodo natural de oscilación del

péndulo (Tn). La ecuación que nos permitirá encontrar l conociendo Tn es la siguiente [19]:

Para obtener el periodo natural de oscilación recurriremos a la siguiente prueba:

Colocaremos el robot apoyado únicamente de los ejes de las ruedas. A continuación, lo

inclinaremos y lo dejaremos oscilar libremente, sin actuación de los motores, al mismo tiempo

que vamos leemos los datos del ángulo de oscilación gracias a un giroscopio.

(En este apartado vamos a obviar el código utilizado para llevar a cabo tal experimento

y el funcionamiento del giroscopio, que ya será comentado posteriormente)

Aunque el peso total del robot no intervenga en la ecuación anterior, se ha realizado

esta prueba para el caso de la alimentación del robot con batería LEGO y con pilas alcalinas.

Por lo tanto, los resultados de ambos experimentos deberían coincidir.

Los datos de los experimentos realizados se pueden consultar en el anexo 4.

Figura 19: Obtención del parámetro Tn


29

En primer lugar la gráfica obtenida correspondiente a la prueba realizada utilizando la

batería LEGO para la alimentación del Brick es la siguiente:

Gráfico 1: Datos obtenidos con batería para la determinar el periodo natural de oscilación

Para determinar el periodo natural de oscilación, se ha contado el número de mínimos relativos: 28, que se encuentran en un tiempo entre 3 y 19,5 segundos.

Por lo tanto, el periodo natural de oscilación resultante es de 0,589 segundos,

aproximadamente 0,6 segundos.

A continuación se muestran los resultados de la misma prueba utilizando pilas alcalinas

para la alimentación del Brick:

Gráfico 2: Datos obtenidos con pilas alcalinas para la determinar el periodo natural de oscilación

-25

-20

-15

-10

-5

0

5

10

15

20

25

0,0

10

,81

1,6

12

,41

3,2

14

,01

4,8

15

,61

6,4

17

,21

8,0

18

,81

9,6

11

0,4

11

1,2

11

2,0

11

2,8

11

3,6

11

4,4

11

5,2

11

6,0

11

6,8

11

7,6

11

8,4

11

9,2

1

Án

gulo

(°)

Tiempo (s)

Determinación del período natural de oscilación

-30

-20

-10

0

10

20

30

0,0

10

,85

1,6

92

,53

3,3

74

,21

5,0

55

,89

6,7

37

,57

8,4

19

,25

10

,09

10

,93

11

,77

12

,61

13

,45

14

,29

15

,13

15

,97

16

,81

17

,65

18

,49

19

,33

Án

gulo

(°)

Tiempo (s)

Determinación del período natural de oscilación


30

Para determinar el periodo natural de oscilación, se ha contado el número de mínimos

relativos: 27, que se encuentran en un tiempo entre 4 y 20 segundos.

Por lo tanto, el periodo natural de oscilación resultante es de 0,592 segundos,

aproximadamente 0,6 segundos.

Como se ha podido comprobar, el resultado es prácticamente el mismo en ambos

casos. Por lo tanto, se ha determinado que el periodo natural de oscilación es de 0,6 segundos.

Por lo tanto, si recurrimos a la ecuación presentada anteriormente:

Para tener una idea de donde se encuentra situado el centro de masas recurriremos a

la representación en 3D realizada con Lego Digital Designer [20]:

Figura 20: Centro de masas del robot

Como se puede observar en la figura anterior, el centro de masas del robot

corresponde a una posición ligeramente inferior al centro del Brick.

Una vez hemos determinado todos los parámetros necesarios, el siguiente paso

consistirá en simular el comportamiento del sistema.


31

3.3.Simulaciones

Se ha realizado un conjunto de simulaciones con las que se pretende conocer con la

máxima exactitud posible el comportamiento dinámico del sistema, con la finalidad de

encontrar un control PID con el que conseguir mantener el péndulo en equilibrio.

El primer paso que se realizará es comprobar si el sistema puede mantenerse en

equilibrio con un control proporcional, tal y como se explica a continuación.

3.3.1. Lugar geométrico de las raíces con la planta linealizada

La primera simulación que se realizará será la obtención del diagrama de polos y ceros

de la planta linealizada con la herramienta Sisotool de Matlab. En este caso se utiliza la planta

linealizada porque con la planta no linealizada no sería posible realizar esta simulación.

La finalidad de esta simulación es poder determinar si el sistema se podría mantener

en equilibrio con el control más básico de un PID: el control proporcional [21].

Para ello, lo primero que se debe hacer es linealizar la planta obtenida anteriormente.

3.3.1.1. Linealización de la planta

Recordamos la ecuación que teníamos:

El primer paso es pasar el denominador de la parte derecha multiplicando a la

aceleración angular:


32

A continuación aplicaremos las siguientes equivalencias, teniendo en cuenta que el

ángulo θ es un ángulo de valor cercano a cero:

Si aplicamos las anteriores equivalencias, obtenemos la siguiente ecuación:

A continuación aplicamos la transformada de Laplace y agrupamos términos:

Y finalmente obtenemos la siguiente función de transferencia:

Se puede observar el siguiente problema: teniendo un numerador negativo,

necesitaríamos que el sistema tuviera una realimentación positiva.

Este problema se puede solucionar de la siguiente forma: podemos definir que la

fuerza F es una fuerza negativa. De esta forma podríamos reeescribir la función de

transferencia como:

El siguiente paso consistirá en simular esta planta linealizada con Sisotool para

determinar el lugar geométrico de las raíces.


33

3.3.1.2. Simulación con Sisotool

Para realizar la simulación se ha escrito el siguiente código, disponible en el anexo 5:

clear;

%Parámetros: g=9.82; l=0.089; mc=0.068; m=0.557;

%Planta linealizada: num=1; den = [l*((4*(mc+m)/3)-m) 0 -g*(mc+m)]; planta=tf(num,den);

%Simulación: sisotool(planta);

Si ejecutamos este código se abrirá en una nueva ventana de Sisotool en la cual

podemos ver el siguiente LGR:

Figura 21: LGR con la planta linealizada

Se puede observar en la imagen el LGR marcado en color azul oscuro y los polos

marcados en un color magenta.

En la imagen anterior el sistema es inestable: tiene un polo real negativo y un polo real

positivo (este último es el que hace que sea inestable), ambos con parte compleja nula (reales

puros).


34

Si aumentamos la ganancia, la parte real de los polos en valor absoluto se va

acercando a cero. Concretamente, para una ganancia de 6,13 los polos pasan de ser reales

puros a convertirse en un doble polo con parte real e imaginaria nulas:

Figura 22: LGR de la planta linealizada, polo doble

Si continuáramos aumentando la ganancia, los polos tendrían la parte real nula y la

parte imaginaria no nula, del mismo módulo pero de signo contrario. Se trataría de un sistema

marginalmente estable.

El siguiente paso que se realizará será la verificación de esta simulación. Para ello, se

creará un modelo en Simulink con la planta linealizada. Se realimentará la planta y se le

añadirá una ganancia. Es decir, se realizará un control P.


35

3.3.1.3. Verificación del LGR mediante el análisis de la respuesta

3.3.1.3.1. Modelo en Simulink creado

El modelo Simulink creado es el siguiente, disponible en el anexo 5:

Figura 23: Modelo Simulink para la verificación del LGR

En primer lugar tenemos el ángulo de referencia para que el sistema se mantenga en

equilibrio. Este ángulo debe introducirse en radianes, y su valor en este caso será 0 radianes,

pero en otros casos puede ser interesante que sea un valor no nulo, por ejemplo, sería

interesante si quisiéramos realizar un control de posición.

A continuación tenemos un sumador cuya salida es la señal de error, la diferencia

entre la consigna (referencia) y el ángulo actual del péndulo.

En tercer lugar tenemos otro sumador. En este caso, este sumador nos servirá para

“despertar” al sistema, como se explica a continuación:

En el sistema con la planta linealizada, no podemos introducir condiciones iniciales.

Por lo tanto, como el sistema se encuentra inicialmente en equilibrio, el sistema no se moverá

a no ser que introduzcamos una perturbación.

El método que se ha utilizado para introducir la perturbación es una suma de señales,

como se muestra en el siguiente diagrama (siguiente página):


36

Figura 24: Obtención de la señal de perturbación

Tenemos dos parámetros que podemos variar para hacer que la perturbación desplace

el péndulo a un ángulo determinado: la amplitud de la perturbación y el tiempo durante el que

mantenemos la perturbación a nivel alto.

Después de añadir la perturbación, el siguiente elemento que encontramos es la

ganancia, que será el parámetro que utilizaremos para comprobar el funcionamiento del

sistema y comparar los resultados con los que se esperan por la simulación del LGR.

La salida del bloque de ganancia es la entrada de la planta linealizada, que ya se ha

tratado anteriormente.

La salida de la planta linealizada es el ángulo de inclinación en un determinado

instante de tiempo del péndulo, en unidades de radianes. Este ángulo se satura en ±π/2

radianes para simular que el péndulo choca contra la superficie al caer.

La salida del limitador será el ángulo que se utiliza en la realimentación.

Por último, guardamos el valor del ángulo y del clock del sistema en el workspace para

poder representarlos gráficamente.

Una vez explicado el modelo, el siguiente paso que se realizará será la comprobación

de la respuesta del sistema para distintos valores de ganancia.


37

3.3.1.3.2. Simulación de la planta linealizada con control proporcional

Para realizar esta simulación debemos ejecutar el fichero constantes.m (anexo 5).

Para verificar el resultado obtenido en el LGR realizado se utilizarán distintas ganancias.

En primer lugar, para una ganancia inferior a 6,3 el sistema debería ser inestable. Por

ejemplo, utilizando una ganancia de 5 se obtiene el siguiente resultado:

Figura 25: Gráfica temporal del ángulo para una ganancia de 6

El sistema no logra mantenerse en equilibrio y el ángulo se satura en +90°.

A continuación se utiliza una ganancia de 6,3 y obtenemos el siguiente resultado:

Figura 26: Gráfica temporal del ángulo para una ganancia de 6,3


38

En este caso el sistema no se caería, y se mantendría oscilando indefinidamente con la

misma amplitud, aproximadamente de 5,6 º.

Por último, podemos ver que si aumentamos la ganancia del sistema (por ejemplo, a

un valor de 10), las oscilaciones son más rápidas y de menor amplitud:

Figura 27: Gráfica temporal del ángulo para una ganancia de 10

Por lo tanto, se verifica el resultado obtenido con el LGR. Además, este resultado nos

permite afirmar que si el sistema tuviera exactamente la misma dinámica que de la planta

linealizada, con un control proporcional podría mantenerse en equilibrio.

El problema es el siguiente:

Recapitulando, en primer lugar hemos realizado una modelización del sistema real lo

más precisa posible, pero aún así el sistema real y el modelo no son idénticos, por ejemplo, por

la construcción física: en la simulación hablamos de una varilla ideal y el sistema real difiere

mucho de este modelo (aunque sea la mejor aproximación que se pueda realizar).

A continuación, hemos anulado los términos de fricción del modelo, y por último

hemos linealizado la planta sin fricción que habíamos obtenido.

Todo ello quiere decir que a nivel de simulación el resultado es correcto, pero si

llevamos a cabo la implementación de un control P en el sistema real con una determinada

ganancia superior a 6,3, el sistema no se mantendrá en equilibrio, debido a las diferencias

existentes entre la planta linealizada y el sistema real.

Por lo tanto, el siguiente paso será trabajar con la planta sin linealizar, con la finalidad

de utilizar un modelo más parecido al sistema real que se pretende simular.


39

3.3.2. Simulación en dominio temporal continuo de la planta no linealizada

3.3.2.1. Modelo que se va a simular

En este apartado se realiza la simulación de la planta obtenida anteriormente (sin

linealizar) con la finalidad de obtener unos valores de control con los que poder mantener el

péndulo en equilibrio.

En primer lugar, se ha realizado el siguiente modelo en Simulink (anexo 5):

Figura 28: Modelo Simulink de la simulación de la planta no linealizada

El modelo es muy similar al que se había realizado anteriormente (planta linealizada).

En primer lugar tenemos el ángulo de referencia.

A continuación, tenemos un sumador cuya salida es la señal de error, que es la

diferencia entre el ángulo de referencia y el ángulo en el que se encuentra el péndulo.

Esta señal de error es la entrada al bloque del controlador PID. Por lo tanto,

deberemos determinar las constantes correspondientes a cada uno de los términos del PID

como se explicará posteriormente. En el siguiente subcapítulo se justificará le elección de este

controlador.

La salida del controlador PID es la entrada de la planta no linealizada, que es la misma

que incluye Matlab en el ejemplo de péndulo invertido tratado anteriormente. Únicamente se

ha añadido un bloque de saturación del ángulo a ±π/2 rad.


40

En este modelo no tenemos el sumador con el que introducíamos la perturbación en el

sistema. Esta diferencia es debida a que la planta que tenemos es la siguiente:

Figura 29: Modelo Simulink de la planta no linealizada

Tenemos dos bloques integradores.

El primer integrador nos permite obtener la velocidad angular mediante la integración

de la aceleración angular.

El segundo nos permite obtener la posición angular mediante la integración de la

velocidad angular.

En estos bloques integradores podemos introducir unas condiciones iniciales, por

ejemplo, en el segundo integrador podemos introducir un ángulo inicial con el que podemos

“despertar” al sistema:

Figura 30: Cuadro de diálogo del bloque integrador

Una vez visto el modelo Simulink de este sistema, el siguiente paso será obtener los

parámetros necesarios para realizar el control del péndulo.

En este caso, trabajamos con un controlador PID, y los parámetros que necesitaremos

obtener son las constantes Kp, Ki y Kd.

Para la obtención de cada uno de estos parámetros se recurrirá al bloque sintonizador

de PID de Matlab.


41

3.3.2.2. Sintonizador de PID de Matlab

Existe una gran variedad de sistemas de control que podríamos utilizar [22]. Como se

ha comentado anteriormente, uno de los objetivos de este proyecto es aplicar los

conocimientos adquiridos a lo largo de la titulación.

Por lo tanto, el sistema de control que se va a utilizar en este proyecto es un PID

puesto que es el sistema que más se ha tratado, y como consecuencia, es sobre el que he

adquirido un mayor conocimiento.

Un PID (Proporcional Integral Derivativo) es un mecanismo de control

por realimentación [23] que calcula la desviación o error entre un valor medido y el valor que

se quiere obtener, para aplicar una acción correctora que ajuste el proceso [24].

En nuestro caso, el valor que se quiere obtener es el ángulo en el que se pretende

equilibrar el sistema, que será de 0°, y el valor medido será el valor del ángulo del péndulo en

un determinado instante de tiempo.

El algoritmo de cálculo del control PID se da en tres parámetros distintos: el

proporcional, el integral, y el derivativo.

- El valor Proporcional determina la reacción del error actual.

- El Integral genera una corrección proporcional a la integral del error, esto nos

asegura que aplicando un esfuerzo de control suficiente, el error de seguimiento se

reduce a cero.

- El Derivativo determina la reacción del tiempo en el que el error se produce.

Para poder implementar un PID vamos a necesitar tres elementos:

- Un sensor con el que obtendremos el valor del ángulo del péndulo

periódicamente.

- Un controlador en el que se implemente el PID para transformar la señal de error

entre el ángulo de equilibrio y el ángulo del péndulo a un valor para enviar a los

actuadores.

- Un o unos actuadores con los que provocaremos un cambio en el movimiento del

sistema con la finalidad de corregir el ángulo del péndulo.

El siguiente paso a realizar será la simulación del sistema con la finalidad de encontrar

las constantes del controlador PID para poder mantener en equilibrio el sistema real. Para ello

recurriremos al sintonizador de PID que tenemos disponible en Matlab.

http://es.wikipedia.org/wiki/Realimentaci%C3%B3n

http://es.wikipedia.org/wiki/Algoritmo


42

Como se había comentado previamente, la elección de Matlab como entorno para

realizar las simulaciones correspondientes del sistema se debía a otros motivos, además de los

citados.

Uno de estos motivos es que incluye un bloque con el que podemos sintonizar un PID

[25]. El modelo de este sintonizador es el siguiente:

Figura 31: Modelo Simulink del sintonizador de PID de Matlab

En este sintonizador observamos los siguientes bloques:

En primer lugar el Step, que será el ángulo de referencia en nuestro sistema.

En segundo lugar, el controlador PID, cuyos valores de Kp, Ki y Kd se determinarán en

la simulación de este sintonizador.

En tercer lugar, la planta que queremos controlar.

Y por último, los bloques más importantes de este sintonizador son los bloques con los

que añadiremos las restricciones: Output Constraint y Actuator Constraint.

En primer lugar, tenemos un bloque para añadir restricciones a la salida de la planta.

En el caso de nuestro sistema, se trata de la restricción en el ángulo de oscilación del sistema.

En segundo lugar, tenemos un bloque para añadir restricciones al actuador. En el caso

de nuestro sistema, se trata de las restricciones que tengan los motores de la plataforma Lego

Mindstorms NXT 2.0.


43

Si abrimos un bloque de restricciones, nos encontramos ante la siguiente ventana:

Figura 32: Restricciones del sintonizador de PID de Matlab

En la figura anterior, podemos ver una zona coloreada en blanco en la parte central y

una zona coloreada en un tono más oscuro de blanco en la parte superior e inferior.

Estas zonas están delimitadas por segmentos marcados en color negro. Estos

segmentos son las restricciones que podemos añadir/modificar.

De estas restricciones podemos modificar varios parámetros, como se muestra en el

siguiente cuadro de diálogo:

Figura 33: Parámetros que se pueden modificar de las restricciones

Cada línea de valores corresponde a un segmento. Podemos agregar/eliminar

segmentos, y podemos modificar sus parámetros: amplitud, tiempo de inicio y de fin, peso,

etc.


44

3.3.2.3. Restricciones de nuestro sistema

Para añadir las restricciones en la simulación debemos conocer las restricciones de

nuestro sistema físico real para que estos parámetros nos permitan sintonizar el PID que

controle la planta con el mayor grado de aproximación a la realidad posible.

3.3.2.3.1. Restricciones en el ángulo del péndulo

En este caso la restricción que vamos a introducir será la amplitud máxima de

oscilación que queremos que tenga el sistema.

La idea es que esta amplitud máxima de oscilación sea lo más pequeña posible cuando

el sistema se haya estabilizado.

Debemos tener en cuenta que para despertar al sistema utilizamos un ángulo inicial.

Por lo tanto, la amplitud máxima de oscilación debe ser mayor que el ángulo inicial durante un

tiempo. Este tiempo será el necesario para que el ángulo de oscilación sea menor que el

ángulo inicial.

Por lo tanto, podemos utilizar una restricción en el ángulo de un valor que iremos

variando en función del ángulo inicial utilizado para despertar al sistema.

Como se verá posteriormente, esta restricción se cumple con mayor facilidad que la

restricción en el actuador, puesto que el sistema se equilibra en un ángulo prácticamente nulo

en muy poco tiempo.

3.3.2.3.2. Restricciones en el actuador (motor LEGO Minstorms NXT 2.0)

En este caso se utilizará la construcción física para comprobar las limitaciones que

tienen los motores de LEGO Mindstorms NXT 2.0.

Sobre estos motores se han realizado diversos estudios, de entre los que cabe destacar

el estudio realizado por Philo en su página web [26].

Al margen de los estudios realizados, la mejor forma de conocer las limitaciones de los

actuadores es realizando un experimento.


45

La finalidad de este experimento es determinar la velocidad lineal máxima de nuestro

sistema por el siguiente motivo:

En nuestro modelo, el controlador aplica una fuerza F sobre el actuador, que es el que

provoca el movimiento de la planta. Sabemos que:

La masa total del sistema la conocemos, y la velocidad lineal del sistema la podemos

determinar mediante el experimento que vamos a realizar.

El experimento consiste en colocar el robot sobre una superficie plana y sin inclinación,

introducir un ciclo del 100% en los motores durante un tiempo determinado y medir la

distancia que ha recorrido el robot. El código de este experimento se encuentra disponible en

el anexo 2.

Conociendo el tiempo empleado y la distancia recorrida podemos determinar la

velocidad lineal.

El resultado experimental obtenido es el siguiente:

Tiempo definido: 5 s.

Distancia recorrida: 3,6 m.

El valor obtenido no deja de ser una aproximación, debido a que estamos suponiendo

que en el momento en que los actuadores empiezan a mover al robot, la velocidad ya será

0,72 m/s, no contemplamos el tiempo necesario para adquirir esta velocidad.

Una vez conocidas ambas restricciones, el siguiente paso consistirá en introducirlas en

el sintonizador de PID de Simulink.


46

3.3.2.4. Sintonizador PID de Matlab con las restricciones de nuestro modelo

A continuación se adjunta el modelo Simulink del sintonizador de PID modificado con

las restricciones que se han expuesto anteriormente disponible en el anexo 5:

Figura 34: Modelo Simulink del sintonizador de PID con restricciones de nuestro sistema

Se ha modificado el modelo original introduciendo los siguiente cambios:

En primer lugar, la salida de la planta (el ángulo de desviación del péndulo en unidades

de radianes) se multiplica por una constante para convertir el valor del ángulo de unidades de

radianes a unidades de grados.

Esta conversión se realiza para introducir la restricción de la salida de la planta

directamente en grados.

En segundo lugar, el valor de la salida del controlador PID se divide por la masa total

del sistema, que es la suma de la masa del carro y la masa del péndulo.

A continuación se integra esta señal y obtenemos la velocidad lineal sobre la cual

podremos aplicar la restricción que se ha determinado experimentalmente.

A continuación se muestran las restricciones utilizadas en ambos casos.


47

En primer lugar, las restricciones en el ángulo del péndulo:

Figura 35: Restricciones en el ángulo del péndulo

Se utilizan dos segmentos:

El primer segmento se inicia en 0 segundos y como tiempo final 5 segundos. Su

amplitud dependerá del valor del ángulo inicial que utilicemos para despertar al sistema. Se ha

decidido utilizar la siguiente relación para determinar esta amplitud:

El segundo segmento se inicia en 5 segundos y finaliza en 20 segundos. La amplitud de

este segmento será de ±1°, para reducir las oscilaciones cuando el sistema se estabilice.

En segundo lugar, las restricciones en el actuador:

Figura 36: Restricciones en el actuador

En el caso del actuador, la restricción que se utiliza es de ±0,72 m/s. Esta restricción es

independiente del ángulo de perturbación que utilicemos.

Una vez conocidas las restricciones, el siguiente paso será ejecutar la simulación para

obtener unos valores de Kp, Ki y Kd para nuestro controlador.


48

3.3.2.5. Simulación del sintonizador de PID

Para realizar la simulación del sintonizador de PID tenemos dos parámetros variables

que afectarán a los valores de las constantes Kp, Ki y Kd: el ángulo inicial de la restricción y el

ángulo inicial del péndulo.

Como se ha comentado anteriormente, se ha decidido que el ángulo de la restricción

se obtenga a partir del ángulo inicial del péndulo, y que la relación entre ambos sea un offset

para que siempre exista la misma diferencia.

Por lo tanto, la única variable que tenemos es el ángulo inicial del péndulo.

Para la obtención de Kp, Ki y Kd se ha realizado un conjunto de pruebas utilizando

distintos valores iniciales del ángulo. El motivo es el siguiente:

Para cada valor de ángulo inicial que se le da al sistema, se obtiene un valor distinto de

Kp, Ki y Kd. Los valores obtenidos son muy dispares entre sí. De hecho, se obtiene un valor

distinto si utilizamos un valor positivo o negativo de ángulo inicial, aunque el módulo sea el

mismo.

Por lo tanto, existen muchas constantes para realizar un control PID teórico con el que

se podría mantener en equilibrio el péndulo.

Realizar el análisis con cada uno de los posibles controles PID supondría un trabajo

muy extenso, por lo que se ha optado por la siguiente solución:

Se realizará un conjunto de pruebas en las que el ángulo inicial del péndulo irá desde

10° hasta -10° en incrementos de 1° (obviando el caso concreto en que el ángulo inicial sea de

0°), por lo que se obtendrán 20 valores distintos para cada constante.

Se obtendrá el valor medio de cada una de las constantes del PID y se comprobará el

funcionamiento del control PID obtenido con la planta del sistema.

En primer lugar se adjunta la tabla de los valores obtenidos en cada una de las

simulaciones para los distintos valores del ángulo inicial del péndulo (siguiente página).


49

Ángulo inicial (°) Kp Ki Kd Restricción de ángulo hasta 5 s (°)

-10 23,21 -5,76 9,31 15

-9 59,80 -19,82 0,37 14

-8 384,95 -164,76 1,68 13

-7 -12,79 1,08 58,26 12

-6 -0,61 -4,79 79,01 11

-5 74,00 11,16 80,19 10

-4 -17,58 2,26 53,40 9

-3 13,94 -2,54 0,01 8

-2 -493,61 156,53 652,14 7

-1 15,21 -1,70 19,18 6

1 18,00 -5,30 172,60 6

2 75,16 -8,01 29,48 7

3 -7,67 72,53 18,59 8

4 705,40 -17,41 91,43 9

5 -0,28 -2,55 59,69 10

6 9,99 -1,10 0,03 11

7 184,82 -25,35 23,39 12

8 -16,65 19,78 45,11 13

9 0,92 25,28 34,50 14

10 20,10 -1,87 3,53 15

Valor medio: 51,8155 1,383 71,595

Tabla 3: Valores de las constantes del PID obtenidos en la simulación del sintonizador de PID

Como se puede observar en la tabla anterior y como se había comentado previamente,

los valores obtenidos son muy dispares entre sí; de hecho, en ningún caso coinciden. Además,

tampoco coinciden los valores obtenidos para ángulos inicales de igual módulo pero de

distinto signo.

Los valores medios obtenidos son los siguientes:

Kp = 51,8155; Ki = 1,3830; Kd = 71,5950

El siguiente paso consistirá en simular la planta con estos valores obtenidos y

comprobar su correcto funcionamiento. Además, se reajustaran ligeramente las constantes

para adecuar la respuesta del sistema a nuestros intereses.


50

3.3.2.6. Verificación de los valores obtenidos del sintonizador

3.3.2.6.1. Respuesta a un ángulo inicial

Para verificar que los valores obtenidos anteriormente permiten mantener el péndulo

en equilibrio, se aplicarán sobre el modelo Simulink mostrado en el apartado 5.3.2.1.

El ángulo inicial del sistema es de 10° y los valores de las constantes del PID aplicados

son:

Kp = 51,8155; Ki = 1,3830; Kd = 71,5950

La respuesta del sistema que se obtiene es la siguiente:

Figura 37: Respuesta del sistema para Kp=51,8155; Ki=1,3830; Kd=71,5950 y ángulo inicial 10°

Como podemos observar, el sistema logra mantenerse en equilibrio y presenta las

siguientes características:

En primer lugar, el tiempo necesario para estabilizarse es de 5 segundos. Es un tiempo

muy elevado. Para reducir este tiempo de estabilización se puede aumentar Kp o disminuir Kd.

En segundo lugar, el error que presenta el péndulo: pese a que al final se llega a

anular, el tiempo necesario está por encima de 20 segundos. Es decir, la constante Ki cumple

con su cometido (anular el error) pero hay que modificar las constantes Kp o Kd para acelerar

el proceso.

En tercer lugar, se puede observar como el sistema es ligeramente subamortiguado

[27]. Esta es una buena característica, pero sería más razonable conseguir disminuir el tiempo

de estabilización aunque el sistema tuviera una menor amortiguación.


51

Por lo tanto, el siguiente paso que se realizará será modificar las constantes Kp y Kd

con la finalidad de acelerar el proceso de estabilización.

En primer lugar se modificará la constante Kd puesto que parece ser dominante

respecto a Kp. Se debe reducir su valor para acelerar la respuesta del sistema.

Se ha realizado un conjunto de pruebas para distintos valores de Kd, como se muestra

en la siguiente figura:

Figura 38: Respuesta del sistema a distintos valores de Kd

A medida que se reduce el valor de la constante Kd la respuesta del sistema es más

rápida. Podríamos plantear el hecho de anularla y realizar únicamente un control PI. Veamos

cual sería la consecuencia en la respuesta del sistema:

Figura 39: Respuesta del sistema para Kp=51,8155; Ki=1,3830; Kd=0 y ángulo inicial 10°


52

La consecuencia de anular el término derivativo es que el sistema se inestabiliza y las

oscilaciones cada vez presentan una mayor amplitud, hasta que para un tiempo prolongado el

péndulo caerá.

Por lo tanto, debemos reducir la constante Kd pero sin llegar a anularla. Observando la

figura 38, la decisión que se ha tomado es utilizar un valor Kd = 10 o Kd = 20. Con el primer

valor (Kd=10) se obtiene una mayor velocidad de respuesta y con el segundo valor (Kd=20) se

obtiene una mayor estabilidad frente a perturbaciones.

La diferencia en el tiempo de estabilización del péndulo entre ambos valores de Kd es

inferior a 1 segundo.

La decisión que se ha tomado es utilizar un valor para la constante Kd = 20 con la

finalidad de tener una mayor estabilidad frente a posibles perturbaciones.

A continuación se ha realizado un estudio sobre distintos valores para Kp, fijando el

valor de Kd = 20 y Ki = 1,3830. El conjunto de respuestas obtenidas es la siguiente:

Figura 40:Respuesta del sistema a distintos valores de Kp

A medida que aumenta Kp el sobrepico de la respuesta se reduce. Por lo tanto, el caso

óptimo sería un valor de Kp infinito.

Observando el comportamiento de la simulación, se ha optado por utilizar un valor de

Kp=60, con el que se consigue estabilizar el sistema en aproximadamente 2 segundos.

Por último, pese a que el término integral del PID cumple con su cometido, se realizará

una prueba con distintos valores de Ki con la finalidad de optimizar la respuesta del sistema.


53

En este caso se ha optado por escalar el eje de las ordenadas para poder visualizar con

mayor precisión la respuesta para los distintos valores de Ki. La gráfica correspondiente a la

prueba realizada es la siguiente:

Figura 41: Respuesta del sistema a distintos valores de Ki

A medida que aumentamos el valor de la constante Ki, el sistema es menos

amortiguado y presenta un mayor tiempo de estabilización. Como se puede observar en la

imagen, el valor óptimo en este caso es Ki=1.

Por lo tanto se ha determinado que el control óptimo del PID para este sistema es:

Kp = 60; Ki = 1; Kd = 20

Por último, si comparamos el comportamiento del sistema con este control y el

comportamiento del sistema con el control original obtenido del sintonizador:

Figura 42: Gráfica comparativa entre los valores obtenidos con el sintonizador de PID y los valores finales seleccionados


54

Como se puede observar, la respuesta que se obtiene con los valores modificados es

mejor que la respuesta obtenida con los valores originales del sintonizador de PID

principalmente porque mejora el tiempo de estabilización del sistema.

Por lo tanto, tenemos un control con el que podemos mantener en equilibrio el

sistema carro-péndulo, pero no sabemos si este control funcionará en nuestro sistema real con

el robot Lego Mindstorms NXT 2.0.

Por otro lado, la introducción de la perturbación en el sistema en este caso ha sido un

ángulo inicial. Debemos comprobar que el sistema actuará correctamente en el caso de que la

perturbación que se introduzca sea una fuerza, por ejemplo, un pequeño golpe que para que

el robot reaccione.

El siguiente paso consistirá en anular el ángulo inicial que le hemos dado al sistema e

introducir una perturbación en forma de fuerza, para ver cómo reacciona el robot y volver a

optimizar los valores de Kp, Ki y Kd.

3.3.2.6.2. Respuesta a una perturbación

Si introducimos una señal entre la salida del controlador PID y la planta del sistema

carro-péndulo estaremos introduciendo una perturbación en el sistema, puesto que esta salida

es la fuerza que actúa sobre el carro.

Para introducir la perturbación utilizaremos el mismo método que se ha utilizado en la

verificación del LGR con la planta linealizada. El modelo Simulink correspondiente a esta

simulación es el siguiente, que se encuentra disponible en el anexo 5.

Figura 43: Modelo Simulink para analizar la respuesta de la planta no linealizada frente a una perturbación


55

Se han ajustado los parámetros de la perturbación para que el ángulo del péndulo se

desvíe 10° de la posición de equilibrio. El resultado obtenido de la simulación es el siguiente:

Figura 44: Respuesta de la planta linealizada frente a una perturbación de 10°

A continuación añadiremos un ángulo inicial y retrasaremos la aparición de la

perturbación hasta los 5 segundos para comparar la respuesta del sistema en los dos casos:

Figura 45: Respuesta de la planta linealizada frente a ánglo inicial y a perturbación

Como se puede observar, la respuesta del sistema es prácticamente la misma en los

dos casos. La única diferencia es que con la perturbación se produce un ligero

subamortiguamiento (inferior a 0,1°) que no se produce con el ángulo inicial.

Una vez validado el funcionamiento del sistema frente a perturbaciones, el siguiente

paso consiste en introducir algunas restricciones sobre el sistema, con la finalidad de tener en

cuenta algunas no linealidades del actuador.


56

3.3.2.7. Adición de restricciones en el actuador

Anteriormente se había determinado la primera no linealidad del actuador, que era la

saturación de la velocidad a un valor máximo 0,72m/s (en módulo).

Esta restricción se considera constante, sin tener en cuenta el tiempo de aceleración

que necesite el sistema para adquirir esta velocidad.

La siguiente no linealidad que se añadirá es la zona muerta del actuador.

Nuestro actuador serán dos motores de Lego Mindstorms NXT 2.0. Para actuar sobre

los motores se introduce un ciclo de trabajo comprendido entre -100 y +100.

Si actuamos sobre estos motores sin ningún tipo de carga, únicamente con un ciclo de

trabajo del 1% ya rotarían. Pero cuando unimos los motores al montaje físico del robot, el

robot en sí es una carga puesto que tiene una masa que hace que con un ciclo de trabajo del

1% los motores no roten.

Por lo tanto, la prueba que se ha utilizado para determinar el ciclo de trabajo mínimo

que debemos introducir en los motores para provocar el movimiento del sistema es la

siguiente:

Se ha colocado el robot en posición horizontal sobre una superficie plana. Utilizando el

código disponible en el anexo 2 se ha ido incrementando el ciclo de trabajo de los motores en

+1 a cada segundo (arranque de motor utilizando una rampa). En el momento en que el robot

ha empezado a moverse, se ha pulsado utilizado un sensor de contacto como pulsador para

finalizar el programa y obtener el último valor del ciclo de trabajo introducido.

Tras la realización de esta prueba, al detener el sistema cuando inicia el movimiento, el

valor de ciclo de trabajo es del 10%. Como las restricciones en el sistema las introducimos en

forma de velocidad, tendremos:

Una vez determinadas ambas restricciones, volveremos a comprobar el

funcionamiento del sistema en presencia de estas.

El modelo Simulink que se ha utilizado es una modificación del modelo que se había

utilizado en el apartado anterior. Este modelo con las restricciones se encuentra disponible en

el anexo 5.


57

Figura 46: Modelo Simulink de la planta no linealizada con restricciones

El resultado obtenido de la simulación es el siguiente:

Figura 47: Simulación del sistema con restricciones, introduciendo ángulo inicial y perturbación

Como podemos observar, el sistema es capaz de responder adecuadamente al ángulo

inicial, aunque con una mayor lentitud. El problema se produce cuando introducimos la

perturbación, que desestabiliza el péndulo hasta que cae.

Por lo tanto, reduciremos el ángulo que introduce la perturbación para ver cuál es el

valor máximo de perturbación con el que el sistema podría mantener el péndulo en equilibrio.

Tras la realización de diversas pruebas se ha determinado que el valor máximo de

perturbación que puede soportar el péndulo sin caer es ligeramente inferior a 9°, como se

muestra en la siguiente figura:


58

Figura 48: Máxima perturbación que se puede introducir en el sistema con restricciones

Por lo tanto, se ha realizado una mayor aproximación al sistema real, añadiendo

algunas restricciones en los actuadores.

El siguiente paso consistirá en discretizar el sistema, porque aunque la dinámica de la

planta sea en tiempo continuo, las muestras del ángulo y el envío de los valores de control a

los actuadores se realizan de forma periódica.

El problema que se presenta es que para discretizar el sistema debemos recurrir a la

planta linealizada. Como consecuencia, la aproximación a la realidad no será tan cercana como

con el modelo no linealizado.

Al utilizar la planta linealizada, el control óptimo obtenido en las pruebas realizadas

anteriormente (la planta no linealizada) es posible que no funcione correctamente. Por ello,

deberemos modificar los parámetros del controlador PID con la finalidad de obtener una

respuesta óptima para la planta linealizada.


59

3.3.3. Simulación en dominio temporal continuo de la planta linealizada

3.3.3.1. Respuesta de la planta linealizada utilizando el PID anterior

En este primer apartado se comprobará el funcionamiento de la planta linealizada

utilizando las constantes del PID obtenidas para la planta no linealizada.

Debemos tener en cuenta que la planta linealizada solo puede “despertar” utilizando

la perturbación, no podemos utilizar un ángulo inicial.

El modelo Simulink para esta simulación es el siguiente, disponible en el anexo 5:

Figura 49: Modelo Simulink de la planta linealizada con restricciones y perturbación

En primer lugar, utilizando la máxima perturbación que admitía la planta no

linealizada, obtenemos la siguiente respuesta:

Figura 50: Comportamiento de la planta linealizada frente a una perturbación


60

En la figura anterior podemos observar que la perturbación que para la planta no

linealizada suponía una desviación del ángulo de equilibrio inferior a 9°, en este caso supone

una perturbación de casi 20°. En un primer momento parece que el sistema puede llegar a

mantener al péndulo en equilibrio, pero finalmente cae.

Por lo tanto, se va a modificar la perturbación para que sea de una amplitud similar a

la simulada con la planta no linealizada.

El resultado obtenido tras la simulación es el siguiente:

Figura 51: Comportamiento de la planta linealizada frente a una perturbación de 9°

En este caso, el sistema es capaz de mantenerse estable pero se mantiene oscilando

indefinidamente, nunca consigue que el error en el ángulo del péndulo sea nulo. La amplitud

de la oscilación es de aproximadamente 0,2°.

El problema ante el que nos encontramos es el siguiente: si se utiliza el mismo valor

para las constantes del PID que en la planta no linealizada, es posible que al discretizar el

sistema no se consiga mantener el péndulo en equilibrio.

Por otra parte, si se modifican los parámetros del controlador PID, nos estaremos

alejando del modelo real, puesto que la planta no linealizada presenta una mayor similitud que

la planta linealizada.

La solución por la que se ha optado es la siguiente: se modificará los valores del

controlador PID para obtener unos valores que mejoren la respuesta del sistema, y

posteriormente se discretizarán los dos controladores: el de la planta no linealizada y el de la

planta linealizada.

Por lo tanto, el siguiente paso será modificar los valores de las constantes del PID con

la finalidad de optimizar la respuesta de la planta linealizada frente a perturbaciones.

Del mismo modo que con la planta no linealizada, se utilizarán distintos valores para

cada una de las constantes del controlador PID hasta obtener la mejor respuesta posible del

sistema.


61

3.3.3.2. Modificación de los parámetros del PID

La desventaja de esta simulación es que debido a que las oscilaciones que se producen

son muy rápidas, no podemos añadir la respuesta del sistema para varias constantes en una

misma gráfica.

Por lo tanto, se probará con distintos valores para cada una de las constantes del PID,

se explicará brevemente cómo afecta la modificación de cada constante a la respuesta del

sistema y se mostraran dos gráficas: la primera será la respuesta del sistema con el valor

original de la constante y la segunda la respuesta del sistema con el valor optimizado de la

constante.

En primer lugar, recordamos cuales son las constantes con las que hemos trabajado

hasta el momento: Kp = 60; Ki = 1; Kd = 20

Para estos valores, la respuesta del sistema es la siguiente:

Figura 52: Respuesta de la planta linealizada con las constantes de PID originales

Vemos que el sistema presenta muchas oscilaciones. Para reducirlas, podemos actuar

sobre dos parámetros: la constante proporcional o la constante derivativa. Las acciones que se

deberían realizar sobre estas constantes son: reducir la constante proporcional o reducir la

constante derivativa, o ambas.

La primera acción que llevaremos a cabo será reducir la constante proporcional.

Tras probar diversos valores para la constante proporcional, se observa que a medida

que disminuimos su valor, la primera oscilación presenta una mayor amplitud, pero a

continuación la atenuación de la respuesta es mayor. En régimen permanente presenta una

amplitud de oscilación de ±0,1°.


62

El valor óptimo que se ha determinado para la constante proporcional es 20. Para

valores inferiores a 15 el sistema no es capaz de mantener el equilibrio. El margen que va

desde 15 hasta 20 es un margen de seguridad para no utilizar el valor de la constante

proporcional con el que el sistema podría perder el equilibrio.

La respuesta obtenida es la siguiente:

Figura 53: Respuesta de la planta linealizada con Kp=20, Ki=1, Kd=20

Una vez se ha modificado la constante proporcional, podemos observar en la figura

anterior que el sistema sigue presentando muchas oscilaciones pero su amplitud se ha

reducido.

Para reducir el número de oscilaciones del sistema modificaremos la constante

derivativa. Es posible que el valor de 20 sea un valor muy alto que hace que la respuesta del

sistema sea lenta y como consecuencia aparecen tantas oscilaciones.

De hecho, si observamos la figura 53, podemos ver como en un primer momento

parece que el sistema se vaya a equilibrar en un ángulo de aproximadamente +1°, y

lentamente el error va disminuyendo hasta que el ángulo es de 0°.

En las pruebas realizadas, se ha disminuido el valor de la constante derivativa,

observando que conforme disminuimos su valor, la respuesta del sistema presenta menos

oscilaciones y se estabiliza en menos tiempo.

El valor óptimo que se ha determinado para la constante derivativa es 2. Para valores

inferiores, el sistema no era capaz de mantener el equilibrio. Para valores superiores la

respuesta del sistema era muy lenta y presentaba oscilaciones en régimen permanente.


63

La respuesta obtenida es la siguiente:

Figura 54: Respuesta de la planta linealizada con Kp=20, Ki=1, Kd=2

Una vez modificadas las constantes Kp y Kd, el siguiente paso consistiría en retocar la

constante Ki. Pero como podemos observar en la respuesta anterior (figura 54), el error en

régimen permanente es nulo, por lo que no es necesario retocar este valor.

De esta manera podemos determinar que los valores óptimos para el control de la

planta linealizada son:

Kp = 20; Ki = 1; Kd = 2

Si comparamos la respuesta óptima que presenta la planta linealizada (figura 54) y la

respuesta óptima que presenta la planta no linealizada (figura 48) podemos ver una gran

diferencia, puesto que la estabilización de la planta no linealizada es más rápida y sin

oscilaciones.

Pese a esta diferencia existente, cabe recordar que la simulación principal del sistema

ha sido la que se ha llevado a cabo previamente con la planta no linealizada, puesto que

supone una mayor aproximación a la realidad, por lo que es de esperar que el

comportamiento del robot sea más parecido al de la figura 48.

Una vez hemos obtenido el control óptimo para mantener en equilibrio el sistema con

la planta linealizada, el siguiente paso consiste en discretizarlo.

Para ello utilizaremos de nuevo las posibilidades que nos ofrece el software Matlab, tal

y como se explica a continuación.


64

3.3.4. Discretización del sistema y simulación

3.3.4.1. Discretización de la planta y del controlador

Este es el último paso a realizar en cuanto a simulaciones se refiere. En esta simulación

lo que haremos será realizar una discretización del sistema. Para ello los dos elementos clave

que se va a utilizar son la planta linealizada y el controlador.

Para la discretización utilizaremos una herramienta de matlab, concretamente el

comando c2d [28]. Se encarga de transformar la función de transferencia que introduzcamos

de dominio temporal continuo a dominio discreto, y dispone de diversos métodos para realizar

esta transformación.

Para la función de transferencia de la planta se utilizará el método ‘zoh’: zero order

hold. Con esta opción suponemos que la entrada de la planta se mantiene constante durante

el período de muestreo [29].

Para la función de transferencia del controlador utilizaremos el método ‘tustin’. Este

método conserva la dinámica del sistema. Es decir, la dinámica del sistema es como si fuera en

tiempo continuo, pero la obtención de los datos se realiza en dominio discretizado [30].

Por lo tanto, lo único que necesitamos es obtener la función de transferencia del

controlador PID, puesto que la de la planta linealizada ya la tenemos.

La función de transferencia del controlador PID es la siguiente:

Una vez obtenidas ambas funciones de transferencia, procedemos a ejecutar los

siguientes comandos en Matlab:

%Discretización de la planta y del controlador:

Dz = c2d (control,Tm,'tustin')

Gpz = c2d (planta,Tm,'zoh');

Para agilizar el proceso de simulación y verificación del resultado, se ha creado un

archivo .m desde el que se realiza la conversión anterior a dominio discretizado y a

continuación se simula el comportamiento del sistema discretizado.


65

Para realizar esta simulación se ha creado el siguiente modelo Simulink:

Figura 55: Modelo Simulink para la simulación en dominio discretizado

Como podemos ver es muy similar a los modelos presentados anteriormente. Las

diferencias son las siguientes:

En primer lugar, la planta y el controlador son bloques Function Block. Las dos líneas

de código adjuntadas anteriormente crearán una función de transferencia en el Workspace y

con estos bloques insertaremos ambas funciones de transferencia en el modelo.

En segundo lugar, la perturbación que introducimos en el sistema: en este caso se

utiliza un bloque Discrete Impulse, que es un impulso de amplitud unitaria. Por ello a

continuación añadimos un bloque de ganancia, para poder modificar la amplitud del impulso.

Los bloques restantes son los mismos que en anteriores simulaciones, con la diferencia

que en todos ellos se ha introducido el periodo de muestreo en la opción Sample Time.

La última y principal diferencia que distingue este modelo de los anteriores reside en

los parámetros de configuración de la simulación.

En este caso se utiliza la siguiente opción:

Figura 56: Parámetros de configuración de la simulación del sistema discretizado

Se utiliza un solver con intervalos de tiempo fijos, y entre cada punto de las muestras y

el siguiente no se realiza ningún tipo de aproximación.

El periodo utilizado es de 10 ms. Este valor es el mismo que se utilizará en la

implementación sobre el robot LEGO, y es debido a la velocidad de lectura recomendada por el

fabricante del sensor.

El siguiente paso consiste en simular el sistema y comprobar su funcionamiento con los

controladores PID determinados anteriormente.


66

3.3.4.2. Simulaciones con la planta y el controlador discretizados

Como se ha explicado anteriormente, se simulará el sistema discretizado con dos

posibles configuraciones del PID con la finalidad de determinar cual permite obtener una

mejor respuesta del sistema.

3.3.4.2.1. Simulación con el PID obtenido de la planta no linealizada

En esta primera simulación se utilizará las constantes del PID obtenidas utilizando el

modelo de planta no linealizada.

Los valores de las constantes del PID son:

Kp = 60; Ki = 1; Kd = 20

Y la respuesta obtenida del sistema es la siguiente:

Figura 57: Simulación del sistema discretizado para Kp=60, Ki=1 y Kd=20

Como se puede observar en la imagen anterior, el sistema no es capaz de mantener el

equilibrio del péndulo. Cuando cae, el control adquiere un valor máximo de forma que es

capaz de levantar al sistema pero sin equilibrarlo, por lo que a continuación el péndulo cae en

la dirección contraria.

Como se había comentado previamente, cabía la posibilidad que el sistema no fuese

capaz de mantener el equilibrio con estas constantes del PID puesto que la respuesta de la

planta linealizada con el controlador obtenido para la planta no linealizada presentaba muchas

oscilaciones.


67

3.3.4.2.2. Simulación con el PID obtenido de la planta linealizada

En esta segunda simulación se utilizará las constantes del PID obtenidas utilizando el

modelo de planta no linealizada. Estos valores son:

Kp = 20; Ki = 1; Kd = 2

Y la respuesta obtenida del sistema es la siguiente:

Figura 58: Simulación del sistema discretizado para Kp=60, Ki=1 y Kd=20

En este caso el sistema es capaz de mantener el equilibrio, y si recordamos, la

respuesta obtenida es muy similar a la que se obtenía con la planta no linealizada.

Para apreciar la diferencia que existe entre la simulación discretizada y la simulación

continua debemos aproximar la imagen, para visualizar los segmentos que unen cada dato.

La imagen de detalle obtenida es la siguiente:

Figura 59: Zoom de la simulación del sistema discretizado para Kp=60, Ki=1 y Kd=20


68

Como podemos observar en esta imagen, en este caso no se realiza una interpolación

[31] entre los datos sino que se unen de forma escalonada, como corresponde a un sistema

discretizado.

El último paso es ajustar las constantes de este sistema, del mismo modo que se

procedió en las simulaciones de la planta linealizada y de la planta no linealizada, con la

finalidad de optimizar la respuesta del sistema.

El problema que se puede observar en la figura 58 es que el sistema tarda mucho en

llegar a estabilizarse en un ángulo de 0°.

Para mejorar este aspecto deberemos aumentar la constante proporcional para

aumentar la velocidad de respuesta del sistema o también podemos reducir la constante

derivativa, que tendrá un efecto similar.

En primer lugar, reduciremos la constante derivativa. Se utilizarán varios valores para

determinar cuál es el óptimo, como se muestra a continuación:

Figura 60: Respuesta del sistema discretizado para distintos valores de Kd

Como se puede observar en la figura anterior, una disminución de Kd comporta un

aumento del sobrepico inicial y una reducción del tiempo de estabilización. Aún así, la

respuesta a partir de 2,5 segundos es muy similar en los tres casos.

Si ampliamos la imagen en régimen permanente podemos observar la siguiente

característica (página siguiente):


69

Figura 61: Detalle de la dinámica de la planta discretizada para distintos valores de Kd

En la figura anterior se observa que la diferencia entre las 3 respuestas es muy

pequeña. Por lo tanto, se ha determinado que el valor óptimo para la constante Kd es 1

puesto que con este valor el sistema se estabiliza más rápidamente.

A continuación analizaremos el efecto de la modificación de la constante Kp. Se

utilizarán varios valores para ver cuál es el óptimo, como se muestra a continuación:

Figura 62: Respuesta del sistema discretizado para distintos valores de Kp

En la imagen anterior podemos observar que un aumento de Kp comporta una

disminución del sobrepico inicial y una reducción del tiempo de estabilización. Si utilizamos

una imagen para ver en detalle la respuesta en régimen permanente:


70

Figura 63: Detalle de la dinámica de la planta discretizada para distintos valores de Kp

Se puede observar como los valores más altos de Kp comportan un error más pequeño

en régimen permanente. Este error se va aproximando cada vez más al ángulo de referencia de

0°.

Por lo tanto, podemos determinar que un valor adecuado para la constante Kp puede

ser Kp=30. Si comparamos la respuesta original del sistema con la respuesta tras modificar las

constantes del PID:

Figura 64: Respuesta del sistema discretizado con el PID original y el PID modificado

Podemos observar que la respuesta del sistema mejora en el tiempo de estabilización

y en el tiempo que necesita para anular el error del ángulo. Por otro lado, empeora en cuanto

al sobrepico inicial y en amortiguación.


71

Recapitulando:

Se ha realizado la simulación del modelo que describe el comportamiento de un

sistema carro-péndulo, realizando una aproximación progresiva en cuanto a la similitud del

modelo simulado con el sistema real.

Se ha obtenido tres posibles conjuntos de constantes de un control PID para controlar

el sistema real:

En primer lugar, las constantes obtenidas con la planta no linealizada:

Kp = 60; Ki = 1; Kd = 20

El aspecto positivo de la utilización de la planta linealizada es que presenta una mayor

similitud con el sistema real.

Por el contrario, la simulación se realiza en tiempo continuo, por lo que difiere del

sistema real en el que la adquisición de los valores del ángulo y la actuación sobre los motores

se realizan periódicamente.

En segundo lugar, las constantes obtenidas con la planta linealizada:

Kp = 20; Ki = 1; Kd = 2

Esta simulación se encuentra en un punto intermedio entre la planta no linealizada y el

sistema discretizado, puesto que se realiza en tiempo continuo pero la planta utilizada es la del

sistema discretizado.

En tercer lugar, los valores obtenidos con la planta discretizada:

Kp = 30; Ki = 1; Kd = 1

El aspecto positivo de esta simulación es que es un sistema discretizado, por lo tanto,

tiene una mayor similitud con el sistema real en cuanto a que la adquisición de los valores del

ángulo y la actuación sobre los motores se realizan periódicamente.

Por el contrario, la planta discretizada tiene una menor similitud con el sistema real

que la planta no linealizada.

Por lo tanto, lo más posible es que los valores para el control del sistema que se han

obtenido no funcionen tan bien como en las simulaciones, pero deberían permitir mantener el

equilibrio durante un corto periodo de tiempo.

El siguiente paso a realizar consiste en la implementación del sistema de control en

nuestro robo LEGO Mindstorms NXT 2.0.

Pruebas en el sistema real

72

4. Pruebas en el sistema real

En este capítulo se llevará a cabo la verificación de las simulaciones realizadas

anteriormente. Para ello, se realizará la construcción física de un sistema carro-péndulo

utilizando la plataforma LEGO Mindstorms NXT 2.0 y posteriormente se realizará el código

para programarlo en un lenguaje similar al lenguaje C.

4.1.Construcción física del robot

El primer paso para llegar a implementar el algoritmo de control obtenido en las

simulaciones es construir físicamente el robot.

Para la construcción física se utiliza la plataforma de LEGO Mindstorms NXT 2.0, sobre

la cual ya se ha realizado una gran variedad de modelos.

La construcción física que se llevará a cabo en este proyecto parte de la base del

modelo NXTway-GS [32]. Sobre este modelo se han realizado ciertas modificaciones,

como se explica a continuación.

La construcción física del NXTway-GS es la siguiente:

Figura 65: Construcción física del NXTway-GS

De la anterior construcción física se van a realizar las siguientes modificaciones por los

motivos que se exponen a continuación:

En primer lugar se va a modificar la posición del Brick respecto a los motores. En las

imágenes de perfil se puede observar que si se dibujara un segmento vertical en la posición del

eje de rotación de los motores, este segmento no pasaría por el centro del Brick.


73

El problema que supone es que el Brick es el elemento de mayor masa del sistema, y

con bastante diferencia. Por lo tanto, en la construcción física anterior el sistema tiende a caer

en dirección a la parte frontal del Brick, debido a que el peso está descentrado.

Si no se modificara, el sistema tendería a caer siempre en la misma dirección, y el

punto de equilibrio no sería un ángulo de 90° respecto a la superficie por la que se desplaza el

robot.

Por lo tanto, la primera modificación que se va a realizar será centrar el peso del robot

en el eje vertical que parte del eje de rotación de los motores. No solo supone cambiar la

posición del Brick, sino también la de algunas piezas aisladas como la barra de unión entre los

dos motores que sobresale varios centímetros respecto del eje de equilibrio.

La segunda modificación que se realizará será centrar el sensor giroscópico en el eje

vertical que parte del eje de rotación de los motores. Se realizará por dos motivos:

El primer motivo es el que se ha expuesto anteriormente: la necesidad de centrar la

masa del robot. El sensor es el elemento de mayor masa después del controlador Brick.

El segundo motivo es la adquisición de los valores que realiza este sensor. Para poder

obtener la medida correcta del ángulo de desplazamiento, debemos centrar la posición del

sensor con el eje que parte del eje de rotación del sistema.

En tercer lugar se va a modificar la posición de las ruedas debido a que al modificar la

posición de la barra de unión entre ambos motores no disponemos del espacio suficiente en el

segmento que une ambos motores. Por lo tanto, se colocará las ruedas en la parte exterior.

Tras las modificaciones realizadas, el aspecto de nuestro robot es el siguiente:

Figura 66: Construcción física del robot de este proyecto


74

Ambos diseños expuestos anteriormente se han realizado con el software de

construcción virtual Lego Digital Designer [33].

Se puede observar en la figura 66, concretamente en las imágenes de perfil, que el

peso del robot queda más centrado en el eje vertical que parte del eje de rotación de los

motores.

También se puede observar como se ha colocado el sensor en este mismo eje. El

problema que podría existir con la construcción que se ha realizado para este proyecto es

debido a la posición del sensor: como se ha colocado en un lateral, el robot ya no es simétrico,

y como consecuencia estamos cargando un motor con un peso ligeramente superior al peso

que carga al otro motor.

El problema que puede existir es que uno de los dos motores tenga una mayor zona

muerta que el otro, o bien que al mantener el equilibrio el robot tienda a girar.

Pese a la existencia de este posible problema, las ventajas que supone el cambio son

mayores que los inconvenientes.

Una vez presentada la construcción física del robot que se ha utilizado, el siguiente

paso que se realizará será exponer brevemente el software utilizado para su programación.

4.2.Entorno de programación

Existen muchos softwares y lenguajes de programación para la plataforma LEGO

Mindstorms NXT 2.0.

En primer lugar tenemos el software que viene en el kit de LEGO: NXT-G [34]. Es un

software creado por National Instruments y el lenguaje de programación es como el de

Labview: con bloques.

Por otro lado también se ha creado diversas toolbox para distintos softwares, como

por ejemplo para Matlab [35] y para Labview [36].

Y por último tenemos softwares cuya programación es muy parecida al lenguaje C [37].

El lenguaje que utilizaremos en este proyecto para llevar a cabo la programación del

robot es NXC (Not eXactly C) [38], y el entorno de programación utilizado será Bricx Command

Center [39].

Esta elección se ha tomado en base a los conocimientos previos sobre el lenguaje C y

por otro lado porque este lenguaje y este entorno son los más utilizados para la programación

del Brick de LEGO.

Una vez conocido el sistema físico y el entorno y lenguaje de programación, a

continuación se describirá el funcionamiento general del robot.


75

4.3.Programación del sistema de control del robot

Para explicar cómo se realizará la programación del robot y para enlazar el sistema real

con las simulaciones realizadas se recurrirá al siguiente esquema:

Figura 67: Esquema del funcionamiento general del robot

En el esquema anterior podemos observar los siguientes elementos:

En primer lugar, el ángulo de referencia del robot. Este ángulo será el ángulo en el que

esté posicionado cuando se realice la calibración del sensor.

En segundo lugar, la señal de error que será la diferencia entre el ángulo de referencia

y el ángulo que leamos con el sensor.

En tercer lugar, el controlador. El control PID estará implementado en un programa

que se enviará al Brick.

En cuarto lugar, la señal de control, que será un ciclo de trabajo de los motores, que

está comprendido entre -100 y +100. Este ciclo de trabajo se obtiene con el PID implementado.

En quinto lugar, lo que era la planta del sistema en las simulaciones, en este caso es el

robot en sí. Como se ha comentado, la actuación se realizará sobre los motores.

En sexto lugar, en el robot tenemos el sensor con el que obtendremos el ángulo del

robot en un determinado instante de tiempo. Este sensor es un giroscopio, y el valor que

devuelve es la velocidad angular.

Por último, para obtener el ángulo del robot deberemos integrar la medida obtenida

del giroscopio.

Si recapitulamos, prácticamente se han visto todos los elementos anteriores. Los

elementos que faltan por explicar son: el giroscopio, la integración de la medida del giroscopio

y el código realizado para mantener en equilibrio el robot, que se explicarán a continuación.


76

4.4.El sensor: el giroscopio

La definición técnica con la que podemos explicar que es un giroscopio y como

funciona es la siguiente:

El giróscopo o giroscopio es un dispositivo mecánico formado

esencialmente por un cuerpo con simetría de rotación que gira

alrededor de su eje de simetría. Cuando se somete el giróscopo a

un momento de fuerza que tiende a cambiar la orientación del eje de

rotación su comportamiento es aparentemente paradójico ya que el

eje de rotación, en lugar de cambiar de dirección como lo haría un

cuerpo que no girase, cambia de orientación en una dirección

perpendicular a la dirección «intuitiva» [40].

Si se le añade la circuitería adecuada se puede convertir fácilmente en un sensor que

transforme una magnitud física (un momento de fuerza) en una señal eléctrica que podrá ser

transformada en un valor numérico.

El giroscopio que se va a utilizar en este proyecto es el siguiente:

4.4.1. HiTechnic Gyro Sensor

Se trata de un sensor giroscópico fabricado por HiTechnic [41]. Este sensor ya está

adaptado a la plataforma LEGO Mindstorms NXT 2.0, es decir, la conexión del sensor al Brick se

realiza con el cable estándar utilizado en esta plataforma. Además, visualmente se utilizado un

encapsulado como el de los sensores oficiales de LEGO.

Figura 69: HiTechnic Gyro Sensor

Se trata de un sensor giroscópico de un único eje de medida, por lo que es suficiente

para nuestro robot. Según el fabricante, el sensor devuelve un valor que representa el número

de grados por segundo de rotación, es decir, la velocidad angular. El sensor puede llegar a

medir rotaciones de más de ±360° por segundo.

Figura 68: Giroscopio de tres ejes

http://es.wikipedia.org/wiki/Eje_de_simetr%C3%ADa

http://es.wikipedia.org/wiki/Momento_de_fuerza


77

También especifica que la información del sensor puede ser leída a más de,

aproximadamente, 300 veces por segundo.

Esta información es muy importante para la realización de este proyecto puesto que el

periodo de muestreo de nuestro sistema es un elemento clave: si leemos el valor del ángulo

con un período muy elevado, el sistema podría caer debido a que los motores no habrían

actuado a tiempo.

300 veces por segundo supone un periodo de 1/300, que es 3,33 milisegundos

aproximadamente. Se ha decidido utilizar un periodo de lectura del sensor de 10 milisegundos,

por situarnos un poco por encima del valor límite que establece el fabricante.

La rotación que puede leer el sensor es la siguiente:

Figura 70: Rotación que lee el girosocipio de HiTechnic

El problema principal que tiene este giroscopio son las derivas. Se ha escrito artículos

[42] en los que se explican las causas de estas posibles derivas y se dan algunas soluciones para

mitigarlas, pero por lo general suele ser muy difícil anularlas complemente.

Estas derivas dependen de diversos factores, de entre los que se destacan los

siguientes: la fabricación del sensor y el nivel de voltaje de alimentación del Brick.

Esos son los motivos principales que se suelen exponer, pero además existe otro y de

una gran importancia: las vibraciones, en nuestro caso, las vibraciones que causan los motores

debido a su funcionamiento.

Por lo tanto, a continuación se realizará un breve estudio sobre el sensor giroscópico

de HiTechnic con la finalidad de intentar conocer el funcionamiento del sensor frente a

variaciones de algunos de los parámetros anteriores.


78

4.4.1.1. Pruebas estáticas realizadas con el giroscopio de HiTechnic

Se ha realizado diversas pruebas con la finalidad de comprobar el funcionamiento del

sensor giroscópico. El código utilizado para estas pruebas se encuentra disponible en el anexo

2.

Las pruebas se han realizado para el caso de la alimentación del Brick con pilas

alcalinas y la alimentación con la batería oficial de LEGO.

Se ha situado el robot sobre una superficie horizontal de forma que quede inmóvil.

Cuando se requiera realizar una actuación sobre los motores, se posiciona el robot de forma

que las ruedas no entren en contacto con la superficie.

En primer lugar, en la mayoría de documentaciones sobre el giroscopio y en general,

sobre cualquier sensor, se realiza una calibración con la finalidad de intentar reducir las

posibles derivas posteriores.

Para calibrar el giroscopio se tomará un conjunto de medidas y se realizará el

promedio [43] de estas. El código correspondiente a la calibración es el siguiente:

//Obtención del offset del sensor:

for(int i = 0; i < muestras_offset; i++)

{

offset += SensorHTGyro(GYRO_PORT);

Wait(T_calibracion);

}

offset = offset / muestras_offset;

En la siguiente tabla se adjunta los resultados obtenidos. Se ha realizado 5 mediciones

de 1000 muestras cada una con un periodo de muestreo de 10 ms, obteniendo el promedio de

todas las muestras de cada medición. Por último se ha obtenido el promedio de estas 5

mediciones. También se incluye los valores de voltaje de alimentación del Brick en cada caso.

Valores de offset obtenidos

Alimentación: Pilas alcalinas Batería LEGO

DC motores: 0% 0%

Parámetros: Vel. Angular (°/s) Voltaje (V) Vel. Angular (°/s) Voltaje (V)

-1,18 8,198 -1,09 8,281

-1,19 8,17 -1,13 8,267

-1,25 8,156 -1,13 8,294

-1,24 8,156 -1,12 8,308

-1,19 8,156 -1,13 8,322

Promedio: -1,21 8,1672 -1,12 8,2944

Tabla 4: Medidas del offset del giroscopio de HiTechcnic


79

Se puede observar los siguientes resultados:

El valor medio final obtenido para ambos sistemas de alimentación es muy similar: la

diferencia es inferior a 1 décima.

Se debe tener en cuenta que los niveles de alimentación del sistema con batería oficial

de LEGO son ligeramente superiores a los niveles de alimentación con pilas alcalinas.

También debemos tener en cuenta que los valores de voltaje tomados son el valor

medio de varias lecturas: si observamos el nivel de voltaje del Brick, tenemos la opción de

refresh: actualizar el valor del nivel de voltaje. Al actualizar este valor, prácticamente nunca

vamos a obtener el mismo valor.

Se observa que los resultados obtenidos con la batería oficial de LEGO son más

constantes ante los cambios de voltaje de alimentación del sistema.

Por lo tanto, en la tabla anterior podemos determinar que la alimentación del sistema

con batería es la mejor opción puesto que la calibración del offset es más constante frente a

variaciones del nivel de voltaje.

El siguiente paso será comprobar el funcionamiento de ambos sistemas de

alimentación en la medición del ángulo.

Para realizar la medición del ángulo debemos integrar el valor obtenido del sensor,

que es la velocidad angular.

Para integrar esta medida, multiplicaremos el valor obtenido del sensor por el tiempo

que transcurre entre muestras, que será un delay creado con el período de muestreo que

escojamos. En este caso el periodo de muestreo es de 10 ms. Este tipo de integral es una

fórmula de Newton-Cotes utilizando la regla del rectángulo [44].

El código correspondiente a la integración de la medida del giroscopio es el siguiente:

//Lectura del giroscopio (velocidad angular) y obtención del

ángulo:

lectura_gyro = SensorHTGyro(GYRO_PORT);

velocidad = lectura_gyro - offset;

angulo_actual += velocidad*T;

//Delay para la lectura del giroscopio:

Wait(T*1000);

Para comprobar el funcionamiento del giroscopio en la medición del ángulo, en primer

lugar se ha realizado dos conjuntos de pruebas: sin actuación sobre los motores (sin vibración)

y con actuación sobre los motores (con vibración). Estas pruebas se encuentran disponibles en

el anexo 4.

Del mismo modo que para la obtención del offset, se ha realizado 5 mediciones y se ha

obtenido el promedio de estas. Para obtener el ángulo final de desviación se he ejecutado el

programa de adquisición de muestras del sensor durante 60 segundos.


80

La tabla de resultados obtenidos es la siguiente:

Valores de ángulo obtenidos

Alimentación: Pilas alcalinas Batería LEGO

DC motores: 0% 0%

Parámetros: Ángulo (°) Voltaje (V) Ángulo (°) Voltaje (V)

-1,8 8,031 0,98 8,308

1,87 8,031 0,42 8,336

1,8 8,031 -1,6 8,322

-2,9 8,031 0,44 8,308

0,16 8,017 0,31 8,294

Promedio: -0,174 8,0282 0,11 8,3136

DC motores: 100% 100%

Parámetros: Ángulo (°) Voltaje (V) Ángulo (°) Voltaje (V)

-6,82 8,239 0,13 8,294

-6,53 8,128 -2,39 8,211

-2,19 8,087 -5,45 8,225

-6,18 8,045 -4,36 8,225

-3,82 7,99 -5,27 8,198

Promedio: -5,108 8,0978 -3,468 8,2306

Tabla 5: Medidas del ángulo de desviación del giroscopio de HiTechcnic en 60 segundos

Se puede observar los siguientes resultados:

- En el caso sin actuación sobre los motores:

Los niveles de voltaje del sistema alimentado con baterías alcalinas se mantienen más

constantes que en la alimentación del sistema con batería oficial de LEGO.

Aún así, el ángulo final de desviación obtenido alimentando el sistema con la batería

LEGO es en casi todos los casos inferior (en módulo) a la desviación obtenida alimentando el

sistema con pilas alcalinas.

- En el caso con actuación máxima sobre los motores:

En este caso se puede observar la gran ventaja de la batería LEGO: los motores

trabajan al 100% durante 60 segundos, y podemos ver cómo decae el nivel de voltaje de las

pilas alcalinas. En cambio, el nivel de voltaje de la batería se mantiene bastante constante.

El promedio del ángulo de desviación obtenido en la alimentación con batería también

es favorable a la alimentación del sistema con batería, puesto que la desviación del ángulo es

menor que para la alimentación del sistema con pilas alcalinas.

Si comparamos los resultados obtenidos en el caso de actuar sobre los motores y en el

caso de no actuar sobre ellos, podemos ver como la vibración de los motores es el factor más

importante en el funcionamiento del giroscopio.


81

Una vez analizado el funcionamiento del giroscopio, podemos concluir que pese a

realizar una calibración previa del sensor, la lectura al cabo de 60 segundos supone una

desviación importante respecto al valor ideal (0°). Esta desviación se incrementa si se realiza

una actuación sobre los motores.

También debemos tener en cuenta que el robot no estará siempre trabajando con un

ciclo de trabajo del 100%, sino que el ciclo de trabajo dependerá del ángulo de inclinación.

Por lo tanto, es bastante difícil realizar un cálculo certero del comportamiento del

giroscopio de HiTechnic, por lo que la solución utilizada para minimizar este error de

desviación será realizar pruebas sobre el sistema en funcionamiento.

La realización de estas pruebas ha servido para determinar que seguramente el

sistema funcione mejor si se alimenta con la batería oficial de LEGO.

El siguiente paso que se llevará a cabo será realizar una serie de mediciones con el

giroscopio en movimiento para comprobar su funcionamiento tras la calibración.

4.4.1.2. Pruebas dinámicas realizadas con el giroscopio de HiTechnic

En este apartado se comprobará el funcionamiento del giroscopio, inclinando el robot

manualmente y sin realizar la actuación sobre los motores. Los datos de cada una de las

simulaciones se encuentran disponibles en el anexo 4.

En primer lugar se situará el cuerpo del robot apoyado sobre una superficie. A

continuación se realizará una rotación de -180° y una rotación de +180° para devolverlo a la

posición inicial y comprobar la desviación respecto al ángulo esperado (0°).

Figura 71: Diagrama esquemático de la primera prueba dinámica del giroscopio


82

La gráfica temporal obtenida es la siguiente:

Gráfico 3: Respuesta del giroscopio a oscilaciones de ±180°

Si ampliamos la gráfica anterior a la zona de nuestro interés:

Gráfico 4: Respuesta del giroscopio a oscilaciones de ±180° (ampliación)

Se puede observar como después de cada oscilación completa el ángulo cada vez

difiere más del valor inicial. De hecho, tras la última oscilación podemos ver claramente como

empieza a actuar el valor del drift del giroscopio.

La segunda prueba consiste en intentar simular el comportamiento del robot con

oscilaciones de menor amplitud: inicialmente se sitúa el cuerpo del robot sobre una superficie.

A continuación se realiza una rotación de 90° para llevar el robot a la posición teórica de

equilibrio. Una vez equilibrado, se realizan pequeñas rotaciones (±20°). Finalmente se

devuelve el robot a su posición inicial para comprobar el ángulo de desviación respecto a 0°.

-200

-180

-160

-140

-120

-100

-80

-60

-40

-20

0

20

0,0

1

0,8

81

,75

2,6

2

3,4

9

4,3

65

,23

6,1

6,9

7

7,8

48

,71

9,5

8

10

,45

11

,32

12

,19

13

,06

13

,93

14

,81

5,6

7

16

,54

17

,41

18

,28

19

,15

Án

gulo

(°)

Tiempo(s)

-5

-4

-3

-2

-1

0

1

0,0

10

,85

1,6

92

,53

3,3

7

4,2

15

,05

5,8

9

6,7

37

,57

8,4

19

,25

10

,09

10

,93

11

,77

12

,61

13

,45

14

,29

15

,13

15

,97

16

,81

17

,65

18

,49

19

,33

Án

gulo

(°)

Tiempo(s)


83

Figura 72 Diagrama esquemático de la segunda prueba dinámica del giroscopio


Gráfico 5: Respuesta del giroscopio a pequeñas oscilaciones (±10°)

Como se puede observar en la figura anterior, tras la realización de oscilaciones de

±20° aproximadamente, el sensor presenta una desviación importante. Consultando los datos

obtenidos podemos ver que esta desviación es de casi 5°.

La última prueba que se va a realizar es similar a la anterior, con la diferencia que las

oscilaciones de esta prueba serán mucho más pequeñas en un intento por aproximarnos al

comportamiento real del robot, puesto que se espera que el robot responda con la suficiente

velocidad para que las oscilaciones sean lo más pequeñas posibles.

-120

-100

-80

-60

-40

-20

0

0,0

10

,88

1,7

5

2,6

23

,49

4,3

65

,23

6,1

6,9

7

7,8

4

8,7

19

,58

10

,45

11

,32

12

,19

13

,06

13

,93

14

,8

15

,67

16

,54

17

,41

18

,28

19

,15

Án

gulo

(°)

Tiempo(s)


84

Figura 73: Diagrama esquemático de la tercera prueba dinámica del giroscopio


Gráfico 6: Respuesta del giroscopio a pequeñas oscilaciones (±3°)

Se puede observar que en este caso el error que presenta el sistema es menor que en

el caso anterior, pero aun así sigue existiendo. En este caso la desviación final es de 2°.

Por lo tanto, el método que se utilizará para intentar reducir esta deriva será la

realización de pruebas utilizando el código final creado para mantener al robot en equilibrio.

Una vez analizado el comportamiento dinámico del giroscopio, el siguiente paso

realizado será describir brevemente el código con el que se pretende mantener en equilibrio

este sistema.

-100

-80

-60

-40

-20

0

20

0,0

10

,88

1,7

5

2,6

23

,49

4,3

65

,23

6,1

6,9

7

7,8

4

8,7

19

,58

10

,45

11

,32

12

,19

13

,06

13

,93

14

,8

15

,67

16

,54

17

,41

18

,28

19

,15

Án

gulo

(°)

Tiempo(s)


85

4.5.Código final

A continuación se describirá brevemente el código final realizado, detallando

únicamente las partes más importantes. Este código no es muy extenso por lo que no se ha

creído que sea necesario crear funciones con la finalidad de optimizar su estructura.

En primer lugar tenemos las inicializaciones, tanto de constantes como de variables.

//Constantes:

#define GYRO_PORT S4

#define T_muestreo_ms 10

#define muestras_offset 1000

//Constantes del PID:

#define Kp 60

#define Ki 1

#define Kd 20

//Variables:

float velocidad=0.0;

float angulo_actual=0.0;

float motor_actual=0.0;

//Variables del PID:

float error=0.0;

float error_old=0.0;

float P_error=0.0;

float I_error=0.0;

float D_error=0.0;

//Variables del giroscopio:

float offset_gyro=0.0;

float lectura_gyro = 0.0;

//Variables para guardar datos en un fichero datalog:

byte fileHandle;

short bytesWritten;

En segundo lugar tenemosla función principal. Definiremos el puerto en el que se

encuentra el giroscopio conectado:

//Función principal:

task main ()

{

//Definimos el puerto del giroscopio:

SetSensorHTGyro(GYRO_PORT);

A continuación preparamos el sistema para la calibración. Esta preparación incluye

asegurarnos que no hay actuación sobre los motores y esperar un tiempo prudencial para

colocar adecuadamente el robot. Una vez finalizada la preparación se utilizará un indicador

acústico para informar sobre el inicio de la calibración.


86

Debemos recordar que el proceso de calibración es muy importante para un

funcionamiento lo más correcto posible posteriormente, por lo que durante la calibración el

robot deberá permanecer completamente inmóvil.

//Nos aseguramos que no haya actuación sobre los motores:

Off(OUT_AC);

//Esperamos 10 segundos para poder colocar el robot

adecuadamente. Este paso

//es muy importante debido a que a continuación se realizará la

calibración

//del giroscopio, y necesitamos que el robot esté sin movimiento

y en la

//posición adecuada, que es en un ángulo de 90º respecto a la

superficie.

Wait(SEC_10);

//Aviso acústico para informar que empieza la calibración del

sensor.

PlaySound(SOUND_CLICK);

El siguiente paso será realizar la calibración del sensor, que ya se ha explicado

previamente. Una vez finalizado el proceso de calibración se indicará con una señal acústica.



{

offset_gyro += SensorHTGyro(GYRO_PORT);

Wait(T_muestreo_ms);

}

offset_gyro = offset_gyro / muestras_offset;

//Aviso acústico conforme ha finalizado la obtención del offset.


El último paso previo a la ejecución del bucle principal del programa será crear un

archivo de datalog en el que iremos guardando los valores de la variable o variables que

deseemos representar gráficamente para estudiar el comportamiento del robot.

//Borramos el archivo de datos anterior y lo creamos de nuevo:

DeleteFile("Dades.txt");

CreateFile("Dades.txt", 30000, fileHandle);

A continuación empieza el bucle principal en el que se realiza la adquisición de valores

del sensor, la ejecución del controlador PID y la actuación sobre los motores.


87

En primer lugar se realiza la adquisición de valores del sensor. El valor adquirido se

integra con la finalidad de obtener el ángulo de desviación del robot respecto a la posición de

equilibrio en la que se ha calibrado.

//Bucle para mantener el sistema en equilibrio:

for (int i=0;i<4000;i++)

{

//Lectura del giroscopio (velocidad angular) y obtención del

ángulo:


velocidad = lectura_gyro - offset_gyro;

angulo_actual += velocidad*(T_muestreo_ms/1000) -(13.7/2000);

El tiempo durante el que se quiere ejecutar el programa para mantener en equilibrio el

robot dependerá del número de iteraciones del bucle for y del periodo de muestreo que

tengamos. En este caso tenemos 4000 iteraciones con un periodo de muestre de 10 ms con lo

que obtenemos un tiempo de ejecución de 40 s.

En la obtención del ángulo de desviación podemos observar que se ha añadido un

valor de 13.7/2000. Este valor es muy importante porque ayuda a minimizar el efecto del drift

(aunque no lo elimine completamente).

La obtención de este valor ha sido experimental: una vez obtenido el controlador PID

adecuado para mantener el sistema en equilibrio, se observa que existe un drift que hace que

el robot vaya avanzando en una determinada dirección.

Se han realizado diversas pruebas con un tiempo de 20 segundos y se ha ido

corrigiendo el valor que se le añade al ángulo de lectura del giroscopio hasta reducir este

desplazamiento del robot.

El siguiente paso es transformar el ángulo del PID en la señal de actuación que

enviaremos a los motores, que será el ciclo de trabajo, comprendido entre -100 y +100.

El código correspondiente al PID es el siguiente:

//PID:

error_old = error;

error = 0 - angulo_actual;

P_error = error;

I_error += error_old;

D_error = error - error_old;

motor_actual = Kp*P_error + Ki*I_error + Kd*D_error;

A continuación se satura el ciclo de trabajo en sus valores extremos y se envía a los

motores:

//Saturación del actuador:

if (motor_actual > 100.0) {motor_actual = 100.0;}

if (motor_actual < -100.0) {motor_actual = -100.0;}

//Actuación sobre el motor:

OnFwd(OUT_AC,motor_actual);


88

Por último guardamos las variables que deseemos en el datalog. Posteriormente el

archivo datalog lo podremos abrir desde el ordenador para representar gráficamente los

datos.

//Guardamos los datos en el datalog:

string ang = NumToStr(angulo_actual);

string dc = NumToStr(motor_actual);

string write = StrCat(ang,",",dc);

WriteLnString(fileHandle,write, bytesWritten);

Una vez finalizada la ejecución del bucle for se indica mediante una señal acústica. Se

para la actuación sobre los motores y se cierra el fichero de datos creado. Si no lo cerráramos

no podríamos abrirlo posteriormente.

//Una vez finalizado el bucle, apagamos los motores y cerramos

el fichero

//de datos para poder leerlo posteriormente. También se utiliza

un indicador

//acústico para informar que ha finalizado el programa.

Off(OUT_AC);

CloseFile(fileHandle);


Wait(SEC_1);

}

El código completo se encuentra disponible en el anexo 2.

A continuación se realizará la comprobación del funcionamiento del programa para los

valores de las constantes del PID obtenidas en las simulaciones.


89

4.6.Pruebas finales del robot

Por último se comprobará el funcionamiento del robot con los controladores PID

determinados en las simulaciones. Para ello, se utilizará el código del anterior apartado y

únicamente se modificará el valor de las constantes Kp, Ki y Kd.

Se ha realizado dos tipos de pruebas: sin perturbar el sistema y perturbando el

sistema.

El parámetro escogido para comprobar el funcionamiento del robot es el ángulo de

desviación respecto al punto de equilibrio, tal y como se había realizado anteriormente en las

simulaciones.

Los valores de cada una de las pruebas se encuentran disponibles en el anexo 4.

4.6.1. Comportamiento del robot sin perturbaciones

En primer lugar se utilizará las constantes obtenidas en la simulación de la planta no

linealizada. Los valores de estas constantes son:

Kp = 60; Ki = 1; Kd = 20

La respuesta obtenida del robot es la siguiente:

Gráfico 7: Respuesta del robot para las constantes Kp=60; Ki=1; Kd=20

El sistema oscila indefinidamente. La amplitud de las oscilaciones es de 4° y la

frecuencia es bastante elevada, aproximadamente 5 oscilaciones por segundo.

-10

-8

-6

-4

-2

0

2

4

6

8

10

0,0

10

,71

,39

2,0

82

,77

3,4

64

,15

4,8

45

,53

6,2

26

,91

7,6

8,2

98

,98

9,6

71

0,3

61

1,0

51

1,7

41

2,4

31

3,1

21

3,8

11

4,5

15

,19

15

,88

16

,57

17

,26

17

,95

18

,64

19

,33

Án

gulo

(°)

Tiempo(s)


90

El motivo de este comportamiento podría ser que el valor de la constante Kp sea muy

elevado, o que el valor de la constante Kd sea muy reducido.

En segundo lugar se utilizará las constantes obtenidas en la simulación de la planta

linealizada. Los valores de estas constantes son:

Kp = 20; Ki = 1; Kd = 2



La respuesta del sistema mejora bastante respecto al caso anterior por los siguientes

motivos:

- En primer lugar, la amplitud máxima de las oscilaciones oscilación es de 2,2°.

- En segundo lugar, aunque las oscilaciones no cesen, el sistema es bastante más

estable que en el caso anterior puesto que las oscilaciones de amplitud elevada

(caídas del robot) se corrigen hasta que prácticamente se anula el error en el

ángulo.

El problema que se observa en este caso es el número de oscilaciones que necesita el

robot para mantenerse en equilibrio: pese a que su amplitud se va reduciendo, la frecuencia

sigue siendo elevada: 4 oscilaciones por segundo.

Para mejorar este comportamiento la solución sería similar a la comentada en el caso

anterior: se podría reducir la constante Kp o bien aumentar la constante Kd.

-2,5

-2

-1,5

-1

-0,5

0

0,5

1

1,5

2

0,0

10

,71

,39

2,0

82

,77

3,4

64

,15

4,8

45

,53

6,2

26

,91

7,6

8,2

98

,98

9,6

71

0,3

61

1,0

51

1,7

41

2,4

31

3,1

21

3,8

11

4,5

15

,19

15

,88

16

,57

17

,26

17

,95

18

,64

19

,33

Án

gulo

(°)

Tiempo(s)


91

En tercer lugar se utilizará las constantes obtenidas en la simulación de la planta

discretizada. Los valores de estas constantes son:

Kp = 30; Ki = 1; Kd = 1



En este caso podemos observar un comportamiento muy similar al de la planta no

linealizada con una diferencia:

Al cabo de aproximadamente 5 segundos, las oscilaciones se reducen y adquieren un

valor medio negativo. Con este controlador el robot no es capaz de mantener el equilibrio y

cae.

Para completar la simulación se ayuda al robot a que no caiga, con la finalidad de

observar la respuesta.

El robot (con ayuda) oscila indefinidamente. Las oscilaciones son de mayor amplitud

que en el caso de la planta no linealizada, y con una frecuencia de aproximadamente 4

oscilaciones por segundo.

Como las respuestas del robot son similares, si comparamos los valores del controlador

PID de la planta no linealizada y de la planta discretizada podemos observar que:

- La constante proporcional de la planta discretizada (Kp=30) es la mitad que la de la

planta no linealizada (Kp=60). Por lo tanto, en teoría las oscilaciones de la planta

discretizada deberían tener menor amplitud, pese a que el resultado de la prueba

sea el contrario.

-10

-8

-6

-4

-2

0

2

4

6

8

10

0,0

10

,71

,39

2,0

82

,77

3,4

64

,15

4,8

45

,53

6,2

26

,91

7,6

8,2

98

,98

9,6

71

0,3

61

1,0

51

1,7

41

2,4

31

3,1

21

3,8

11

4,5

15

,19

15

,88

16

,57

17

,26

17

,95

18

,64

19

,33

Án

gulo

(°)

Tiempo(s)


92

- La constante derivativa de la planta no linealizada (Kd=20) es veinte veces mayor

que la de la planta discretizada (Kd=1).

El significado de la comparación anterior es el siguiente: la importancia de la reducción

de la constante derivativa es mucho mayor a la de la reducción de la constante proporcional.

Este resultado se aplicará a continuación con la finalidad de optimizar la respuesta del robot.

Tras estas tres primeras simulaciones, el controlador PID que mejor funciona en el

robot es el que se había obtenido con la planta linealizada.

El siguiente paso será la optimización del comportamiento del robot. Para ello,

utilizaremos como base los valores originales del controlador PID de la planta linealizada:

Kp = 20; Ki = 1; Kd = 2

Se llevará a cabo dos acciones: reducir la constante proporcional y aumentar la

constante derivativa.

Tras la realización de varias pruebas con distintos valores para ambas constantes, el

comportamiento óptimo del robot se ha obtenido con los siguientes valores:

Kp = 10; Ki = 1; Kd = 20



Como se puede observar en el gráfico anterior, la respuesta del robot es más

constante que en los casos anteriores y presenta menos oscilaciones. Además, la frecuencia de

oscilación se reduce a 1 oscilación cada 2,5 segundos.

-2,5

-2

-1,5

-1

-0,5

0

0,5

1

1,5

2

2,5

0,0

10

,71

,39

2,0

82

,77

3,4

64

,15

4,8

45

,53

6,2

26

,91

7,6

8,2

98

,98

9,6

71

0,3

61

1,0

51

1,7

41

2,4

31

3,1

21

3,8

11

4,5

15

,19

15

,88

16

,57

17

,26

17

,95

18

,64

19

,33

Án

gulo

(°)

Tiempo(s)


93

El siguiente paso consiste en analizar el comportamiento del robot frente a

perturbaciones.

4.6.2. Comportamiento del robot frente a perturbaciones

Como se ha determinado en las pruebas anteriores, el controlador PID obtenido con la

planta discretizada no permitía al robot mantener el equilibrio, por lo que se descarta utilizarlo

para comprobar la respuesta del robot frente a perturbaciones.

Por lo tanto se realizará las pruebas con el controlador PID de la planta no linealizada,

el de la planta linealizada y el óptimo que se ha obtenido en el apartado anterior.

En primer lugar se utiliza el controlador PID de la planta no linealizada. El problema

que existe es que el robot está oscilando indefinidamente. No es capaz de responder a la

perturbación y cae.

Por lo tanto, este controlador no es válido.

El siguiente controlador que se utilizará es el de la planta linealizada. La respuesta

obtenida del robot es la siguiente:

Gráfico 11: Respuesta del robot frente a una perturbación con constantes Kp=20; Ki=1; Kd=2

El robot soporta perturbaciones de aproximadamente 9° sin caer. El robot presenta

bastantes oscilaciones hasta que consigue equilibrarse, como se había visto en la simulación

sin perturbación.

-6

-4

-2

0

2

4

6

8

10

0,0

10

,71

,39

2,0

82

,77

3,4

64

,15

4,8

45

,53

6,2

26

,91

7,6

8,2

98

,98

9,6

71

0,3

61

1,0

51

1,7

41

2,4

31

3,1

21

3,8

11

4,5

15

,19

15

,88

16

,57

17

,26

17

,95

18

,64

19

,33

Án

gulo

(°)

Tiempo(s)


94

Pese a la gran cantidad de oscilaciones, el robot se mantiene en equilibrio.

Por lo tanto, se demuestra que con un controlador PID obtenido en las simulaciones

podemos mantener el robot en equilibrio frente a perturbaciones de amplitud similar a las

introducidas en las simulaciones.

Por último se utilizará el controlador optimizado del apartado anterior con el que se

espera obtener un mejor comportamiento.


Gráfico 12: Respuesta del robot frente a una perturbación con constantes Kp=10; Ki=1; Kd=20

La respuesta del robot mejora respecto al caso anterior. Por ejemplo, para una

perturbación de 10° se estabiliza en menos de 2 segundos y únicamente necesita 2

oscilaciones.

Por lo tanto, el control PID con el que se ha optimizado el comportamiento del robot

es el siguiente:

Kp = 10; Ki = 1; Kd = 20

Recapitulando, se ha demostrado que es posible mantener en equilibrio el robot frente

a perturbaciones con un controlador obtenido en las simulaciones.

Debido a la diferencia entre el modelo real y las simulaciones, debemos modificar el

controlador PID obtenido de las simulaciones para optimizar el comportamiento del robot.

-15

-10

-5

0

5

10

15

0,0

10

,71

,39

2,0

82

,77

3,4

64

,15

4,8

45

,53

6,2

26

,91

7,6

8,2

98

,98

9,6

71

0,3

61

1,0

51

1,7

41

2,4

31

3,1

21

3,8

11

4,5

15

,19

15

,88

16

,57

17

,26

17

,95

18

,64

19

,33

Án

gulo

(°)

Tiempo(s)

Conclusiones

95

5. Conclusiones

A continuación se resumen las conclusiones más importantes que se han extraído en la

realización de este proyecto:

- En primer lugar, a modo de resumen, las tareas realizadas en este proyecto han sido

las siguientes:

Se ha realizado la modelización del sistema real, obteniendo las ecuaciones

que describen su dinámica.

Con el modelo obtenido se ha realizado diversas simulaciones con

diferentes grados de aproximación a la realidad.

Se ha obtenido un controlador para cada modelo simulado.

Se ha comprobado el funcionamiento de estos controladores sobre el

sistema real. El resultado final ha sido satisfactorio puesto que con un

controlador obtenido en las simulaciones se puede mantener el robot en

equilibrio.

- En segundo lugar, se debe recordar que la modelización del sistema real que se ha

realizado ha sido con el sistema carro-péndulo. En esta modelización se ha

considerado varios elementos ideales, destacando el ejemplo el cuerpo del robot,

modelado como una varilla de masa uniformemente distribuida.

Pese a haber introducido ciertos parámetros restrictivos con la finalidad de realizar

una mejor aproximación del modelo a la realidad (por ejemplo, las restricciones en

los motores), el controlador óptimo obtenido para el control del robot no es ninguno

de los obtenidos en las simulaciones.

Todo ello quiere decir que los dos factores clave en la modelización del sistema son:

la modelización física del péndulo y las restricciones de los motores del robot.

- En tercer lugar, se puede concluir que existe una estrecha relación entre simulación y

pruebas en el sistema real, puesto que se realimentan mutuamente para que el

modelo y el sistema real sean lo más parecidos posibles.

- En cuarto lugar, uno de los aspectos de mayor importancia en la implementación

sobre el sistema real es el sensor giroscópico. Como se ha estudiado, el sensor

utilizado dista mucho de la idealidad utilizada en las simulaciones, principalmente

por las derivas provocadas por las vibraciones de los motores.

- En quinto y último lugar, pese a que existan diferencias entre el modelo realizado y el

sistema real, se ha comprobado que con uno de los controles obtenidos en las

simulaciones el sistema se mantiene en equilibrio y es capaz de responder a

perturbaciones por lo que parece que el modelo y el sistema real tienen similitudes.

Posibles mejoras

96

5.1.Posibles mejoras

Aunque los resultados finales obtenidos hayan sido satisfactorios, a continuación se

detallan algunas posibles mejoras que se podrían realizar:

En primer lugar, se podría realizar una mejor aproximación del sistema real al modelo.

Esta mejora debería ir encaminada en dos direcciones:

1. Realizar una descripción física más detallada del cuerpo robot con la finalidad de

obtener un modelo del péndulo más similar al cuerpo del robot, en vez de utilizar

como modelo de péndulo una varilla ideal.

2. Realizar una descripción dinámica más detallada de los motores de LEGO

Mindstorms. Esta mejora debe centrarse principalmente en la obtención de las

curvas de arranque del motor.

En segundo lugar, se podría estudiar con mayor profundidad el comportamiento del

sensor giroscópico de HiTechnic, con la finalidad de poder linealizar su comportamiento en el

mayor grado posible.

Debemos tener en cuenta que aunque el factor que más deriva provoca es la vibración

de los motores, puede ser que esta deriva afecte en distinto grado a cada sensor. Es decir,

podría ser que por motivos de fabricación cada sensor tenga una deriva distinta frente a la

vibración de los motores.

En tercer y último lugar, la mejora más importante que se puede realizar es el control

de posición del robot.

Para llevar a cabo el control de posición del robot deberemos utilizar la segunda

ecuación obtenida en las ecuaciones que describen la dinámica del sistema. Esta ecuación

describe el movimiento lineal del robot.

Para llevar a cabo el control de posición, en las simulaciones se debería realizar otro

lazo de control. Es decir, el lazo de control principal sería el que se ha realizado en este

proyecto, cuya finalidad es mantener el robot en equilibrio. El siguiente lazo de control sería el

que utilizaríamos para desplazar al robot, como se muestra en el siguiente diagrama:

Posibles mejoras

97

Figura 74: Control de posición y control de ángulo

En la figura anterior, la parte más importante es que la dinámica de la planta que

describe el comportamiento lineal del sistema servirá para obtener el ángulo de referencia del

robot. El motivo es el siguiente:

Si queremos que el robot avance, no podemos mantenerlo con un ángulo de 90°

respecto a la superficie sobre la que se desplaza, debemos inclinarlo ligeramente en la

dirección de avance para que pueda desplazarse sin caer, es decir, el punto de equilibrio del

robot no será de 90° respecto a la superficie sobre la que se desplaza.

En la realización práctica, para obtener el desplazamiento recorrido por el robot

podemos recurrir a los tacómetros de los que disponen los motores de LEGO Mindstorms.

Conociendo la rotación de estos, el radio de las ruedas utilizadas y el tiempo de rotación

podemos determinar el ciclo de trabajo que se enviará a los motores para realizar el control de

posición. Este control de posición también puede realizarse con un controlador PID.

Anexos

98

6. Anexos

6.1.Anexo 1: Información sobre LEGO Mindstorms NXT 2.0

La plataforma LEGO Mindstorms NXT 2.0 es un sistema formado por una unidad

central procesadora (conocida como Brick) y un conjunto de elementos con los que puede

interactuar: sensores, actuadores y comunicaciones.

En primer lugar, tenemos la unidad central que utiliza dos microcprocesadores:

- En primer lugar, un microprocesador principal de la compañía Atmel, serie ARM7,

modelo AT91SAM7S256. Este microprocesador es de 32 bits, incluye 256 Kb de

memoria Flash, 64 Kb de RAM externa y trabaja a una frecuencia de 48 MHz.

- En segundo lugar, un microprocesador secundario de la compañía Atmel, serie AVR,

modelo ATmega48. Este microprocesador es de 8 bits, incluye 4 Kb de memoria

Flash, 512 bytes de RAM externa y trabaja a una frecuencia de 8 MHz.

Esta unidad central cuenta con cuatro puertos de entrada para señales analógicas o

digitales (aunque se pueden aumentar mediante la conexión de un multiplexor no oficial) y

tres puertos de salida que además son capaces de obtener una señal de entrada de los

encoders de los motores.

Los sensores que se pueden conectar a los puertos de entrada son los siguientes:

- Oficiales de LEGO: Sensor de luz, sensor de contacto, sensor de color y sensor

de ultrasonidos.

- No oficiales: Sensor de temperatura, sensor de sonido, sensor de ángulo de

rotación, sensor de aceleración, sensor barométrico, sensor giroscópico,

sensor de infrarrojos, sensor electro-óptico de proximidad, sensor para la

detección de persona o animales, sensor magnético y sensor de brújula. La

mayoría de estos sensores son fabricados por HiTechnic.

Por otro lado, a los puertos de salida lo más usual es conectar los motores oficiales de

LEGO Mindstorms NXT 2.0.

Todas las comunicaciones entre unidad central y sensores/actuadores se realizan

mediante una interfaz de conexión 6-wire (twisted pair).

Anexos

99

La unidad central también es capaz de comunicarse con otros elementos mediante dos

tipos de comunicación:

- USB 2.0: la unidad central dispone de un puerto de entrada y salida con el estándar

USB 2.0 con Full Speed (12 Mbit/s). Este puerto se suele utilizar para recibir

programas realizados desde un ordenador y para enviar los datos recogidos por

algún sensor.

- Bluetooth: la unidad central dispone de comunicación Bluetooth mediante el

módulo Bluecore 4 v2.0 +EDR System de la compañía CSR. Este modulo cuenta con

una memoria RAM interna de 48 Kb, una memoria externa FLASH de 8 Mbit y

funciona a una frecuencia de 26 MHz. Esta comunicación se suele utilizar o bien

para transmitir datos a un ordenador o bien para comunicarse con un dispotivo

como puede ser un teléfono movil para interactuar.

El esquema básico de interacción del Brick de LEGO es el siguiente:

Figura 75: Esquema básico de interacción del Brick de LEGO.

Anexos

100

6.2.Anexo 2: Códigos de Bricx Command Center

6.2.1. Código para la prueba de velocidad del robot

// Explicación: Este código sirve para determinar la velocidad lineal

// máxima de desplazamiento del robot. Para ello, colocamos el robot

// sobre una superficie plana y sin inclinación. El robot se moverá

// durante 5 segundos con un ciclo de trabajo de los motores máximo.

// Conociendo la distancia recorrida (la medimos) y el tiempo,

// podremos conocer la velocidad máxima de los motores.

task main()

{

OnFwd(OUT_AC,100);

Wait(SEC_5);

Off(OUT_AC);

}

// Resultado experimental: distancia recorrida = 3.6 m

// 3.6 m / 5 s = 0.72 m/s

6.2.2. Código para la prueba de velocidad del robot

// Explicación: arrancamos el motor con una rampa, modificando el

// ciclo de trabajo desde 0 hasta 100, y cuando vemos que el robot ya

// se mueve activamos el sensor de contacto del puerto 1, y finalmente

// visualizamos el ciclo de trabajo mínimo para el cual el robot se

// mueve.

int ciclo;

task main()

{

SetSensor(IN_1,SENSOR_TOUCH);

ciclo = 0;

do

{

OnFwd(OUT_AC,cicle);

cicle++;

TextOut(0, LCD_LINE1, "Ciclo: ");

NumOut (7*6, LCD_LINE1, ciclo);

Wait(SEC_5);

}

while (SENSOR_1 == 0 && ciclo<100)

Off(OUT_AC);

TextOut(0, LCD_LINE1, "Ciclo: ");

NumOut (7*6, LCD_LINE1, ciclo);

Wait(SEC_5);

}

//Resultado obtenido: ciclo de trabajo mínimo para que se mueva el

robot: 10%

Anexos

101

6.2.3. Código para las pruebas del giroscopio de HiTechnic

//Constantes:


#define T 10/1000


#define T_calibracion 10

//Variables:




float offset=0.0;



byte fileHandle;

short bytesWritten;

//Menú principal:

task main ()

{




Off(OUT_AC);

//Esperamos 1segundo

Wait(1000);

//Aviso acústico para informar que empieza la calibración del sensor.




{

offset += SensorHTGyro(GYRO_PORT);

Wait(T_calibracion);

}

offset = offset / muestras_offset;






//Bucle para la lectura del sensor:

for (int i=0;i<6000;i++)

{

//Lectura del giroscopio y obtención del ángulo:


velocidad = lectura_gyro - offset;

angulo_actual += velocidad*T;

Anexos

102


Wait(T*1000);

}



WriteLnString(fileHandle,ang, bytesWritten);

//Una vez finalizado el bucle, apagamos los motores y cerramos el

//fichero de datos para poder leerlo posteriormente. También se

//utiliza un indicador acústico para informar que ha finalizado el

//programa.

Off(OUT_AC);



Wait(1000);

}

6.2.4. Código final para mantener en equilibrio el robot

//Alumno: Alex Calvó Gallego

//Tutor: Albert Oller Pujol

//Máster en Ingeniería Electrónica de la Universidad Rovira y Virgili.

//Septiembre de 2012

//Constantes:


#define T_muestreo_ms 10


//Constantes del PID:

#define Kp 30

#define Ki 1

#define Kd 1

//Variables:



float motor_actual=0.0;

//Variables del PID:

float error=0.0;

float error_old=0.0;

float P_error=0.0;

float I_error=0.0;

float D_error=0.0;


float offset_gyro=0.0;


Anexos

103


byte fileHandle;

short bytesWritten;

//Función principal:

task main ()

{




Off(OUT_AC);

//Esperamos 10 segundos para poder colocar el robot adecuadamente.

//Este paso es muy importante debido a que a continuación se realizará

//la calibración del giroscopio, y necesitamos que el robot esté sin

//movimiento y en la posición adecuada, que es en un ángulo de 90º

//respecto a la superficie.

Wait(SEC_10);

//Aviso acústico para informar que empieza la calibración del sensor.




{

offset_gyro += SensorHTGyro(GYRO_PORT);


}

offset_gyro = offset_gyro / muestras_offset;






//Bucle para mantener el sistema en equilibrio:

for (int i=0;i<2000;i++)

{

//Lectura del giroscopio y obtención del ángulo:


velocidad = lectura_gyro - offset_gyro;

angulo_actual += velocidad*(T_muestreo_ms/1000) -(13.75/2000);

//PID:

error_old = error;

error = 0 - angulo_actual;

P_error = error;

I_error += error_old;

D_error = error - error_old;

motor_actual = Kp*P_error + Ki*I_error + Kd*D_error;

//Saturación del actuador:

if (motor_actual > 100.0) {motor_actual = 100.0;}

if (motor_actual < -100.0) {motor_actual = -100.0;}

Anexos

104

//Actuación sobre el motor:

OnFwd(OUT_AC,motor_actual);



string dc = NumToStr(motor_actual);

string write = StrCat(ang,",",dc);

WriteLnString(fileHandle,write, bytesWritten);



}

//Una vez finalizado el bucle, apagamos los motores y cerramos el

//fichero de datos para poder leerlo posteriormente. También se

//utiliza un indicador acústico para informar que ha finalizado el

//programa.

Off(OUT_AC);



Wait(SEC_1);

}

Anexos

105

6.3.Anexo 3: Instrucciones de montaje del robot

Las instrucciones de montaje del robot se encuentran disponibles en un documento

PDF que se encuentra en el CD que contiene la documentación realizada en este proyecto. Este

documento PDF se encuentra en la carpeta Anexo 3 (BUILDING INSTRUCTIONS).

6.4.Anexo 4: Documentos de Microsoft Excel

Los documentos con los datos utilizados para la realización de las gráficas de este

proyecto se encuentran disponibles en el CD que contiene la documentación realizada en este

proyecto.

Estos documentos se encuentran en la carpeta Anexo 4 (EXCELS). Los documentos de

Microsoft Excel disponibles son los siguientes:

1. Tn con pilas: datos obtenidos para determinar el periodo natural de oscilación del

robot alimentado con pilas alcalinas.

2. Tn con batería: datos obtenidos para determinar el periodo natural de oscilación

del robot alimentado con la batería oficial de LEGO.

3. Pruebas sintonizador planta no linealizada: constantes Kp, Ki y Kd obtenidas en

las simulaciones para determinar los parámetros del controlador.

4. Calibración y desviación del giroscopio: datos obtenidos para calibrar y

determinar la desviación del giroscopio (sin movimiento).

5. Pruebas dinámicas del girosopio: datos obtenidos moviendo manualmente el

robot para comprobar el funcionamiento del giroscopio.

6. Pruebas robot: datos obtenidos para distintos valores de Kp, Ki y Kd para el

controlador PID del robot.

6.5.Anexo 5: Simulaciones de Matlab

Las simulaciones con Matlab utilizadas en la realización de este proyecto se

encuentran disponibles en el CD que contiene la documentación realizada en este proyecto.

Estas simulaciones se encuentran en la carpeta Anexo 5 (MATLAB). Las simulaciones de

Matlab disponibles son las siguientes:

Anexos

106

1. LGR: Contiene dos simulaciones del LGR:

a. Planta linealizada LGR: Simulación utilizada para visualizar el LGR con la

planta linealizada.

b. Verificación LGR: Simulación utilizada para verificar el funcionamiento de

la planta linealizada con un controlador proporcional.

2. Tiempo continuo: Contiene las simulaciones realizadas en tiempo continuo.

a. Planta no linealizada: Simulaciones realizadas con el modelo de planta sin

linealizar.

i. Modelo original: Modelo original que se va a simular.

ii. Sintonizador PID: Modelo utilizado para sintonizar el PID.

iii. Modelo con perturbación: Modelo utilizado para verificar el

comportamiento de la planta no linealizada frente a

perturbaciones.

iv. Modelo con restricciones: Modelo con perturbación al que se le

añaden las restricciones de los actuadores.

b. Planta no linealizada:

i. Modelo con perturbación y restricciones: Modelo utilizado para

comprobar el funcionamiento de la planta no linealizada frente a

perturbaciones, añadiendo las restricciones de los actuadores.

3. Discretización: Contiene el archivo en el que se realiza la discretización de la planta

y del controlador y su simulación.

NOTA: Para ejecutar cualquier simulación en primer lugar se debe ejecutar el archivo

.m que contiene las constantes necesarias para la simulación. Una vez ejecutado este archivo,

la simulación se iniciará automáticamente (excepto en el caso del Sintonizador PID).

Referencias

107

7. Referencias

[1] Lrobotikas. [Página web online]. Última actualización: 28 de diciembre de 2012 [fecha de consulta: 13-01-2012] [Acceso gratuito]

<http://lrobotikas.net/wiki/index.php?title=P%C3%A1gina_Principal>

[2] NXTLOG 2.0 Projects. [Página web online]. Última actualización: 2 de marzo de 2012 [fecha de consulta: 7-12-2011] [Acceso gratuito]

<http://us.mindstorms.lego.com/en-us/Community/NXTLog/DisplayProjectList.aspx?tag=gyro>

[3] FIRST LEGO League. [Página web online]. Última actualización: 11 de marzo de 2012 [fecha de consulta: 16-01-2012] [Acceso gratuito]

<http://www.firstlegoleague.es/ >

[4] A LEGO-Based Control Experiment. [Página web online, documento PDF]. Peter Gawthrop y Euan McGookin publicado en octubre de 2004 [fecha de consulta: 22-01-2012] [Acceso gratuito]

<http://eprints.gla.ac.uk/588/1/GawMcG04.pdf >

[5] NXT Two Wheels balancing robot tricks & keys. [Página web online, Blog]. Tomas Arribas, publicado el 4 de enero de 2011 [fecha de consulta: 17-01-2012] [Acceso gratuito]

<http://nxttwowheels.blogspot.com.es/ >

[6] NXT Two Wheels balancing robot tricks & keys. [Página web online]. Publicado en 2007 [fecha de consulta: 17-01-2012] [Acceso gratuito]

<http://www.philohome.com/nxtway/nxtway.htm>

[7] NXT Segway with Rider. [Página web online]. Dave Parker, publicado en 2008 [fecha de consulta: 17-01-2012] [Acceso gratuito]

<http://www.nxtprograms.com/NXT2/segway/index.html>

http://lrobotikas.net/wiki/index.php?title=P%C3%A1gina_Principal

http://us.mindstorms.lego.com/en-us/Community/NXTLog/DisplayProjectList.aspx?tag=gyro

http://www.firstlegoleague.es/

http://eprints.gla.ac.uk/588/1/GawMcG04.pdf

http://nxttwowheels.blogspot.com.es/

http://www.philohome.com/nxtway/nxtway.htm

http://www.nxtprograms.com/NXT2/segway/index.html

Referencias

108

[8] NXTway-GS (Self-Balancing Two-Wheeled Robot) Controller Design. [Página web online]. Yorihisa Yamamoto, publicado el 11 de marzo de 2008, última actualización el 1 de mayo de 2009 [fecha de consulta: 19-01-2012] [Acceso gratuito]

<http://www.mathworks.com/matlabcentral/fileexchange/19147 >

[9] Steve’s Legway. [Página web online]. Yorihisa Yamamoto, publicado en 2002 [fecha de consulta: 18-01-2012] [Acceso gratuito]

<http://www.teamhassenplug.org/robots/legway/ >

[10] Lagrangiano (Wikipedia). [Página web online]. Última actualización 26 de julio de 2012 [fecha de consulta: 14-02-2012] [Acceso gratuito] <http://es.wikipedia.org/wiki/Lagrangiano> [11] Cart-pole system: Equations of motion. [Página web online, documento PDF]. Fecha de publicación: 2010 [fecha de consulta: 16-02-2012] [Acceso gratuito] <http://es.wikipedia.org/wiki/Lagrangiano>

[12] Correct equations for the dynamics of the cart-pole system. [Página web online, documento PDF]. Razvan V.Florian. Fecha de publicación: 11 de julio de 2005, última actualización: 10 de febrero de 2007 [fecha de consulta: 20-02-2012] [Acceso gratuito]

<http://www.coneural.org/florian/papers/05_cart_pole.pdf>

[13] Neuronlike Adaptive Elements That Can Solve Difficult Learning Control Problems. [Página

web online, documento PDF]. Andrew G.Barto. Fecha de publicación: 1 de agosto de 1982,

revisado el 20 de abril de 1983 [fecha de consulta: 20-02-2012] [Acceso gratuito]

<http://webdocs.cs.ualberta.ca/~sutton/papers/barto-sutton-anderson-83.pdf>

[14] Newton’s laws of motion. [Página web online]. Última actualización el 19 de julio de 2012

[fecha de consulta: 23-02-2012] [Acceso gratuito]

<http://en.wikipedia.org/wiki/Newton%27s_laws_of_motion#Newton.27s_first_law>

http://www.mathworks.com/matlabcentral/fileexchange/19147

http://www.teamhassenplug.org/robots/legway/

http://es.wikipedia.org/wiki/Lagrangiano

http://es.wikipedia.org/wiki/Lagrangiano

http://www.coneural.org/florian/papers/05_cart_pole.pdf

http://webdocs.cs.ualberta.ca/~sutton/papers/barto-sutton-anderson-83.pdf

http://en.wikipedia.org/wiki/Newton%27s_laws_of_motion#Newton.27s_first_law

Referencias

109

[15] Coulomb model of friction. [Página web online]. Última actualización el 24 de agosto de

2011 [fecha de consulta: 24-02-2012] [Acceso gratuito]

<http://mech.subwiki.org/wiki/Coulomb_model_of_friction>

[16] Simulink. [Página web online]. Mathworks [fecha de consulta: 20-02-2012] [Acceso gratuito]

<http://www.mathworks.es/products/simulink/>

[17] Fagor. [Página web online]. [fecha de consulta: 02-03-2012] [Acceso gratuito] <http://pdf.archiexpo.com/pdf/fagor/small-domestic-appliances/474-5585-_40.html>

[18] NXT DC Rechargable Battery. [Página web online]. Página oficial de Lego mundial [fecha de consulta: 03-02-2012] [Acceso gratuito] <http://shop.lego.com/en-US/NXT-DC-Rechargeable-Battery-9693> [19] El péndulo simple. [Página web online]. Universidad del País Vasco [fecha de consulta: 03-02-2012] [Acceso gratuito] <http://www.sc.ehu.es/sbweb/fisica/dinamica/trabajo/pendulo/pendulo.htm> [20] Lego Digital Designer. [Página web online]. Página oficial de LEGO en España [fecha de consulta: 10-02-2012] [Acceso gratuito]

<http://ldd.lego.com/>

[21] Sistema de control (Wikipedia). [Página web online]. Última actualización 25 de julio de 2012 [fecha de consulta: 27-02-2012] [Acceso gratuito] <http://es.wikipedia.org/wiki/Sistema_de_control> [22] Retroalimentación (Wikipedia). [Página web online]. Última actualización 13 de agosto de 2012 [fecha de consulta: 27-02-2012] [Acceso gratuito] <http://es.wikipedia.org/wiki/Realimentaci%C3%B3n> [23] Sistema de control (Wikipedia). [Página web online]. Última actualización 10 de agosto de 2012 [fecha de consulta: 27-02-2012] [Acceso gratuito] <http://es.wikipedia.org/wiki/Proporcional_integral_derivativo>

http://mech.subwiki.org/wiki/Coulomb_model_of_friction

http://www.mathworks.es/products/simulink/

http://pdf.archiexpo.com/pdf/fagor/small-domestic-appliances/474-5585-_40.html

http://shop.lego.com/en-US/NXT-DC-Rechargeable-Battery-9693

http://www.sc.ehu.es/sbweb/fisica/dinamica/trabajo/pendulo/pendulo.htm

http://ldd.lego.com/

http://es.wikipedia.org/wiki/Sistema_de_control

http://es.wikipedia.org/wiki/Realimentaci%C3%B3n

http://es.wikipedia.org/wiki/Proporcional_integral_derivativo

Referencias

110

[24] El control proporcional. [Página web online]. Instrumentación y control [fecha de consulta: 28-02-2012] [Acceso gratuito]

<http://www.instrumentacionycontrol.net/es/curso-control-pid-practico/364-el-control-

proporcional-definiciones-practicas-y-precisas>

[25] Automatic PID Tuning. [Página web online]. Mathworks [fecha de consulta: 05-03-2012] [Acceso gratuito]

<http://www.mathworks.es/help/sldo/examples/pid-tuning-with-actuator-constraints.html>

[26] NXT Motor Internals. [Página web online]. Publicado en febrero de 2007, última actualización en noviembre de 2008 [fecha de consulta: 10-03-2012] [Acceso gratuito]

<http://www.philohome.com/nxtmotor/nxtmotor.htm>

[27] Sistemas de Segundo orden (Wikipedia). [Página web online]. Última actualización: 27 de junio de 2012 [fecha de consulta: 26-03-2012] [Acceso gratuito] <http://es.wikipedia.org/wiki/Sistemas_de_segundo_orden>

[28] c2d. [Página web online]. Mathworks [fecha de consulta: 10-04-2012] [Acceso gratuito]

<http://www.mathworks.es/help/toolbox/ident/ref/c2d.html>

[29] Zero-order hold (Wikipedia). [Página web online]. Última actualización: 30 de abril de 2012 [fecha de consulta: 10-04-2012] [Acceso gratuito]

<http://en.wikipedia.org/wiki/Zero-order_hold>

[30] Bilinear transform (Wikipedia). [Página web online]. Última actualización: 15 de junio de 2012 [fecha de consulta: 10-04-2012] [Acceso gratuito]

<http://en.wikipedia.org/wiki/Bilinear_transform>

[31] Interpolación (Wikipedia). [Página web online]. Última actualización: 14 de agosto de 2012 [fecha de consulta: 22-04-2012] [Acceso gratuito]

<http://es.wikipedia.org/wiki/Interpolaci%C3%B3n>

http://www.instrumentacionycontrol.net/es/curso-control-pid-practico/364-el-control-proporcional-definiciones-practicas-y-precisas

http://www.instrumentacionycontrol.net/es/curso-control-pid-practico/364-el-control-proporcional-definiciones-practicas-y-precisas

http://www.mathworks.es/help/sldo/examples/pid-tuning-with-actuator-constraints.html

http://www.philohome.com/nxtmotor/nxtmotor.htm

http://es.wikipedia.org/wiki/Sistemas_de_segundo_orden

http://www.mathworks.es/help/toolbox/ident/ref/c2d.html

http://en.wikipedia.org/wiki/Zero-order_hold

http://en.wikipedia.org/wiki/Bilinear_transform

http://es.wikipedia.org/wiki/Interpolaci%C3%B3n

Referencias

111

[32] NXTway-GS (Self-Balancing Two-Wheeled Robot) Controller Design. [Página web online]. Yorihisa Yamamoto, publicado el 11 de marzo de 2008, última actualización el 1 de mayo de 2009 [fecha de consulta: 19-01-2012] [Acceso gratuito]

<http://www.mathworks.com/matlabcentral/fileexchange/19147 >

[33] Lego Digital Designer. [Página web online]. Página oficial de LEGO en España [fecha de consulta: 10-02-2012] [Acceso gratuito]

<http://ldd.lego.com/>

[34] NXT-G (Wikipedia). [Página web online]. Última actualización: 17 de agosto de 2012 [fecha de consulta: 02-05-2012] [Acceso gratuito]

<http://en.wikipedia.org/wiki/Lego_Mindstorms_NXT#NXT-G>

[35] LEGO Mindstorms NXT support for Matlab. [Página web online]. MathWorks [fecha de consulta: 02-05-2012] [Acceso gratuito]

<http://www.mathworks.es/academia/lego-mindstorms-nxt-software/legomindstorms-

matlab.html?sec=start>

[36] LABVIEW Add-ons for LEGO MINDSTORMS NXT. [Página web online]. National Instruments [fecha de consulta: 02-05-2012] [Acceso gratuito]

<http://www.ni.com/white-paper/4435/en>

[37] Programming Languages (Wikipedia). [Página web online]. Última actualización: 17 de agosto de 2012 [fecha de consulta: 02-05-2012] [Acceso gratuito]

<http://en.wikipedia.org/wiki/Lego_Mindstorms#Programming_languages_2>

[38] Next Byte Codes, Not eXactly C, and SuperPro C. [Página web online]. Última actualización: 2011 [fecha de consulta: 02-05-2012] [Acceso gratuito]

<http://en.wikipedia.org/wiki/Lego_Mindstorms#Programming_languages_2>

[39] Bricx Command Center 3.3. [Página web online]. Última actualización: 13 de marzo de 2011 [fecha de consulta: 02-05-2012] [Acceso gratuito]

<http://bricxcc.sourceforge.net/>

http://www.mathworks.com/matlabcentral/fileexchange/19147

http://ldd.lego.com/

http://en.wikipedia.org/wiki/Lego_Mindstorms_NXT#NXT-G

http://www.mathworks.es/academia/lego-mindstorms-nxt-software/legomindstorms-matlab.html?sec=start

http://www.mathworks.es/academia/lego-mindstorms-nxt-software/legomindstorms-matlab.html?sec=start

http://www.ni.com/white-paper/4435/en

http://en.wikipedia.org/wiki/Lego_Mindstorms#Programming_languages_2

http://en.wikipedia.org/wiki/Lego_Mindstorms#Programming_languages_2

http://bricxcc.sourceforge.net/

Referencias

112

[40] Giróscopo (Wikipedia). [Página web online]. Última actualización: 31 de julio de 2012 [fecha de consulta: 09-05-2012] [Acceso gratuito]

<http://es.wikipedia.org/wiki/Gir%C3%B3scopo>

[41] NXT Gyro Sensor. [Página web online]. HiTechnic [fecha de consulta: 09-05-2012] [Acceso gratuito]

<https://www.hitechnic.com/cgi-bin/commerce.cgi?preadd=action&key=NGY1044>

[42] Gyro offset and drift. [Página web online]. Fecha de publicación: 3 de noviembre de 2010 [fecha de consulta: 11-05-2012] [Acceso gratuito]

<http://nxttime.wordpress.com/2010/11/03/gyro-offset-and-drift/>

[43] Media aritmética (Wikipedia). [Página web online]. Última actualización: 8 de agosto de 2012 [fecha de consulta: 12-05-2012] [Acceso gratuito]

<http://es.wikipedia.org/wiki/Media_aritm%C3%A9tica>

[44] Integración numérica: regla del rectángulo (Wikipedia). [Página web online]. Última actualización: 9 de junio de 2012 [fecha de consulta: 14-05-2012] [Acceso gratuito]

<http://es.wikipedia.org/wiki/Integraci%C3%B3n_num%C3%A9rica#Regla_del_rect.C3.A1ngulo>

http://es.wikipedia.org/wiki/Gir%C3%B3scopo

https://www.hitechnic.com/cgi-bin/commerce.cgi?preadd=action&key=NGY1044

http://nxttime.wordpress.com/2010/11/03/gyro-offset-and-drift/

http://es.wikipedia.org/wiki/Media_aritm%C3%A9tica

http://es.wikipedia.org/wiki/Integraci%C3%B3n_num%C3%A9rica#Regla_del_rect.C3.A1ngulo

TITULACIÓN: Máster en Ingeniería...

Documents

Transcript of TITULACIÓN: Máster en Ingeniería...